From af8b7337903bbff01f1f9c4d8aa64937ce95ba79 Mon Sep 17 00:00:00 2001
From: BoucherS_cp <XceedBoucherS@users.noreply.github.com>
Date: Wed, 11 Feb 2015 20:04:30 +0000
Subject: [PATCH]

---
 .../AssemblyVersionInfo.cs                    |    2 +-
 .../AssemblyVersionInfo.cs                    |    2 +-
 .../Theme.xaml                                |   44 +-
 .../AssemblyVersionInfo.cs                    |    2 +-
 .../AssemblyVersionInfo.cs                    |    2 +-
 .../Controls/FocusElementManager.cs           |    2 +-
 .../Controls/LayoutFloatingWindowControl.cs   |   11 +-
 .../Xceed.Wpf.AvalonDock/DockingManager.cs    |    2 +-
 .../Xceed.Wpf.AvalonDock/Themes/generic.xaml  |    6 +-
 .../(DataVirtualization)/VirtualList.cs       |   14 +-
 .../VirtualListEnumerator.cs                  |    5 +-
 .../(DataVirtualization)/VirtualPage.cs       |   33 +
 .../DataGridForeignKeyDescription.cs          |   51 +-
 .../DataTableForeignKeyDescription.cs         |   40 +-
 .../CollectionViewGroupExtensions.cs          |  125 +-
 .../ConnectionErrorChangedEventManager.cs     |   87 +
 .../ConnectionStateChangedEventManager.cs     |   87 +
 .../DataGridCollectionView.cs                 |  858 +--
 .../DataGridCollectionViewBase.cs             |  796 ++-
 .../DataGridCollectionViewEnumerator.cs       |   11 +-
 .../DataGridCollectionViewGroup.cs            |  649 ++-
 .../DataGridCollectionViewGroupRoot.cs        |   54 +-
 .../DataGridCollectionViewGroupSort.cs        |   16 +-
 .../DataGridCollectionViewSource.cs           |   17 +-
 .../DataGridCollectionViewSourceBase.cs       |    2 +
 .../DataGridDetailDescription.cs              |    4 +-
 .../(CollectionView)/DataGridItemProperty.cs  |    4 +-
 .../DataGridItemPropertyBase.cs               |  336 +-
 .../DataGridItemPropertyCollection.cs         |   30 +
 .../DataGridLINQPageManager.cs                |   76 +-
 .../DataGridSortDescriptionCollection.cs      |    1 -
 .../DataGridUnboundItemProperty.cs            |   20 -
 .../DataGridVirtualizingCollectionViewBase.cs |   22 +-
 .../(CollectionView)/DeferredOperation.cs     |   59 +-
 .../DeferredOperationManager.cs               |  272 +-
 .../DistinctValuesDictionary.cs               |   10 +-
 ...DistinctValuesRefreshNeededEventManager.cs |   87 +
 .../(CollectionView)/GroupSortComparer.cs     |    9 +-
 ...rtyGroupSortStatNameChangedEventManager.cs |   92 +
 .../PostBatchCollectionChangedEventManager.cs |   78 +
 .../PreBatchCollectionChangedEventManager.cs  |   78 +
 .../PropertyDetailDescription.cs              |   97 +-
 ...roxyApplyingFilterCriteriasEventManager.cs |   87 +
 ...roxyAutoFilterValuesChangedEventManager.cs |   93 +
 .../ProxyCollectionRefreshEventManager.cs     |   87 +
 ...oxyGroupDescriptionsChangedEventManager.cs |   93 +
 ...roxySortDescriptionsChangedEventManager.cs |   93 +
 .../(CollectionView)/QueryableExtensions.cs   |   83 +-
 .../(CollectionView)/RawItemMap.cs            |  145 +
 .../RootGroupChangedEventManager.cs           |   87 +
 .../(ForeignKeys)/ForeignKeyConfiguration.cs  |  407 +-
 .../(ForeignKeys)/ForeignKeyContentControl.cs |   24 +-
 .../CustomItemContainerGenerator.cs           | 4969 +++++++++--------
 .../(Generator)/DataItemDataProvider.cs       |  109 +
 .../(Generator)/DataItemDataProviderBase.cs   |   35 +
 .../(Generator)/EmptyDataItemDataProvider.cs  |   70 +
 .../(Generator)/GeneratorNode.cs              |    2 +-
 .../(Generator)/GeneratorNodeFactory.cs       |  171 +-
 .../(Generator)/GeneratorNodeHelper.cs        |   27 +-
 .../(Generator)/GroupGeneratorNode.cs         |    2 +-
 .../NotifyCollectionChangedGeneratorNode.cs   |    2 +-
 .../(Generator)/RangeSelectionVisitor.cs      |   41 +-
 .../(Generator)/SelectAllVisitor.cs           |    2 +-
 .../VisibilityChangingEventManager.cs         |   72 +
 ...AutoScrollCurrentItemSourceTriggersEnum.cs |   39 +
 .../AutoScrollCurrentItemTriggersEnum.cs      |   37 +
 .../(enums)/DistinctValuesConstraintEnum.cs   |    3 +-
 .../Xceed.Wpf.DataGrid/AssemblyVersionInfo.cs |    2 +-
 .../Src/Xceed.Wpf.DataGrid/AutoResetFlag.cs   |   34 +
 .../AutoResetFlagFactory.cs                   |  156 +
 ...llCurrentItemSourceTriggersRestrictions.cs |  105 +
 .../ColumnManagerCellAutomationPeer.cs        |    6 +-
 .../Automation/DataGridGroupAutomationPeer.cs |   78 +-
 .../HeaderFooterItemAutomationPeer.cs         |   20 +-
 .../Src/Xceed.Wpf.DataGrid/Cell.cs            |  975 ++--
 ...lContentStringFormatChangedEventManager.cs |   74 +
 .../{DataGridCheckBox.cs => CheckBox.cs}      |    2 +
 ...hildColumnVisibilityChangedEventManager.cs |   75 +
 ...nericContentTemplateSelectorResources.xaml |    9 +-
 .../Src/Xceed.Wpf.DataGrid/Column.cs          |  132 +-
 .../ColumnAddGroupCommand.cs                  |  116 +
 .../Src/Xceed.Wpf.DataGrid/ColumnBase.cs      | 1127 ++--
 .../Xceed.Wpf.DataGrid/ColumnCollection.cs    |  269 +-
 .../Src/Xceed.Wpf.DataGrid/ColumnCommand.cs   |   62 +
 .../Xceed.Wpf.DataGrid/ColumnGroupCommand.cs  |   26 +
 .../Xceed.Wpf.DataGrid/ColumnManagerCell.cs   |  580 +-
 .../Xceed.Wpf.DataGrid/ColumnManagerRow.cs    |   19 +-
 .../ColumnReorderingEvent.cs                  |    5 +-
 .../Xceed.Wpf.DataGrid/ColumnSortCommand.cs   |  261 +
 .../ColumnSynchronizationManager.cs           | 1097 ++++
 .../FilterCriterionToNullableBoolConverter.cs |   59 -
 .../Converters/StatResultConverter.cs         |  112 -
 .../Converters/StringFormatConverter.cs       |    2 +-
 .../Converters/StringFormatMultiConverter.cs  |   50 +
 .../Src/Xceed.Wpf.DataGrid/CurrencyManager.cs |   28 +-
 .../Src/Xceed.Wpf.DataGrid/DataCell.cs        |  108 +-
 .../Xceed.Wpf.DataGrid/DataGridBindingInfo.cs |   19 +-
 .../Src/Xceed.Wpf.DataGrid/DataGridContext.cs | 1388 +++--
 .../Src/Xceed.Wpf.DataGrid/DataGridControl.cs | 1082 ++--
 .../Xceed.Wpf.DataGrid/DataGridException.cs   |   58 +
 .../DataGridInternalException.cs              |   10 +
 .../DataGridItemContainerManager.cs           |  158 +
 .../Xceed.Wpf.DataGrid/DataGridItemsHost.cs   |   83 +-
 .../DataGridVirtualizingPanel.cs              |    2 -
 .../DataItemEventDescriptor.cs                |  117 +
 .../DataItemEventDescriptorBase.cs            |   80 +
 .../DataItemEventDescriptorFactory.cs         |  166 +
 .../DataItemPropertyDescriptor.cs             |  105 +
 .../DataItemPropertyDescriptorBase.cs         |  344 ++
 .../DataItemPropertyDescriptorFactory.cs      |  297 +
 .../DataItemTypeDescriptionProvider.cs        |   48 +
 .../DataItemTypeDescriptor.cs                 |  254 +
 .../Src/Xceed.Wpf.DataGrid/DataRow.cs         |   70 +-
 .../DefaultCellEditorSelector.xaml            |   66 +-
 .../DefaultCellEditorSelector.xaml.cs         |   32 +-
 .../DefaultDetailConfiguration.cs             |   75 +-
 .../Xceed.Wpf.DataGrid/DetailConfiguration.cs |  890 ++-
 .../DetailConfigurationCollection.cs          |   23 +-
 .../Src/Xceed.Wpf.DataGrid/DropMarkAdorner.cs |   12 +-
 .../(Clipboard)/ClipboardExporterBase.cs      |  423 +-
 .../Xceed.Wpf.DataGrid/Export/FormatHelper.cs |   35 -
 .../Src/Xceed.Wpf.DataGrid/FieldNameMap.cs    |   77 +
 .../FilterCriteria/AndFilterCriterion.cs      |    3 +-
 .../FilterCriteria/EndsWithFilterCriterion.cs |    3 +-
 .../FilterCriteria/FilterCriterion.cs         |    4 +-
 .../FilterCriteria/FilterExpressionHelper.cs  |  108 +
 .../FilterCriteria/OrFilterCriterion.cs       |    2 +-
 .../RelationalFilterCriterion.cs              |    8 +-
 .../StartsWithFilterCriterion.cs              |    1 -
 .../Src/Xceed.Wpf.DataGrid/FilterParser.cs    |   73 +-
 .../FittedWidthRequestedEventArgs.cs          |   51 +
 ...nfigNotifyCollectionChangedEventManager.cs |   68 +
 .../GenericContentTemplateSelector.cs         |  400 ++
 .../Xceed.Wpf.DataGrid/GlobalSuppressions.cs  |   13 -
 .../Src/Xceed.Wpf.DataGrid/Group.cs           |  533 +-
 .../Src/Xceed.Wpf.DataGrid/GroupByControl.cs  |   16 +-
 .../Src/Xceed.Wpf.DataGrid/GroupByItem.cs     |   20 +-
 .../Src/Xceed.Wpf.DataGrid/GroupExtensions.cs |   20 +
 .../Xceed.Wpf.DataGrid/GroupHeaderControl.cs  |  148 +-
 .../GroupLevelDescription.cs                  |  124 +-
 .../GroupLevelIndicatorPane.cs                |  197 +-
 .../Src/Xceed.Wpf.DataGrid/GroupingHelper.cs  |   63 +-
 .../Xceed.Wpf.DataGrid/HeaderFooterItem.cs    |  289 +-
 .../HierarchicalGroupByControl.cs             |   17 +-
 .../HierarchicalGroupByControlNode.cs         |   17 +-
 .../HierarchicalGroupByItem.cs                |  263 +-
 .../HierarchicalGroupLevelIndicatorPane.cs    |   58 +-
 .../IDataGridItemContainerExtensions.cs       |  121 +
 ...ationRule.cs => IGroupLevelDescription.cs} |   48 +-
 .../Xceed.Wpf.DataGrid/ItemPropertyNameMap.cs |  176 +
 .../Xceed.Wpf.DataGrid/ItemsSourceHelper.cs   |  485 +-
 .../LateGroupLevelDescription.cs              |  431 ++
 .../Src/Xceed.Wpf.DataGrid/Log.cs             |  408 +-
 .../Markup/DataGridThemeResourceDictionary.cs |   45 +
 .../FrameworkThemeResourceDictionary.cs       |   31 +
 .../Markup/SharedResourceDictionary.cs        |  283 +
 .../Markup/SharedThemeResourceDictionary.cs   |  414 ++
 .../Markup/ThemeConverter.cs                  |   12 +-
 .../Src/Xceed.Wpf.DataGrid/Markup/ThemeKey.cs |   79 +-
 ...ifyCollectionChangedEventArgsExtensions.cs |   36 +
 .../NotifyRangeCollectionChangedEventArgs.cs  |   51 +
 .../ObservableColumnCollection.cs             |  220 +
 .../Xceed.Wpf.DataGrid/RecyclingManager.cs    |  210 +-
 .../RequestBringIntoViewWeakEventManager.cs   |   81 +
 ...yBringIntoViewAndFocusCurrentEventArgs.cs} |   29 +-
 .../Src/Xceed.Wpf.DataGrid/Row.cs             |  471 +-
 .../Src/Xceed.Wpf.DataGrid/RowSelector.cs     |   20 +-
 .../Src/Xceed.Wpf.DataGrid/RowSelectorPane.cs |  421 +-
 .../Src/Xceed.Wpf.DataGrid/ScrollTip.cs       |  127 +-
 .../SelectedCellsStorage.cs                   |  800 ++-
 .../SelectedItemsStorage.cs                   |  823 ++-
 ...s => SelectionChangedInternalEventArgs.cs} |   25 +-
 .../Xceed.Wpf.DataGrid/SelectionChanger.cs    |   30 +-
 .../Xceed.Wpf.DataGrid/SelectionManager.cs    | 1288 +++--
 .../Xceed.Wpf.DataGrid/SelectionRangePoint.cs |  142 +
 .../SelectionRangeWithItems.cs                |  117 +-
 .../Settings/XmlColumnWidthStruct.cs          |   84 -
 .../Xceed.Wpf.DataGrid/SharedListStruct.cs    |  118 +
 .../Src/Xceed.Wpf.DataGrid/SortingHelper.cs   |  240 -
 .../InvalidSourcePropertyNameException.cs     |   73 -
 .../Xceed.Wpf.DataGrid/Stats/StatFunction.cs  |   81 +-
 .../Stats/StatFunctionCollection.cs           |   99 +-
 .../Stats/StatFunctionComparer.cs             |    5 +-
 .../StringFormatDataTemplate.cs               |  282 +
 .../ToggleColumnSortCommand.cs                |  318 ++
 .../Src/Xceed.Wpf.DataGrid/UnboundColumn.cs   |   24 +-
 .../UpdateColumnSortCommand.cs                |  209 +
 .../Utils/Collections/DoubleFenwickTree.cs    |   41 +
 .../Utils/Collections/FenwickTree.Generic.cs  |  134 +
 .../Utils/Collections/IndexWeakHeapSort.cs    |    6 +-
 .../LongestIncreasingSubsequence.cs           |  119 +
 .../Utils/Collections/ObservableHashList.cs   |  476 +-
 .../Utils/PropertyHelper.cs                   |   36 +
 .../Utils/WeakEventHandler.cs                 |    9 +-
 .../Wpf/BreadthFirstSearchTreeTraversal.cs    |   73 +
 ...BreadthFirstSearchTreeTraversalStrategy.cs |   27 +
 .../Wpf/DepthFirstSearchTreeTraversal.cs      |   73 +
 .../DepthFirstSearchTreeTraversalStrategy.cs  |   27 +
 .../Utils/Wpf/DispatcherHelper.cs             |    2 +-
 .../Utils/Wpf/DragDrop/AutoScrollManager.cs   |  236 +
 .../Utils/Wpf/DragDrop/DragSourceManager.cs   |  411 +-
 .../Wpf/ITreeTraversal.cs}                    |   15 +-
 .../Utils/Wpf/ITreeTraversalStrategy.cs       |   24 +
 .../Wpf/Markup/XceedResourceDictionary.cs     |   31 +-
 .../Utils/Wpf/TreeHelper.cs                   |  117 +-
 .../ValueChangeDataItemPropertyDescriptor.cs  |  241 +
 .../FixedColumnCountChangedEventArgs.cs       |   60 +
 .../FixedColumnCountEventManager.cs           |   78 +
 .../IColumnInfoCollection.Generic.cs          |   45 +
 .../IColumnNameCollection.cs                  |   44 +
 .../TableViewColumnVirtualizationManager.cs   |  849 +--
 ...ableViewColumnVirtualizationManagerBase.cs | 1440 +++++
 .../UpdateMeasureRequiredEventManager.cs      |   25 +-
 .../VirtualizingFixedCellSubPanel.cs          |   95 +-
 .../(Enums)/FlattenDetailBindingModeEnum.cs   |   27 +
 .../(Enums)/MasterDetailLayoutModeEnum.cs     |   26 +
 .../ColumnReorderingDragSourceManager.cs      |  979 ++--
 .../Views/(TableflowView)/TableflowView.cs    |   10 +-
 .../(TableflowView)/TableflowViewItemsHost.cs |  965 ++--
 .../Views/DataGridScrollViewer.cs             |  304 +-
 .../Views/DictionaryTheme.cs                  |   26 +-
 .../Views/FixedCellPanel.cs                   |  837 ++-
 .../Views/FixedCellSubPanel.cs                |  201 +-
 .../Views/IVirtualizingCellsHost.cs           |    4 +-
 .../Views/MasterDetailLayoutAttribute.cs      |   42 +
 .../Views/NavigationHelper.cs                 |  556 ++
 .../Views/ScrollViewerTemplateHelper.cs       |  186 +
 .../Views/ScrollingCellsDecorator.cs          |   11 +-
 .../Views/SynchronizedScrollViewer.cs         |    2 -
 .../Src/Xceed.Wpf.DataGrid/Views/TableView.cs |   61 +-
 .../Views/TableViewEndPageInfo.cs             |   89 +
 .../Views/TableViewFullPageInfo.cs            |  130 +
 .../Views/TableViewHeaderFooterPanel.cs       |  312 +-
 .../Views/TableViewItemsHost.cs               | 2175 ++++----
 .../Xceed.Wpf.DataGrid/Views/TableViewPage.cs |  103 +
 .../Views/TableViewPageInfo.cs                |  179 +
 .../Views/TableViewPartialPageInfo.cs         |   47 +
 .../Views/TableViewScrollViewer.cs            |  186 +-
 .../Views/TableViewStartPageInfo.cs           |   89 +
 .../Src/Xceed.Wpf.DataGrid/Views/Theme.cs     |   14 +-
 .../Xceed.Wpf.DataGrid/Views/UIViewBase.cs    |    7 +-
 .../Src/Xceed.Wpf.DataGrid/Views/ViewBase.cs  |  212 +-
 .../Views/ViewPropertyAttribute.cs            |   35 +-
 .../VirtualizingCellCollection.cs             |  528 +-
 .../VisibleColumnsUpdatedEventArgs.cs         |   42 +
 .../Xceed.Wpf.DataGrid.csproj                 |  171 +-
 .../Resources/TableView.Aero.Graphics.xaml    |    5 +-
 .../Aero/TableView.Aero.normalcolor.xaml      |   86 +-
 .../Aero/TableflowView.Aero.normalcolor.xaml  |  109 +-
 .../Resources/Aero2.normalcolor.Controls.xaml | 2177 ++++++++
 .../Aero2.normalcolor.Resources.xaml          |   20 +-
 .../TableView.Aero2.normalcolor.Graphics.xaml |  188 +-
 .../Aero2/TableView.Aero2.normalcolor.xaml    |   45 +
 .../TableflowView.Aero2.normalcolor.xaml      | 1823 +++---
 .../Classic/Resources/Classic.Resources.xaml  |    4 +-
 .../Classic.systemcolor.Graphics.xaml         |    6 +-
 .../TableView.Classic.systemcolor.xaml        |   56 +-
 .../TableflowView.Classic.systemcolor.xaml    |   89 +-
 .../themes/Common/Common.Resources.xaml       |   90 +-
 .../TableView.GridElementTemplates.xaml       |   11 +-
 .../TableflowView.GridElementTemplates.xaml   |   10 +-
 .../TableViewScrollViewer.generic.xaml        |    2 +-
 .../Resources/TableView.Luna.Graphics.xaml    |    5 +-
 .../themes/Luna/TableView.Luna.homestead.xaml |   59 +-
 .../themes/Luna/TableView.Luna.metallic.xaml  |   59 +-
 .../Luna/TableView.Luna.normalcolor.xaml      |   59 +-
 .../Luna/TableflowView.Luna.homestead.xaml    |   92 +-
 .../Luna/TableflowView.Luna.metallic.xaml     |   77 +-
 .../Luna/TableflowView.Luna.normalcolor.xaml  |   73 +-
 .../Resources/TableView.Royale.Graphics.xaml  |    5 +-
 .../Royale/TableView.Royale.normalcolor.xaml  |   59 +-
 .../TableflowView.Royale.normalcolor.xaml     |   75 +-
 .../TableView.Windows7.Graphics.xaml          |    6 +-
 .../Windows7/Resources/Windows7.Controls.xaml |    5 +-
 .../themes/Windows7/TableView.Windows7.xaml   |   75 +-
 .../Windows7/TableflowView.Windows7.xaml      |   87 +-
 .../Resources/TableView.Zune.Graphics.xaml    |    5 +-
 .../Zune/TableView.Zune.normalcolor.xaml      |   59 +-
 .../Zune/TableflowView.Zune.normalcolor.xaml  |   59 +-
 .../themes/aero.normalcolor.xaml              |    9 +-
 .../themes/aero2.normalcolor.xaml             |  158 +-
 .../Xceed.Wpf.DataGrid/themes/classic.xaml    |    9 +-
 .../Xceed.Wpf.DataGrid/themes/generic.xaml    |   42 +-
 .../themes/luna.homestead.xaml                |    8 +-
 .../themes/luna.metallic.xaml                 |   10 +-
 .../themes/luna.normalcolor.xaml              |    9 +-
 .../themes/royale.normalcolor.xaml            |    9 +-
 .../themes/zune.normalcolor.xaml              |    9 +-
 .../CodeFiles/DataGridView.xaml.txt           |    3 +-
 .../CodeFiles/DateTimeView.xaml.txt           |   33 +-
 .../CodeFiles/NumericView.xaml.txt            |   69 +-
 .../PropertyGridAttributesView.xaml.cs.txt    |   29 +-
 .../PropertyGridAttributesView.xaml.txt       |    5 +-
 .../PropertyGridPropertiesSourceView.xaml.txt |    2 +-
 .../CodeFiles/RadialGaugeView.xaml.txt        |    4 +-
 .../CodeFiles/RangeSliderView.xaml.cs.txt     |   29 +
 .../CodeFiles/RangeSliderView.xaml.txt        |   45 +-
 ...cs.txt => StyleableWindowView.xaml.cs.txt} |   80 +-
 ....xaml.txt => StyleableWindowView.xaml.txt} |   18 +-
 .../CodeFiles/ThemingDataGridView.xaml.cs.txt |    2 +-
 .../TokenizedTextBoxView.xaml.cs.txt          |  152 +
 .../CodeFiles/TokenizedTextBoxView.xaml.txt   |  327 ++
 .../MainWindow.xaml                           |   19 +-
 .../Properties/AssemblyInfo.cs                |    4 +-
 .../Properties/Resources.resx                 |    6 +-
 .../Samples/DataGrid/Views/DataGridView.xaml  |    3 +-
 .../Samples/DateTime/Views/DateTimeView.xaml  |   33 +-
 .../Samples/Numeric/Views/NumericView.xaml    |   63 +-
 .../Views/PropertyGridAttributesView.xaml     |    5 +-
 .../Views/PropertyGridAttributesView.xaml.cs  |    6 +-
 .../RangeSlider/Views/RangeSliderView.xaml    |   45 +-
 .../RangeSlider/Views/RangeSliderView.xaml.cs |   29 +
 .../OpenSourceImages/TokenizedTextBox.png     |  Bin 0 -> 11336 bytes
 .../Text/Views/TokenizedTextBoxView.xaml      |   74 +
 .../Text/Views/TokenizedTextBoxView.xaml.cs   |   63 +
 .../Samples/Window/Resources/FancyStyles.xaml |    2 +-
 ...ndowView.xaml => StyleableWindowView.xaml} |   12 +-
 ...ew.xaml.cs => StyleableWindowView.xaml.cs} |   18 +-
 .../Xceed.Wpf.Toolkit.LiveExplorer.csproj     |   28 +-
 .../Xceed.Wpf.Toolkit.LiveExplorer/app.config |   18 +-
 .../Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs  |    2 +-
 .../Implementation/ButtonSpinner.cs           |   23 +
 .../Themes/Aero2.NormalColor.xaml             |   25 +-
 .../ButtonSpinner/Themes/Generic.xaml         |   23 +-
 .../Implementation/CollectionControl.cs       |   18 +
 .../CollectionControlDialog.xaml              |    2 +-
 .../CollectionControlDialog.xaml.cs           |   10 +-
 .../Themes/Aero2.NormalColor.xaml             |   15 +-
 .../CollectionControl/Themes/Generic.xaml     |    3 +-
 .../ColorCanvas/Implementation/ColorCanvas.cs |    2 +
 .../ColorPicker/Themes/Aero2.NormalColor.xaml |    1 +
 .../ColorPicker/Themes/Generic.xaml           |    2 +
 .../Core/Primitives/InputBase.cs              |   28 +
 .../Core/Primitives/Selector.cs               |   49 +-
 .../Core/Primitives/UpDownBase.cs             |   52 +-
 .../Core/Utilities/DateTimeUtilities.cs       |   36 +
 .../Implementation/DateTimePicker.cs          |   22 +-
 .../Themes/Aero2.NormalColor.xaml             |   21 +-
 .../DateTimePicker/Themes/Generic.xaml        |   21 +-
 .../Implementation/DateTimeParser.cs          |   15 +-
 .../Implementation/DateTimeUpDown.cs          |  160 +-
 .../Themes/Aero2.NormalColor.xaml             |   20 +-
 .../DateTimeUpDown/Themes/Generic.xaml        |   18 +-
 .../MessageBox/Implementation/MessageBox.cs   |   22 -
 .../Implementation/MultiLineTextEditor.cs     |   11 +-
 .../Themes/Aero2.NormalColor.xaml             |  229 +-
 .../Themes/Aero2.NormalColor.xaml             |  156 +-
 .../NumericUpDown/Themes/Generic.xaml         |   21 +-
 .../Converters/IsStringEmptyConverter.cs}     |   25 +-
 .../Implementation/CustomPropertyItem.cs      |    5 +
 .../Definitions/EditorDefinitionBase.cs       |   26 +-
 .../DescriptorPropertyDefinitionBase.cs       |   10 +
 .../Implementation/IPropertyContainer.cs      |    1 +
 .../ObjectContainerHelperBase.cs              |   21 +-
 .../PropertyDefinitionBaseCollection.cs       |   37 +-
 .../Implementation/PropertyGrid.cs            |   21 +-
 .../Implementation/PropertyItem.cs            |    2 +-
 .../Implementation/PropertyItemBase.cs        |    7 +-
 .../Themes/Aero2.NormalColor.xaml             |   64 +-
 .../PropertyGrid/Themes/Generic.xaml          |   66 +-
 .../Converters/SliderThumbWidthConverter.cs   |    1 +
 .../RangeSlider/Implementation/RangeSlider.cs |  232 +-
 .../RangeSlider/Themes/Aero2.NormalColor.xaml |  591 +-
 .../RangeSlider/Themes/Generic.xaml           |  648 +--
 .../RichTextBoxFormatBarManager.cs            |   19 +-
 .../StyleableWindowClippingBorderConverter.cs |    2 +-
 .../Themes/Aero2/Common.xaml                  |    2 +-
 .../Themes/Generic/Common.xaml                |    2 +-
 .../TimePicker/Implementation/TimePicker.cs   |   51 +-
 .../TimePicker/Themes/Aero2.NormalColor.xaml  |    3 +-
 .../TimePicker/Themes/Generic.xaml            |    3 +-
 .../Themes/Aero2.NormalColor.xaml             |   20 +-
 .../TimeSpanUpDown/Themes/Generic.xaml        |   18 +-
 .../Wizard/Implementation/Wizard.cs           |   12 +
 .../Xceed.Wpf.Toolkit.csproj                  |    5 +-
 .../Zoombox/Themes/Aero2.NormalColor.xaml     |    2 +-
 .../Zoombox/Themes/Generic.xaml               |    2 +-
 .../Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs  |    5 +-
 .../Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs  |    2 +-
 .../Implementation/ButtonSpinner.cs           |   23 +
 .../Themes/Aero2.NormalColor.xaml             |   25 +-
 .../ButtonSpinner/Themes/Generic.xaml         |   23 +-
 .../Implementation/CollectionControl.cs       |   18 +
 .../CollectionControlDialog.xaml              |    2 +-
 .../CollectionControlDialog.xaml.cs           |   10 +-
 .../Themes/Aero2.NormalColor.xaml             |   15 +-
 .../CollectionControl/Themes/Generic.xaml     |    3 +-
 .../ColorCanvas/Implementation/ColorCanvas.cs |    2 +
 .../ColorPicker/Themes/Aero2.NormalColor.xaml |    1 +
 .../ColorPicker/Themes/Generic.xaml           |    2 +
 .../Core/Primitives/InputBase.cs              |   28 +
 .../Core/Primitives/Selector.cs               |   49 +-
 .../Core/Primitives/UpDownBase.cs             |   52 +-
 .../Core/Utilities/DateTimeUtilities.cs       |   36 +
 .../Implementation/DateTimePicker.cs          |   22 +-
 .../Implementation/DateTimeParser.cs          |   15 +-
 .../Implementation/DateTimeUpDown.cs          |  160 +-
 .../Themes/Aero2.NormalColor.xaml             |   20 +-
 .../DateTimeUpDown/Themes/Generic.xaml        |   18 +-
 .../MessageBox/Implementation/MessageBox.cs   |   22 -
 .../Implementation/MultiLineTextEditor.cs     |   11 +-
 .../Themes/Aero2.NormalColor.xaml             |  229 +-
 .../Themes/Aero2.NormalColor.xaml             |  156 +-
 .../NumericUpDown/Themes/Generic.xaml         |   21 +-
 .../Converters/IsStringEmptyConverter.cs      |   28 +-
 .../Implementation/CustomPropertyItem.cs      |    5 +
 .../Definitions/EditorDefinitionBase.cs       |   26 +-
 .../DescriptorPropertyDefinitionBase.cs       |   10 +
 .../Implementation/IPropertyContainer.cs      |    1 +
 .../ObjectContainerHelperBase.cs              |   21 +-
 .../PropertyDefinitionBaseCollection.cs       |   37 +-
 .../Implementation/PropertyGrid.cs            |   21 +-
 .../Implementation/PropertyItem.cs            |    2 +-
 .../Implementation/PropertyItemBase.cs        |    7 +-
 .../Themes/Aero2.NormalColor.xaml             |   58 +-
 .../PropertyGrid/Themes/Generic.xaml          |   60 +-
 .../Converters/SliderThumbWidthConverter.cs   |    1 +
 .../RangeSlider/Implementation/RangeSlider.cs |  232 +-
 .../RangeSlider/Themes/Aero2.NormalColor.xaml |  591 +-
 .../RangeSlider/Themes/Generic.xaml           |  648 +--
 .../RichTextBoxFormatBarManager.cs            |   19 +-
 .../StyleableWindowClippingBorderConverter.cs |    2 +-
 .../Themes/Aero2/Common.xaml                  |    2 +-
 .../TimePicker/Implementation/TimePicker.cs   |   51 +-
 .../TimePicker/Themes/Aero2.NormalColor.xaml  |    3 +-
 .../TimePicker/Themes/Generic.xaml            |    3 +-
 .../Themes/Aero2.NormalColor.xaml             |   20 +-
 .../TimeSpanUpDown/Themes/Generic.xaml        |   18 +-
 .../Wizard/Implementation/Wizard.cs           |   12 +
 .../Xceed.Wpf.Toolkit.csproj                  |    7 +-
 .../Zoombox/Themes/Aero2.NormalColor.xaml     |    2 +-
 .../Zoombox/Themes/Generic.xaml               |    2 +-
 .../Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs  |    5 +-
 433 files changed, 40598 insertions(+), 19462 deletions(-)
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionErrorChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionStateChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesRefreshNeededEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ItemPropertyGroupSortStatNameChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PostBatchCollectionChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PreBatchCollectionChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyApplyingFilterCriteriasEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyAutoFilterValuesChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyCollectionRefreshEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyGroupDescriptionsChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxySortDescriptionsChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RawItemMap.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RootGroupChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProvider.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProviderBase.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/EmptyDataItemDataProvider.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/VisibilityChangingEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemSourceTriggersEnum.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemTriggersEnum.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlag.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlagFactory.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoScrollCurrentItemSourceTriggersRestrictions.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CellContentStringFormatChangedEventManager.cs
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/{DataGridCheckBox.cs => CheckBox.cs} (95%)
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ChildColumnVisibilityChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnAddGroupCommand.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCommand.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnGroupCommand.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSortCommand.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSynchronizationManager.cs
 delete mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToNullableBoolConverter.cs
 delete mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StatResultConverter.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatMultiConverter.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemContainerManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptor.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorBase.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorFactory.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptor.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorBase.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorFactory.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptionProvider.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptor.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FieldNameMap.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterExpressionHelper.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FittedWidthRequestedEventArgs.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ForeignKeyConfigNotifyCollectionChangedEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GenericContentTemplateSelector.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/IDataGridItemContainerExtensions.cs
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/{ValidationRules/FilterExpressionValidationRule.cs => IGroupLevelDescription.cs} (51%)
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemPropertyNameMap.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/LateGroupLevelDescription.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/DataGridThemeResourceDictionary.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/FrameworkThemeResourceDictionary.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedResourceDictionary.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedThemeResourceDictionary.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyCollectionChangedEventArgsExtensions.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyRangeCollectionChangedEventArgs.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ObservableColumnCollection.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RequestBringIntoViewWeakEventManager.cs
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/{Stats/InvalidValueException.cs => RequestingDelayBringIntoViewAndFocusCurrentEventArgs.cs} (53%)
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/{Settings/UserSettingsEnum.cs => SelectionChangedInternalEventArgs.cs} (59%)
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangePoint.cs
 delete mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Settings/XmlColumnWidthStruct.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SharedListStruct.cs
 delete mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SortingHelper.cs
 delete mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/InvalidSourcePropertyNameException.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/StringFormatDataTemplate.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ToggleColumnSortCommand.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UpdateColumnSortCommand.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/DoubleFenwickTree.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/FenwickTree.Generic.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/LongestIncreasingSubsequence.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/PropertyHelper.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversal.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversalStrategy.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversal.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversalStrategy.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/AutoScrollManager.cs
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/{Print/IPrintInfo.cs => Utils/Wpf/ITreeTraversal.cs} (67%)
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/ITreeTraversalStrategy.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ValueChangeDataItemPropertyDescriptor.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountChangedEventArgs.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountEventManager.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnInfoCollection.Generic.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnNameCollection.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManagerBase.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/FlattenDetailBindingModeEnum.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/MasterDetailLayoutModeEnum.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/MasterDetailLayoutAttribute.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/NavigationHelper.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollViewerTemplateHelper.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewEndPageInfo.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewFullPageInfo.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPage.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPageInfo.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPartialPageInfo.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewStartPageInfo.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VisibleColumnsUpdatedEventArgs.cs
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Controls.xaml
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableView.Aero2.normalcolor.xaml
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/{StylableWindowView.xaml.cs.txt => StyleableWindowView.xaml.cs.txt} (78%)
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/{StylableWindowView.xaml.txt => StyleableWindowView.xaml.txt} (91%)
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.cs.txt
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.txt
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/OpenSourceImages/TokenizedTextBox.png
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml.cs
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/{StylableWindowView.xaml => StyleableWindowView.xaml} (92%)
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/{StylableWindowView.xaml.cs => StyleableWindowView.xaml.cs} (90%)
 create mode 100644 ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs
 rename ExtendedWPFToolkitSolution/Src/{Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Converters/IntegerToBoolConverter.cs => Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs} (59%)
 rename ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs => ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs (92%)
 create mode 100644 ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToForeignKeyConverter.cs => ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs (57%)
 rename ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs => ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs (92%)

diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Aero/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Aero/AssemblyVersionInfo.cs
index ce1db48a..693b6601 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Aero/AssemblyVersionInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Aero/AssemblyVersionInfo.cs
@@ -21,7 +21,7 @@
 internal static class _XceedVersionInfo
 {
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
-  public const string BaseVersion = "2.3";
+  public const string BaseVersion = "2.4";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
   public const string Version = BaseVersion + 
   ".0.0";
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/AssemblyVersionInfo.cs
index ce1db48a..693b6601 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/AssemblyVersionInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/AssemblyVersionInfo.cs
@@ -21,7 +21,7 @@
 internal static class _XceedVersionInfo
 {
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
-  public const string BaseVersion = "2.3";
+  public const string BaseVersion = "2.4";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
   public const string Version = BaseVersion + 
   ".0.0";
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/Theme.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/Theme.xaml
index 2ee472f8..51fbe329 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/Theme.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.Metro/Theme.xaml
@@ -54,19 +54,6 @@
                 </ControlTemplate>
             </Setter.Value>
         </Setter>
-
-        <Style.Triggers>
-            <Trigger Property="IsMouseOver" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor31}"/>
-                <Setter Property="Background"
-									    Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor10}" />
-            </Trigger>
-            <Trigger Property="IsChecked" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor31}"/>
-                <Setter Property="Background"
-									    Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor10}" />
-            </Trigger>
-        </Style.Triggers>
     </Style>
 
     <Style x:Key="AvalonDock_ThemeMetro_ButtonStyle" TargetType="Button">
@@ -85,19 +72,10 @@
                 </ControlTemplate>
             </Setter.Value>
         </Setter>
-
-        <Style.Triggers>
-            <Trigger Property="IsMouseOver" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor31}"/>
-                <Setter Property="Background"
-									    Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor10}" />
-            </Trigger>
-        </Style.Triggers>
     </Style>
 
     <!--DocumentPaneControlStyle-->
     <Style x:Key="AvalonDock_ThemeMetro_DocumentPaneControlStyle" TargetType="{x:Type avalonDockControls:LayoutDocumentPaneControl}">
-        <Setter Property="Background" Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor33}"/>
         <Setter Property="BorderBrush" Value="{x:Null}"/>
         <Setter Property="Template">
             <Setter.Value>
@@ -171,22 +149,6 @@
                                 </Setter.Value>
                             </Setter>
                         </Trigger>
-                        <MultiDataTrigger>
-                            <MultiDataTrigger.Conditions>
-                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Model.SelectedContent.IsActive}" Value="True"/>
-                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Model.SelectedContent.IsLastFocusedDocument}" Value="True"/>
-                            </MultiDataTrigger.Conditions>
-                            <Setter Property="Background"
-									        Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor31}" />
-                        </MultiDataTrigger>
-                        <MultiDataTrigger>
-                            <MultiDataTrigger.Conditions>
-                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Model.SelectedContent.IsActive}" Value="False"/>
-                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Model.SelectedContent.IsLastFocusedDocument}" Value="True"/>
-                            </MultiDataTrigger.Conditions>
-                            <Setter Property="Background"
-									        Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor30}" />
-                        </MultiDataTrigger>
                         <Trigger Property="IsEnabled" Value="false">
                             <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"/>
                         </Trigger>
@@ -377,8 +339,6 @@
                                         <Setter Property="Panel.ZIndex" Value="0" />
                                     </MultiTrigger>
                                     <Trigger Property="IsEnabled" Value="false">
-                                        <Setter Property="BorderBrush" Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor13}"/>
-                                        <Setter Property="Background" Value="{DynamicResource AvalonDock_ThemeMetro_BaseColor9}"/>
                                         <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"/>
                                     </Trigger>
                                 </ControlTemplate.Triggers>
@@ -969,8 +929,7 @@
                                 <RowDefinition Height="Auto"/>
                                 <RowDefinition Height="*"/>
                             </Grid.RowDefinitions>
-                            <Border x:Name="Header"
-                                Background="{DynamicResource AvalonDock_ThemeMetro_BaseColor16}">
+                            <Border x:Name="Header">
                                 <avalonDockControls:AnchorablePaneTitle 
                                     Model="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"/>
                             </Border>
@@ -1437,7 +1396,6 @@
                                 </Grid>
 
                                 <Border Grid.Row="1" 
-                                        BorderBrush="{DynamicResource AvalonDock_ThemeMetro_BaseColor11}"
                                         BorderThickness="0,1,0,0"
                                         Background="{DynamicResource AvalonDock_ThemeMetro_BaseColor7}"
                                         MinHeight="200" >
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.VS2010/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.VS2010/AssemblyVersionInfo.cs
index ce1db48a..693b6601 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.VS2010/AssemblyVersionInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock.Themes.VS2010/AssemblyVersionInfo.cs
@@ -21,7 +21,7 @@
 internal static class _XceedVersionInfo
 {
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
-  public const string BaseVersion = "2.3";
+  public const string BaseVersion = "2.4";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
   public const string Version = BaseVersion + 
   ".0.0";
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/AssemblyVersionInfo.cs
index ce1db48a..693b6601 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/AssemblyVersionInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/AssemblyVersionInfo.cs
@@ -21,7 +21,7 @@
 internal static class _XceedVersionInfo
 {
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
-  public const string BaseVersion = "2.3";
+  public const string BaseVersion = "2.4";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
   public const string Version = BaseVersion + 
   ".0.0";
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/FocusElementManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/FocusElementManager.cs
index 70e79bee..768cff72 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/FocusElementManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/FocusElementManager.cs
@@ -227,7 +227,7 @@ namespace Xceed.Wpf.AvalonDock.Controls
                         {
                             _setFocusAsyncOperation = null;
                         }
-                    }), DispatcherPriority.Background);
+                    }), DispatcherPriority.Input);
                 }
             }
         }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/LayoutFloatingWindowControl.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/LayoutFloatingWindowControl.cs
index 20a01356..74a4ab5f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/LayoutFloatingWindowControl.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Controls/LayoutFloatingWindowControl.cs
@@ -237,7 +237,6 @@ namespace Xceed.Wpf.AvalonDock.Controls
 
             this.SetParentToMainWindowOf(Model.Root.Manager);
 
-
             _hwndSrc = HwndSource.FromDependencyObject(this) as HwndSource;
             _hwndSrcHook = new HwndSourceHook(FilterMessage);
             _hwndSrc.AddHook(_hwndSrcHook);
@@ -338,12 +337,18 @@ namespace Xceed.Wpf.AvalonDock.Controls
         /// </summary>
         protected virtual void OnIsDraggingChanged(DependencyPropertyChangedEventArgs e)
         {
+          if( ( bool )e.NewValue )
+          {
+            CaptureMouse();
+          }
+          else
+          {
+            ReleaseMouseCapture();
+          }
         }
 
         #endregion
 
-
-
         DragService _dragService = null;
 
         void UpdatePositionAndSizeOfPanes()
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/DockingManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/DockingManager.cs
index 8af625f6..572b15ab 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/DockingManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/DockingManager.cs
@@ -188,7 +188,7 @@ namespace Xceed.Wpf.AvalonDock
                                 if (Layout.ActiveContent != null)
                                     FocusElementManager.SetFocusOnLastElement(Layout.ActiveContent);
                                 _setFocusAsyncOperation = null;
-                            }), DispatcherPriority.Background);
+                            } ), DispatcherPriority.Input );
                     }
                 }
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Themes/generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Themes/generic.xaml
index eced7d15..c9d6fd7a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Themes/generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.AvalonDock/Themes/generic.xaml
@@ -171,7 +171,11 @@
 
     <!--AnchorablePaneControlStyle-->
     <Style x:Key="AnchorablePaneControlStyle" TargetType="{x:Type avalonDockControls:LayoutAnchorablePaneControl}">
-        <Setter Property="TabStripPlacement" Value="Bottom"/>
+      <Setter Property="Foreground"
+              Value="{Binding Model.Root.Manager.Foreground, RelativeSource={RelativeSource Self}}" />
+      <Setter Property="Background"
+              Value="{Binding Model.Root.Manager.Background, RelativeSource={RelativeSource Self}}" />
+      <Setter Property="TabStripPlacement" Value="Bottom"/>
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutAnchorablePaneControl}">
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualList.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualList.cs
index 8bcda49c..2f3526f4 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualList.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualList.cs
@@ -15,16 +15,12 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Diagnostics;
-using System.Collections.Specialized;
-using System.Windows.Threading;
-using System.Windows;
 using System.Collections.ObjectModel;
-using System.ComponentModel;
-using System.Collections;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.Text;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -492,7 +488,7 @@ namespace Xceed.Wpf.DataGrid
     internal void NotifyCommitComplete( AsyncCommitInfo asyncCommitInfo )
     {
       if( asyncCommitInfo.VirtualizedItemInfos.Length < 1 )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "VirualizedItemInfos is empty." );
 
       int indexForItemInPage = asyncCommitInfo.VirtualizedItemInfos[ 0 ].Index;
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualListEnumerator.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualListEnumerator.cs
index 07878788..9d20c42b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualListEnumerator.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualListEnumerator.cs
@@ -15,10 +15,9 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Collections;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -95,7 +94,7 @@ namespace Xceed.Wpf.DataGrid
     public bool MoveNext()
     {
       if( m_version != m_virtualList.PagingManager.Version )
-        throw new InvalidOperationException( "TODO: Collection was modified." );
+        throw new InvalidOperationException( "Collection was modified." );
 
       if( m_beforeStart )
         m_beforeStart = false;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualPage.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualPage.cs
index 3688fa24..fa5edec0 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualPage.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(DataVirtualization)/VirtualPage.cs
@@ -308,12 +308,22 @@ namespace Xceed.Wpf.DataGrid
 
     private void AsyncQueryInfo_BuiltInAbort( AsyncQueryInfo queryInfo )
     {
+      if( this.IsDisposed )
+        return;
+
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
+
       this.ParentVirtualList.PagingManager.OnBuiltInAbort( this, queryInfo );
       this.IsAborting = false;
     }
 
     private void AsyncQueryInfo_BeginQueryItems( AsyncQueryInfo queryInfo )
     {
+      if( this.IsDisposed )
+        return;
+
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
+
       this.ParentVirtualList.PagingManager.OnQueryItems( this, queryInfo );
     }
 
@@ -322,6 +332,8 @@ namespace Xceed.Wpf.DataGrid
       if( this.IsDisposed )
         return;
 
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
+
       this.ParentVirtualList.PagingManager.OnAbortQueryItems( this, queryInfo );
 
       this.IsAborting = false;
@@ -337,6 +349,7 @@ namespace Xceed.Wpf.DataGrid
       if( this.IsDisposed )
         return;
 
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
       Debug.Assert( !this.IsAborting );
       this.ParentVirtualList.PagingManager.OnQueryItemsCompleted( this, queryInfo, fetchedItems );
 
@@ -346,6 +359,11 @@ namespace Xceed.Wpf.DataGrid
 
     private void AsyncQueryInfo_QueryErrorChanged( AsyncQueryInfo queryInfo )
     {
+      if( this.IsDisposed )
+        return;
+
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
+
       this.ParentVirtualList.PagingManager.OnQueryErrorChanged( this, queryInfo );
 
       if( this.ParentVirtualList.IsRestarting )
@@ -354,11 +372,21 @@ namespace Xceed.Wpf.DataGrid
 
     private void AsyncCommitInfo_BeginCommitItems( AsyncCommitInfo commitInfo )
     {
+      if( this.IsDisposed )
+        return;
+
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
+
       this.ParentVirtualList.PagingManager.OnCommitItems( this, commitInfo );
     }
 
     private void AsyncCommitInfo_EndCommitItems( AsyncCommitInfo commitInfo )
     {
+      if( this.IsDisposed )
+        return;
+
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
+
       this.ParentVirtualList.PagingManager.OnCommitItemsCompleted( this, commitInfo );
 
       if( this.ParentVirtualList.IsRestarting )
@@ -367,6 +395,11 @@ namespace Xceed.Wpf.DataGrid
 
     private void AsyncCommitInfo_CommitErrorChanged( AsyncCommitInfo commitInfo )
     {
+      if( this.IsDisposed )
+        return;
+
+      Debug.Assert( ( this.ParentVirtualList != null ) || ( this.ParentVirtualList.PagingManager != null ) );
+
       this.ParentVirtualList.PagingManager.OnCommitErrorChanged( this, commitInfo );
 
       if( this.ParentVirtualList.IsRestarting )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataGridForeignKeyDescription.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataGridForeignKeyDescription.cs
index 01183884..83aaf5df 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataGridForeignKeyDescription.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataGridForeignKeyDescription.cs
@@ -14,28 +14,17 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Collections;
-using System.Windows.Data;
-using System.Diagnostics;
 using System.Windows;
-using System.ComponentModel;
 
 namespace Xceed.Wpf.DataGrid
 {
   public class DataGridForeignKeyDescription : DependencyObject
   {
-    #region Constructors
-
     public DataGridForeignKeyDescription()
     {
     }
 
-    #endregion
-
     #region ForeignKeyConverter Property
 
     public static readonly DependencyProperty ForeignKeyConverterProperty = DependencyProperty.Register(
@@ -64,15 +53,13 @@ namespace Xceed.Wpf.DataGrid
       "ItemsSource",
       typeof( IEnumerable ),
       typeof( DataGridForeignKeyDescription ),
-      new FrameworkPropertyMetadata(
-        null,
-        new PropertyChangedCallback( DataGridForeignKeyDescription.OnItemsSourceChanged ) ) );
+      new FrameworkPropertyMetadata( null ) );
 
     public IEnumerable ItemsSource
     {
       get
       {
-        return m_itemsSource;
+        return ( IEnumerable )this.GetValue( DataGridForeignKeyDescription.ItemsSourceProperty );
       }
       set
       {
@@ -80,18 +67,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private IEnumerable m_itemsSource; // = null;
-
-    private static void OnItemsSourceChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      DataGridForeignKeyDescription foreignKeyDescription = sender as DataGridForeignKeyDescription;
-
-      if( foreignKeyDescription != null )
-      {
-        foreignKeyDescription.m_itemsSource = e.NewValue as IEnumerable;
-      }
-    }
-
     #endregion
 
     #region IsAutoCreated Internal Property
@@ -125,5 +100,27 @@ namespace Xceed.Wpf.DataGrid
     }
 
     #endregion
+
+    #region DisplayMemberPath Property
+
+    public static readonly DependencyProperty DisplayMemberPathProperty = DependencyProperty.Register(
+      "DisplayMemberPath",
+      typeof( string ),
+      typeof( DataGridForeignKeyDescription ),
+      new FrameworkPropertyMetadata( null ) );
+
+    public string DisplayMemberPath
+    {
+      get
+      {
+        return ( string )this.GetValue( DataGridForeignKeyDescription.DisplayMemberPathProperty );
+      }
+      set
+      {
+        this.SetValue( DataGridForeignKeyDescription.DisplayMemberPathProperty, value );
+      }
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataTableForeignKeyDescription.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataTableForeignKeyDescription.cs
index 9c57d49e..d765727b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataTableForeignKeyDescription.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/(ForeignKeys)/DataTableForeignKeyDescription.cs
@@ -14,14 +14,8 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Data;
-using System.Collections;
 using System.Windows;
-using System.Diagnostics;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -56,7 +50,7 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_foreignKeyConstraint;
+        return ( ForeignKeyConstraint )this.GetValue( DataTableForeignKeyDescription.ForeignKeyConstraintProperty );
       }
       set
       {
@@ -66,18 +60,14 @@ namespace Xceed.Wpf.DataGrid
 
     private static void OnForeignKeyConstraintChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      DataTableForeignKeyDescription foreignKeyDescription = sender as DataTableForeignKeyDescription;
-
+      var foreignKeyDescription = sender as DataTableForeignKeyDescription;
       if( foreignKeyDescription != null )
       {
-        foreignKeyDescription.m_foreignKeyConstraint = e.NewValue as ForeignKeyConstraint;
         foreignKeyDescription.UpdateValuePath();
         foreignKeyDescription.UpdateItemsSource();
       }
     }
 
-    private ForeignKeyConstraint m_foreignKeyConstraint;
-
     #endregion
 
     #region PRIVATE METHODS
@@ -85,19 +75,21 @@ namespace Xceed.Wpf.DataGrid
     private void UpdateValuePath()
     {
       // Affect the ValuePath if it was not explicitly set or bound
-      object valuePath = this.ReadLocalValue( ValuePathProperty );
+      var valuePath = this.ReadLocalValue( ValuePathProperty );
 
       if( string.IsNullOrEmpty( this.ValuePath )
         && ( ( valuePath == DependencyProperty.UnsetValue )
              || ( valuePath == null ) ) )
       {
+        var foreignKeyConstraint = this.ForeignKeyConstraint;
+
         // Affect the FieldName to the first RelatedColumn's name
         // if there is only one DataColumn in the RelatedColumns Collection
-        if( ( m_foreignKeyConstraint != null )
-          && ( m_foreignKeyConstraint.RelatedColumns != null )
-          && ( m_foreignKeyConstraint.RelatedColumns.Length == 1 ) )
+        if( ( foreignKeyConstraint != null )
+          && ( foreignKeyConstraint.RelatedColumns != null )
+          && ( foreignKeyConstraint.RelatedColumns.Length == 1 ) )
         {
-          string foreignFieldName = m_foreignKeyConstraint.RelatedColumns[ 0 ].ColumnName;
+          var foreignFieldName = foreignKeyConstraint.RelatedColumns[ 0 ].ColumnName;
 
           if( !string.IsNullOrEmpty( foreignFieldName ) )
           {
@@ -109,11 +101,15 @@ namespace Xceed.Wpf.DataGrid
 
     private void UpdateItemsSource()
     {
-      if( ( m_foreignKeyConstraint != null )
-        && ( m_foreignKeyConstraint.RelatedTable != null ) )
-      {
-        this.ItemsSource = m_foreignKeyConstraint.RelatedTable.DefaultView;
-      }
+      var foreignKeyConstraint = this.ForeignKeyConstraint;
+      if( foreignKeyConstraint == null )
+        return;
+
+      var relatedTable = foreignKeyConstraint.RelatedTable;
+      if( relatedTable == null )
+        return;
+
+      this.ItemsSource = relatedTable.DefaultView;
     }
 
     #endregion
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/CollectionViewGroupExtensions.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/CollectionViewGroupExtensions.cs
index 2e14b0ef..7bca758d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/CollectionViewGroupExtensions.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/CollectionViewGroupExtensions.cs
@@ -27,33 +27,136 @@ namespace Xceed.Wpf.DataGrid
 {
   public static class CollectionViewGroupExtensions
   {
-    public static IList<object> GetItems( this CollectionViewGroup collectionViewGroup )
+
+    internal static SelectionRange GetRange( this CollectionViewGroup collectionViewGroup, DataGridContext dataGridContext )
     {
+      int startIndex = -1;
+      int endIndex = -1;
+
       DataGridVirtualizingCollectionViewGroupBase dataGridVirtualizingCollectionViewGroupBase = collectionViewGroup as DataGridVirtualizingCollectionViewGroupBase;
+      DataGridCollectionViewGroup dataGridCollectionViewGroup = collectionViewGroup as DataGridCollectionViewGroup;
+
       if( dataGridVirtualizingCollectionViewGroupBase != null )
       {
-        return dataGridVirtualizingCollectionViewGroupBase.VirtualItems;
+        startIndex = dataGridVirtualizingCollectionViewGroupBase.StartGlobalIndex;
+        endIndex = startIndex + dataGridVirtualizingCollectionViewGroupBase.VirtualItemCount - 1;
       }
+      else if( dataGridCollectionViewGroup != null )
+      {
+        startIndex = dataGridCollectionViewGroup.GetFirstRawItemGlobalSortedIndex();
+        endIndex = startIndex + dataGridCollectionViewGroup.GlobalRawItemCount - 1;
+      }
+      else if(collectionViewGroup.ItemCount > 0)
+      {
+        if( dataGridContext == null )
+          throw new DataGridInternalException( "This collectionViewGroup require a DataGridContext instance" );
 
-      DataGridCollectionViewGroup dataGridCollectionViewGroup = collectionViewGroup as DataGridCollectionViewGroup;
+        var firstItem = collectionViewGroup.GetFirstLeafItem();
+        var lastItem = collectionViewGroup.GetLastLeafItem();
+
+        if( firstItem != null && lastItem != null )
+        {
+          startIndex = dataGridContext.Items.IndexOf( firstItem );
+          endIndex = dataGridContext.Items.IndexOf( lastItem );
+        }
+      }
+
+      return (startIndex >= 0 ) && (startIndex <= endIndex)
+        ? new SelectionRange(startIndex, endIndex)
+        : SelectionRange.Empty;
+    }
+
+    public static IList<object> GetItems( this CollectionViewGroup collectionViewGroup )
+    {
+      var dataGridVirtualizingCollectionViewGroupBase = collectionViewGroup as DataGridVirtualizingCollectionViewGroupBase;
+      if( dataGridVirtualizingCollectionViewGroupBase != null )
+        return dataGridVirtualizingCollectionViewGroupBase.VirtualItems;
+
+      // The Items property of the DataGridCollectionViewGroup has been optimized to allow faster IndexOf and Contains. Since this property we could not
+      // override the property, we had to new it thus, we need to cast the CollectionViewGroup in the right type before acecssing the property.
+      var dataGridCollectionViewGroup = collectionViewGroup as DataGridCollectionViewGroup;
       if( dataGridCollectionViewGroup != null )
-      {
-        // The Items property of the DataGridCollectionViewGroup has been optimized
-        // to allow faster IndexOf and Contains. Since this property we could not
-        // override the property, we had to new it thus, we need to cast the CollectionViewGroup
-        // in the right type before acecssing the property.
         return dataGridCollectionViewGroup.Items;
-      }
 
       return collectionViewGroup.Items;
     }
 
     public static int GetItemCount( this CollectionViewGroup collectionViewGroup )
     {
-      if( collectionViewGroup is DataGridVirtualizingCollectionViewGroupBase )
-        return ( ( DataGridVirtualizingCollectionViewGroupBase )collectionViewGroup ).VirtualItemCount;
+      var dataGridVirtualizingCollectionViewGroupBase = collectionViewGroup as DataGridVirtualizingCollectionViewGroupBase;
+      if( dataGridVirtualizingCollectionViewGroupBase != null )
+        return dataGridVirtualizingCollectionViewGroupBase.VirtualItemCount;
 
       return collectionViewGroup.ItemCount;
     }
+
+    internal static IEnumerable<object> GetLeafItems( this CollectionViewGroup collectionViewGroup )
+    {
+      foreach( var item in collectionViewGroup.GetItems() )
+      {
+        if( item is CollectionViewGroup )
+        {
+          foreach(var subItem in ( ( CollectionViewGroup )item ).GetLeafItems())
+          {
+            yield return subItem;
+          }
+        }
+        else
+        {
+          yield return item;
+        }
+      }
+    }
+
+    internal static object GetFirstLeafItem( this CollectionViewGroup collectionViewGroup )
+    {
+      IList<object> items = collectionViewGroup.GetItems();
+
+      if( items.Count == 0 )
+        return null;
+
+      var item = items[ 0 ];
+      var subGroup = item as CollectionViewGroup;
+
+      return ( subGroup != null )
+        ? subGroup.GetFirstLeafItem()
+        : item;
+    }
+
+    internal static object GetLastLeafItem( this CollectionViewGroup collectionViewGroup )
+    {
+      IList<object> items = collectionViewGroup.GetItems();
+
+      if( items.Count == 0 )
+        return null;
+
+      var item = items[ items.Count - 1 ];
+      var subGroup = item as CollectionViewGroup;
+
+      return ( subGroup != null )
+        ? subGroup.GetLastLeafItem()
+        : item;
+    }
+
+
+    internal static IEnumerable<CollectionViewGroup> GetSubGroups( this CollectionViewGroup collectionViewGroup )
+    {
+
+      foreach( var item in collectionViewGroup.GetItems() )
+      {
+        var subGroup = item as CollectionViewGroup;
+
+        //No need to check every items, they will be all Groups or not.
+        if( subGroup == null )
+          break;
+
+        yield return subGroup;
+
+        foreach( var subSubgroup in subGroup.GetSubGroups() )
+        {
+          yield return subGroup;
+        }
+      }
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionErrorChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionErrorChangedEventManager.cs
new file mode 100644
index 00000000..55233eec
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionErrorChangedEventManager.cs
@@ -0,0 +1,87 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ConnectionErrorChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private ConnectionErrorChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static ConnectionErrorChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ConnectionErrorChangedEventManager );
+        var currentManager = ( ConnectionErrorChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ConnectionErrorChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridVirtualizingCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridVirtualizingCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridVirtualizingCollectionViewBase )source;
+      target.ConnectionErrorChanged += new EventHandler( this.DeliverEvent );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridVirtualizingCollectionViewBase )source;
+      target.ConnectionErrorChanged -= new EventHandler( this.DeliverEvent );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionStateChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionStateChangedEventManager.cs
new file mode 100644
index 00000000..5e0eaf03
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ConnectionStateChangedEventManager.cs
@@ -0,0 +1,87 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ConnectionStateChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private ConnectionStateChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static ConnectionStateChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ConnectionStateChangedEventManager );
+        var currentManager = ( ConnectionStateChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ConnectionStateChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridVirtualizingCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridVirtualizingCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridVirtualizingCollectionViewBase )source;
+      target.ConnectionStateChanged += new EventHandler( this.DeliverEvent );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridVirtualizingCollectionViewBase )source;
+      target.ConnectionStateChanged -= new EventHandler( this.DeliverEvent );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionView.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionView.cs
index 1d626a93..888bfa68 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionView.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionView.cs
@@ -17,26 +17,16 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.ComponentModel;
-using System.Text;
-using System.Windows.Data;
-using System.Windows.Threading;
+using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Diagnostics;
-using System.Collections.ObjectModel;
-using System.Data;
 using System.Globalization;
-using System.Security;
-using System.Security.Permissions;
 using System.Threading;
-using System.Windows;
-using System.Xml;
-
-using Xceed.Utils;
+using System.Windows.Data;
 using Xceed.Utils.Collections;
 using Xceed.Utils.Data;
 using Xceed.Wpf.DataGrid.Stats;
-using System.Data.Objects.DataClasses;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -75,19 +65,44 @@ namespace Xceed.Wpf.DataGrid
       throw new NotSupportedException( "This constructor is obsolete and should no longer be used." );
     }
 
-    private DataGridCollectionView( IEnumerable collection, DataGridDetailDescription parentDetailDescription, DataGridCollectionView rootDataGridCollectionView )
-      : base( collection, parentDetailDescription, rootDataGridCollectionView )
+    private DataGridCollectionView( IEnumerable collection, DataGridDetailDescription parentDetailDescription, DataGridCollectionView parentDataGridCollectionView )
+      : base( collection, parentDetailDescription, parentDataGridCollectionView.RootDataGridCollectionViewBase )
     {
       if( collection == null )
         throw new ArgumentNullException( "collection" );
 
-      this.UpdateChangedPropertyStatsOnly = rootDataGridCollectionView.UpdateChangedPropertyStatsOnly;
+      this.UpdateChangedPropertyStatsOnly = parentDataGridCollectionView.UpdateChangedPropertyStatsOnly;
+
+      //If already deferring refreshes while a detail grid is expanded.
+      if( parentDataGridCollectionView.InDeferRefresh )
+      {
+        //If count is 0, it means this child collection view represents the first detail of its parent item, so create the parent's list of disposable.
+        if( parentDataGridCollectionView.DetailDeferRefreshes.Count == 0 )
+        {
+          parentDataGridCollectionView.DetailDeferRefreshes.Add( new List<IDisposable>() );
+        }
+
+        //Need to defer refresh on the detail CollectionView as well, and for as many "defers" there are presently at the master level.
+        foreach( List<IDisposable> detailDisposables in parentDataGridCollectionView.DetailDeferRefreshes )
+        {
+          detailDisposables.Add( this.DeferRefresh() );
+        }
+
+        //If Refresh() has been called on the root CollectionView, do it also for the detail one.
+        if( parentDataGridCollectionView.NeedsRefresh )
+        {
+          this.Refresh();
+        }
+      }
     }
 
     internal override void PreConstruct()
     {
       base.PreConstruct();
 
+      m_sourceItemList = new List<RawItem>( 128 );
+      m_filteredItemList = new List<RawItem>( 128 );
+
       m_sourceItems = new SourceItemCollection( this );
       this.RootGroup = new DataGridCollectionViewGroupRoot( this );
     }
@@ -102,13 +117,13 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    StatFunctionCollection m_statFunctions; // = null
+    private StatFunctionCollection m_statFunctions; // = null
 
     #endregion StatFunctions Property
 
     #region InvalidatedStatFunctions Property
 
-    internal List<StatFunction> InvalidatedStatFunctions
+    internal ICollection<StatFunction> InvalidatedStatFunctions
     {
       get
       {
@@ -116,13 +131,13 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    List<StatFunction> m_invalidatedStatFunctions = new List<StatFunction>();
+    private HashSet<StatFunction> m_invalidatedStatFunctions = new HashSet<StatFunction>();
 
     #endregion
 
     #region UpdateChangedPropertyStatsOnly Property
 
-    public bool UpdateChangedPropertyStatsOnly
+    internal bool UpdateChangedPropertyStatsOnly
     {
       get;
       set;
@@ -294,9 +309,6 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        if( m_sourceItemList == null )
-          return 0;
-
         return m_sourceItemList.Count;
       }
     }
@@ -332,7 +344,9 @@ namespace Xceed.Wpf.DataGrid
     private void OnRootGroupChanged( EventArgs e )
     {
       if( this.RootGroupChanged != null )
+      {
         this.RootGroupChanged( this, e );
+      }
     }
 
     #endregion RootGroupChanged Internal Event
@@ -352,9 +366,21 @@ namespace Xceed.Wpf.DataGrid
         throw new InvalidOperationException( "An attempt was made to remove an item from a source that does not support removal." );
 
       RawItem rawItem = this.GetRawItemAt( index );
-      int sourceIndex = ( rawItem == null ) ? -1 : rawItem.Index;
+      int sourceIndex;
+      object dataItem;
 
-      DataGridRemovingItemEventArgs removingItemEventArgs = new DataGridRemovingItemEventArgs( this, null, index, false );
+      if( rawItem != null )
+      {
+        sourceIndex = rawItem.Index;
+        dataItem = rawItem.DataItem;
+      }
+      else
+      {
+        sourceIndex = -1;
+        dataItem = null;
+      }
+
+      DataGridRemovingItemEventArgs removingItemEventArgs = new DataGridRemovingItemEventArgs( this, dataItem, index, false );
       this.RootDataGridCollectionViewBase.OnRemovingItem( removingItemEventArgs );
 
       if( removingItemEventArgs.Cancel )
@@ -368,12 +394,12 @@ namespace Xceed.Wpf.DataGrid
         DeferredOperation deferredOperation = new DeferredOperation(
           DeferredOperation.DeferredOperationAction.Remove,
           sourceIndex,
-          new object[] { rawItem.DataItem } );
+          new object[] { dataItem } );
 
         this.ExecuteOrQueueSourceItemOperation( deferredOperation );
       }
 
-      DataGridItemRemovedEventArgs itemRemovedEventArgs = new DataGridItemRemovedEventArgs( this, null, index );
+      DataGridItemRemovedEventArgs itemRemovedEventArgs = new DataGridItemRemovedEventArgs( this, dataItem, index );
       this.RootDataGridCollectionViewBase.OnItemRemoved( itemRemovedEventArgs );
     }
 
@@ -384,20 +410,44 @@ namespace Xceed.Wpf.DataGrid
       return this.RootGroup.GetRawItemAtGlobalSortedIndex( index ).DataItem;
     }
 
+    public void ResetItem( object item )
+    {
+      DeferredOperation deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.ResetItem, item );
+      this.ExecuteOrQueueSourceItemOperation( deferredOperation );
+    }
+
+    public void ResetItems( IList items )
+    {
+      DeferredOperation deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.ResetItem, items );
+      this.ExecuteOrQueueSourceItemOperation( deferredOperation );
+    }
+
     public void RefreshDistinctValuesForFieldName( string fieldName )
     {
-      this.ForceRefreshDistinctValuesForFieldName( fieldName, this.DistinctValues[ fieldName ].InnerObservableHashList );
+      this.ForceRefreshDistinctValuesForFieldName( fieldName );
+    }
+
+    public void RefreshUnboundItemProperties( object item = null )
+    {
+      DeferredOperation deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.RefreshUnboundItemProperties, item );
+      this.ExecuteOrQueueSourceItemOperation( deferredOperation );
+    }
+
+    public void RefreshUnboundItemProperties( IList items )
+    {
+      DeferredOperation deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.RefreshUnboundItemProperties, items );
+      this.ExecuteOrQueueSourceItemOperation( deferredOperation );
     }
 
     internal override DataGridCollectionViewBase CreateDetailDataGridCollectionViewBase(
       IEnumerable detailDataSource,
       DataGridDetailDescription parentDetailDescription,
-      DataGridCollectionViewBase rootDataGridCollectionViewBase )
+      DataGridCollectionViewBase parentDataGridCollectionViewBase )
     {
-      Debug.Assert( rootDataGridCollectionViewBase is DataGridCollectionView );
+      Debug.Assert( parentDataGridCollectionViewBase is DataGridCollectionView );
 
       if( parentDetailDescription != null )
-        return new DataGridCollectionView( detailDataSource, parentDetailDescription, rootDataGridCollectionViewBase as DataGridCollectionView );
+        return new DataGridCollectionView( detailDataSource, parentDetailDescription, parentDataGridCollectionViewBase as DataGridCollectionView );
 
       return new DataGridCollectionView( detailDataSource );
     }
@@ -406,8 +456,7 @@ namespace Xceed.Wpf.DataGrid
     {
       base.CreateDefaultCollections( parentDetailDescription );
 
-      m_statFunctions = ( parentDetailDescription == null ) ? new StatFunctionCollection() :
-        parentDetailDescription.StatFunctions;
+      m_statFunctions = ( parentDetailDescription != null ) ? parentDetailDescription.StatFunctions : new StatFunctionCollection();
     }
 
     internal override void RefreshDistinctValuesForField( DataGridItemPropertyBase dataGridItemProperty )
@@ -440,14 +489,16 @@ namespace Xceed.Wpf.DataGrid
           distinctValuesSortComparer = dataGridItemProperty.SortComparer;
         }
 
-        int rowsCount = m_sourceItemList.Count; // Parse every rows to get distinct values
+        List<RawItem> currentItemsList = this.GetItemsList();
+        int rowsCount = currentItemsList.Count; // Parse every rows to get distinct values
         int maximumDistinctValuesCount = dataGridItemProperty.MaxDistinctValues;
 
         for( int rowIndex = 0; rowIndex < rowsCount; rowIndex++ )
         {
-          object rowItem = m_sourceItemList[ rowIndex ].DataItem;
+          object rowItem = currentItemsList[ rowIndex ].DataItem;
 
-          // If we have more than one filtered item, we need to verify if the row passes every filter except the filtered one to get
+          // If we have more than one filtered item :
+          // we need to verify if the row passes every AUTO filter except the filtered one to get
           if( this.DistinctValuesConstraint == DistinctValuesConstraint.Filtered )
           {
             if( !this.PassesAutoFilter( rowItem, dataGridItemProperty ) )
@@ -513,21 +564,13 @@ namespace Xceed.Wpf.DataGrid
       {
         case DeferredOperation.DeferredOperationAction.Add:
           {
-            refreshForced = !this.AddSourceItem(
-              deferredOperation.NewStartingIndex,
-              deferredOperation.NewItems,
-              deferredOperation.NewSourceItemCount );
-
+            refreshForced = !this.AddSourceItem( deferredOperation.NewStartingIndex, deferredOperation.NewItems, deferredOperation.NewSourceItemCount );
             break;
           }
 
         case DeferredOperation.DeferredOperationAction.Move:
           {
-            refreshForced = !this.MoveSourceItem(
-              deferredOperation.OldStartingIndex,
-              deferredOperation.OldItems,
-              deferredOperation.NewStartingIndex );
-
+            refreshForced = !this.MoveSourceItem( deferredOperation.OldStartingIndex, deferredOperation.OldItems, deferredOperation.NewStartingIndex );
             break;
           }
 
@@ -558,10 +601,7 @@ namespace Xceed.Wpf.DataGrid
           {
             refreshForced = false;
 
-            // Ensure to defer the CurrentItem change
-            // when regrouping is completed to be sure
-            // the SaveCurrent has the right values
-            // when restoring
+            // Ensure to defer the CurrentItem change when regrouping is completed to be sure the SaveCurrent has the right values when restoring
             using( this.DeferCurrencyEvent() )
             {
               int oldCurrentPosition = -1;
@@ -577,27 +617,19 @@ namespace Xceed.Wpf.DataGrid
               this.AdjustCurrentAndSendResetNotification( oldCurrentRawItem, oldCurrentPosition );
               this.TriggerRootGroupChanged();
             }
-
             break;
           }
 
         case DeferredOperation.DeferredOperationAction.Remove:
           {
-            refreshForced = !this.RemoveSourceItem(
-              deferredOperation.OldStartingIndex,
-              deferredOperation.OldItems.Count );
-
+            refreshForced = !this.RemoveSourceItem( deferredOperation.OldStartingIndex, deferredOperation.OldItems.Count );
             break;
           }
 
         case DeferredOperation.DeferredOperationAction.Replace:
           {
-            refreshForced = !this.ReplaceSourceItem(
-              deferredOperation.OldStartingIndex,
-              deferredOperation.OldItems,
-              deferredOperation.NewStartingIndex,
-              deferredOperation.NewItems );
-
+            refreshForced = !this.ReplaceSourceItem( deferredOperation.OldStartingIndex, deferredOperation.OldItems,
+                                                     deferredOperation.NewStartingIndex, deferredOperation.NewItems );
             break;
           }
 
@@ -605,10 +637,7 @@ namespace Xceed.Wpf.DataGrid
           {
             refreshForced = false;
 
-            // Ensure to defer the CurrentItem change
-            // when resort is completed to be sure
-            // the SaveCurrent has the right values
-            // when restoring
+            // Ensure to defer the CurrentItem change when resort is completed to be sure the SaveCurrent has the right values when restoring
             using( this.DeferCurrencyEvent() )
             {
               int oldCurrentPosition = -1;
@@ -621,9 +650,43 @@ namespace Xceed.Wpf.DataGrid
 
               // Ensure to send reset notifications
               this.AdjustCurrentAndSendResetNotification( oldCurrentRawItem, oldCurrentPosition );
-              this.TriggerRootGroupChanged();
+
+              //If there is no grouping, there is no group changes, so no GroupChanged to raise.
+              if( !this.RootGroup.IsBottomLevel )
+              {
+                this.TriggerRootGroupChanged();
+              }
+            }
+            break;
+          }
+
+        case DeferredOperation.DeferredOperationAction.ResetItem:
+          {
+            refreshForced = false;
+            if( deferredOperation.DataItem != null )
+            {
+              this.ResetSourceItem( deferredOperation.DataItem );
             }
+            else
+            {
+              this.ResetSourceItems( deferredOperation.NewItems );
+            }
+            m_currentChildCollectionView = null;
+            break;
+          }
 
+        case DeferredOperation.DeferredOperationAction.RefreshUnboundItemProperties:
+          {
+            refreshForced = false;
+            if( deferredOperation.NewItems != null )
+            {
+              this.RefreshUnboundItemPropertiesCore( deferredOperation.NewItems );
+            }
+            else
+            {
+              this.RefreshUnboundItemPropertiesCore( deferredOperation.DataItem );
+            }
+            m_currentChildCollectionView = null;
             break;
           }
 
@@ -635,17 +698,43 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    internal override void ProcessInvalidatedGroupStats( List<DataGridCollectionViewGroup> invalidatedGroups, bool ensurePosition )
+    internal override void ProcessInvalidatedGroupStats( HashSet<DataGridCollectionViewGroup> invalidatedGroups )
     {
-      GroupSortComparer[] groupSortComparers = this.GetGroupSortComparers();
-
       foreach( DataGridCollectionViewGroup group in invalidatedGroups )
       {
         group.InvokeStatFunctionsPropertyChanged( this );
+      }
 
-        if( ensurePosition )
+      if( m_hasGroupSortBasedOnStats )
+      {
+        using( this.DeferCurrencyEvent() )
         {
-          this.EnsurePosition( group, groupSortComparers );
+          object oldCurrentDataItem = this.CurrentItem;
+          int oldCurrentPosition = this.CurrentPosition;
+
+          this.SortGroups();
+
+          RawItem currentRawItem = null;
+
+          if( oldCurrentDataItem != null )
+          {
+            currentRawItem = this.GetFirstRawItemFromDataItem( oldCurrentDataItem );
+          }
+
+          if( currentRawItem == null )
+          {
+            if( ( oldCurrentPosition > 0 ) && ( oldCurrentPosition < this.RootGroup.GlobalRawItemCount ) )
+            {
+              currentRawItem = this.RootGroup.GetRawItemAtGlobalSortedIndex( oldCurrentPosition );
+            }
+          }
+
+          if( currentRawItem != null )
+          {
+            this.SetCurrentItem( currentRawItem.GetGlobalSortedIndex(), oldCurrentDataItem, false, false );
+          }
+
+          this.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
         }
       }
 
@@ -665,12 +754,13 @@ namespace Xceed.Wpf.DataGrid
       int oldCurrentPosition = -1;
       RawItem oldCurrentRawItem = null;
 
-      // The cache of PropertyDescriptors for the StatFunctions will be recreated if 
-      // needed in GetStatFunctionProperties().
+      // The cache of PropertyDescriptors for the StatFunctions will be recreated if needed in GetStatFunctionProperties().
       m_statisticalProperties = null;
 
       if( !initialLoad )
+      {
         this.SaveCurrentBeforeReset( out oldCurrentRawItem, out oldCurrentPosition );
+      }
 
       SortDescriptionInfo[] sortDescriptionInfos = null;
 
@@ -700,9 +790,10 @@ namespace Xceed.Wpf.DataGrid
                 if( list != null )
                 {
                   int count = list.Count;
-                  m_sourceItemList = new List<RawItem>( count );
-                  m_dataItemToRawItemList = new Dictionary<object, object>();
-                  m_filteredItemList = new List<RawItem>( count );
+
+                  m_sourceItemList.Clear();
+                  m_filteredItemList.Clear();
+                  m_dataItemToRawItemMap.Clear();
 
                   for( int i = 0; i < count; i++ )
                   {
@@ -738,12 +829,14 @@ namespace Xceed.Wpf.DataGrid
                     ICollection collection = enumeration as ICollection;
 
                     if( collection != null )
+                    {
                       count = collection.Count;
+                    }
                   }
 
-                  m_sourceItemList = new List<RawItem>( count );
-                  m_dataItemToRawItemList = new Dictionary<object, object>();
-                  m_filteredItemList = new List<RawItem>( count );
+                  m_sourceItemList.Clear();
+                  m_filteredItemList.Clear();
+                  m_dataItemToRawItemMap.Clear();
 
                   int index = 0;
                   IEnumerator enumerator = enumeration.GetEnumerator();
@@ -764,17 +857,6 @@ namespace Xceed.Wpf.DataGrid
                     }
                   }
                 }
-                else
-                {
-                  if( m_sourceItemList == null )
-                    m_sourceItemList = new List<RawItem>( 128 );
-
-                  if( m_dataItemToRawItemList == null )
-                    m_dataItemToRawItemList = new Dictionary<object, object>();
-
-                  if( m_filteredItemList == null )
-                    m_filteredItemList = new List<RawItem>( 128 );
-                }
               }
 
               m_filteredItemList.TrimExcess();
@@ -823,14 +905,18 @@ namespace Xceed.Wpf.DataGrid
 
         if( sendResetNotification )
         {
-          this.OnCollectionChanged( new NotifyCollectionChangedEventArgs(
-            NotifyCollectionChangedAction.Reset ) );
+          this.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
         }
 
         this.TriggerRootGroupChanged();
       }
     }
 
+    internal override void ClearGroupSortComparers()
+    {
+      m_groupSortComparers.Clear();
+    }
+
     internal RawItem GetRawItemAt( int index )
     {
       this.EnsureThreadAndCollectionLoaded();
@@ -839,7 +925,7 @@ namespace Xceed.Wpf.DataGrid
 
     internal object GetSourceItemAt( int index )
     {
-      if( m_sourceItemList == null )
+      if( index > m_sourceItemList.Count - 1 )
         throw new ArgumentOutOfRangeException( "index", index, "index must be greater than zero and less than SourceItems.Count." );
 
       return m_sourceItemList[ index ].DataItem;
@@ -847,9 +933,6 @@ namespace Xceed.Wpf.DataGrid
 
     internal IEnumerator<RawItem> GetSourceListEnumerator()
     {
-      if( m_sourceItemList == null )
-        return new List<RawItem>().GetEnumerator();
-
       return m_sourceItemList.GetEnumerator();
     }
 
@@ -859,7 +942,7 @@ namespace Xceed.Wpf.DataGrid
       {
         m_statisticalProperties = new PropertyDescriptorCollection( null );
 
-        foreach( Stats.StatFunction statFunction in m_statFunctions )
+        foreach( StatFunction statFunction in m_statFunctions )
         {
           m_statisticalProperties.Add( new StatFunctionPropertyDescriptor( statFunction.ResultPropertyName ) );
         }
@@ -915,10 +998,14 @@ namespace Xceed.Wpf.DataGrid
         this.AddRawItemInFilteredList( filteredItems, isLast );
         this.AddRawItemInGroup( filteredItems );
 
-        DeferredOperationManager deferredOperationManager = this.DeferredOperationManager;
-        foreach( RawItem rawItem in filteredItems )
+        if( m_statFunctions.Count > 0 )
         {
-          deferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup );
+          DeferredOperationManager deferredOperationManager = this.DeferredOperationManager;
+          foreach( RawItem rawItem in filteredItems )
+          {
+            //When adding a new item, make sure all stats for the specified group are recalculated even if UpdateChangedPropertyStatsOnly is set to true
+            deferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup, true );
+          }
         }
       }
 
@@ -944,10 +1031,17 @@ namespace Xceed.Wpf.DataGrid
         rawItem = m_sourceItemList[ i + startIndex ];
 
         if( this.CurrentEditItem == rawItem.DataItem )
+        {
           this.SetCurrentEditItem( null );
+        }
 
         removedItems[ i ] = rawItem;
-        this.DeferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup );
+
+        //When removing an item, make sure all stats for the specified group are recalculated even if UpdateChangedPropertyStatsOnly is set to true
+        if( m_statFunctions.Count > 0 )
+        {
+          this.DeferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup, true );
+        }
       }
 
       int filteredItemRemovedCount = this.RemoveRawItemInFilteredList( removedItems );
@@ -956,7 +1050,9 @@ namespace Xceed.Wpf.DataGrid
       this.RemoveRawItemInSourceList( startIndex, count );
 
       if( filteredItemRemovedCount > 0 )
+      {
         this.RemoveRawItemInGroup( removedItems );
+      }
 
       this.RefreshDistinctValues( filteredItemRemovedCount > 0 );
       return true;
@@ -976,8 +1072,7 @@ namespace Xceed.Wpf.DataGrid
       int newItemCount = newItems.Count;
       int sourceItemListCount = m_sourceItemList.Count;
 
-      if( ( oldStartIndex + oldItemCount ) > sourceItemListCount
-        || ( newStartIndex + newItemCount ) > sourceItemListCount )
+      if( ( oldStartIndex + oldItemCount ) > sourceItemListCount || ( newStartIndex + newItemCount ) > sourceItemListCount )
       {
         this.ForceRefresh( true, !this.Loaded, true );
         return false;
@@ -1000,7 +1095,9 @@ namespace Xceed.Wpf.DataGrid
             // globalSortedIndex == -1 means item does not pass filter
             if( globalSortedIndex != -1 )
             {
-              bool itemChanged = !object.Equals( oldItem, newItems[ i ] );
+              object newItem = newItems[ i ];
+
+              bool itemChanged = !object.Equals( oldItem, newItem );
 
               if( ( this.CurrentEditItem == oldItem ) && ( itemChanged ) )
               {
@@ -1015,10 +1112,7 @@ namespace Xceed.Wpf.DataGrid
 
               if( this.CurrentEditItem != oldItem )
               {
-                object newItem = newItems[ i ];
-                DeferredOperationManager deferredOperationManager = this.DeferredOperationManager;
-
-                if( newItem != rawItem.DataItem )
+                if( newItem != oldItem )
                 {
                   this.RemoveRawItemDataItemMapping( rawItem );
                   rawItem.SetDataItem( newItem );
@@ -1035,21 +1129,45 @@ namespace Xceed.Wpf.DataGrid
                   oldGroup.ProtectedItems[ rawItem.SortedIndex ] = newItem;
                 }
 
-                this.OnCollectionChanged( new NotifyCollectionChangedEventArgs(
-                  NotifyCollectionChangedAction.Replace, newItem, oldItem, rawItem.GetGlobalSortedIndex() ) );
+                this.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Replace, newItem, oldItem, rawItem.GetGlobalSortedIndex() ) );
 
-                deferredOperationManager.InvalidateGroupStats( oldGroup );
                 this.EnsurePosition( rawItem, globalSortedIndex );
-                deferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup );
+
+                DataGridCollectionViewGroup newGroup = rawItem.ParentGroup;
+                bool movedToDifferentParentGroup = oldGroup != newGroup;
+
+                if( m_statFunctions.Count > 0 )
+                {
+                  DeferredOperationManager deferredOperationManager = this.DeferredOperationManager;
+                  deferredOperationManager.InvalidateGroupStats( oldGroup, movedToDifferentParentGroup );
+                  if( movedToDifferentParentGroup )
+                  {
+                    deferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup, true );
+                  }
+                }
               }
             }
             else
             {
-              // Since it is a replace, we must re-ensure position even if current item did not passed filter
-              // in case a properperty change would let it pass the filter
-              this.DeferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup );
+              Debug.Assert( rawItem.ParentGroup == null, "ParentGroup should be null, since according to the comment at the top of the if, the item is filtered out" );
+
+              DataGridCollectionViewGroup oldGroup = rawItem.ParentGroup;
+
+              // Since it is a replace, we must re-ensure position even if current item did not passed filter in case a property change would let it pass the filter
               this.EnsurePosition( rawItem, globalSortedIndex );
-              this.DeferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup );
+
+              DataGridCollectionViewGroup newGroup = rawItem.ParentGroup;
+              bool movedToDifferentParentGroup = oldGroup != newGroup;
+
+              if( m_statFunctions.Count > 0 )
+              {
+                DeferredOperationManager deferredOperationManager = this.DeferredOperationManager;
+                deferredOperationManager.InvalidateGroupStats( oldGroup, movedToDifferentParentGroup );
+                if( movedToDifferentParentGroup )
+                {
+                  deferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup, true );
+                }
+              }
             }
           }
           else
@@ -1061,7 +1179,9 @@ namespace Xceed.Wpf.DataGrid
         }
 
         if( extraOldItemCount > 0 )
+        {
           this.RemoveSourceItem( oldStartIndex + newItemCount, extraOldItemCount );
+        }
 
         int extraNewItemCount = newItemCount - oldItemCount;
 
@@ -1085,20 +1205,27 @@ namespace Xceed.Wpf.DataGrid
     {
       this.EnsureThreadAndCollectionLoaded();
 
-      object cached;
+      return m_dataItemToRawItemMap[ dataItem ];
+    }
 
-      if( ( m_dataItemToRawItemList != null )
-        && ( m_dataItemToRawItemList.TryGetValue( dataItem, out cached ) ) )
+    internal int GetGlobalSortedIndexFromDataItem( object dataItem )
+    {
+      RawItem rawItem = this.GetFirstRawItemFromDataItem( dataItem );
+      int globalSortedIndex = rawItem.GetGlobalSortedIndex();
+      if( globalSortedIndex == -1 )
       {
-        RawItem temp = cached as RawItem;
+        return rawItem.SortedIndex;
+      }
 
-        if( cached != null )
-          return temp;
+      return globalSortedIndex;
+    }
 
-        return ( ( RawItem[] )cached )[ 0 ];
+    internal IEnumerable<object> GetSortedFilteredDataItems()
+    {
+      foreach( RawItem item in this.RootGroup.RawItems )
+      {
+        yield return item.DataItem;
       }
-
-      return null;
     }
 
     private static DataStore CreateStore( Type dataType, int initialCapacity )
@@ -1177,13 +1304,20 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private List<RawItem> GetItemsList()
+    {
+      return ( this.DistinctValuesConstraint == DistinctValuesConstraint.FilteredWithAllFilters ) ? m_filteredItemList : m_sourceItemList;
+    }
+
     private void EnsurePosition( RawItem rawItem, int globalSortedIndex )
     {
       Debug.Assert( rawItem.GetGlobalSortedIndex() == globalSortedIndex );
 
-      if( this.PassesFilter( rawItem.DataItem )
-        && this.PassesAutoFilter( rawItem.DataItem, null )
-        && this.PassesFilterCriterion( rawItem.DataItem ) )
+      object dataItem = rawItem.DataItem;
+
+      if( this.PassesFilter( dataItem )
+        && this.PassesAutoFilter( dataItem, null )
+        && this.PassesFilterCriterion( dataItem ) )
       {
         if( globalSortedIndex == -1 )
         {
@@ -1214,14 +1348,20 @@ namespace Xceed.Wpf.DataGrid
 
       // Verify the row is in the correct group.
       DataGridCollectionViewGroup newGroup = this.GetRawItemNewGroup( rawItem );
+      DataGridCollectionViewGroup currentGroup = rawItem.ParentGroup;
 
-      if( rawItem.ParentGroup != newGroup )
+      if( currentGroup != newGroup )
       {
         using( this.DeferCurrencyEvent() )
         {
-          DeferredOperationManager deferredOperationManager = this.DeferredOperationManager;
-          deferredOperationManager.InvalidateGroupStats( rawItem.ParentGroup );
-          deferredOperationManager.InvalidateGroupStats( newGroup );
+          if( m_statFunctions.Count > 0 )
+          {
+            DeferredOperationManager deferredOperationManager = this.DeferredOperationManager;
+
+            //If an item is moved from one group to another, make sure all stats for the specified groups are recalculated even if UpdateChangedPropertyStatsOnly is set to true
+            deferredOperationManager.InvalidateGroupStats( currentGroup, true );
+            deferredOperationManager.InvalidateGroupStats( newGroup, true );
+          }
 
           int newSortIndex = newGroup.BinarySearchRawItem( rawItem, this.RawItemSortComparer );
 
@@ -1230,7 +1370,7 @@ namespace Xceed.Wpf.DataGrid
             newSortIndex = ~newSortIndex;
           }
 
-          rawItem.ParentGroup.RemoveRawItemAt( rawItem.SortedIndex );
+          currentGroup.RemoveRawItemAt( rawItem.SortedIndex );
           newGroup.InsertRawItem( newSortIndex, rawItem );
           int newGlobalSortedIndex = rawItem.GetGlobalSortedIndex();
           this.AdjustCurrencyAfterMove( globalSortedIndex, newGlobalSortedIndex, 1 );
@@ -1239,15 +1379,24 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
+        if( m_statFunctions.Count > 0 )
+        {
+          this.DeferredOperationManager.InvalidateGroupStats( currentGroup );
+        }
+
         // Verify sorting only if we have not changed group, since adding an item in a group will automatically sort it.
         // Even if we are not sorted, we must ensure the order matches the natural order of the source.
         int newSortIndex = newGroup.BinarySearchRawItem( rawItem, this.RawItemSortComparer );
 
         if( newSortIndex < 0 )
+        {
           newSortIndex = ~newSortIndex;
+        }
 
         if( newSortIndex > rawItem.SortedIndex )
+        {
           newSortIndex--;
+        }
 
         if( rawItem.SortedIndex != newSortIndex )
         {
@@ -1262,56 +1411,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void EnsurePosition( DataGridCollectionViewGroup group, GroupSortComparer[] groupSortComparers )
-    {
-      DataGridCollectionViewGroup parentGroup = group.Parent;
-
-      if( parentGroup == null )
-        return;
-
-      int oldSortIndex = parentGroup.ProtectedItems.IndexOf( group );
-
-      // If the group have been removed, we have nothing to do here.
-      if( oldSortIndex == -1 )
-        return;
-
-      DataGridCollectionViewGroup currentGroup = parentGroup.Parent;
-      int groupLevel = 0;
-
-      while( currentGroup != null )
-      {
-        groupLevel++;
-        currentGroup = currentGroup.Parent;
-      }
-
-      int newSortIndex = parentGroup.BinarySearchGroup( group, groupSortComparers[ groupLevel ] );
-
-      if( newSortIndex < 0 )
-        newSortIndex = ~newSortIndex;
-
-      if( newSortIndex > oldSortIndex )
-        newSortIndex--;
-
-      if( oldSortIndex != newSortIndex )
-      {
-        using( this.DeferCurrencyEvent() )
-        {
-          int oldGlobalSortedIndex = group.GetFirstRawItemGlobalSortedIndex();
-          parentGroup.ProtectedItems.Move( oldSortIndex, newSortIndex );
-          int newGlobalSortedIndex = group.GetFirstRawItemGlobalSortedIndex();
-
-          int itemCount = group.GlobalRawItemCount;
-          this.AdjustCurrencyAfterMove( oldGlobalSortedIndex, newGlobalSortedIndex, itemCount );
-
-          List<object> items = new List<object>( 256 );
-          group.GetGlobalItems( items );
-
-          this.OnCollectionChanged( new NotifyCollectionChangedEventArgs(
-            NotifyCollectionChangedAction.Move, items, newGlobalSortedIndex, oldGlobalSortedIndex ) );
-        }
-      }
-    }
-
     // excludedFilteredDataGridItemProperty is used to avoid filtering the column on which we are calculating Distinct Values if null, this parameter is ignored
     private bool PassesAutoFilter( object item, DataGridItemPropertyBase excludedFilteredDataGridItemProperty )
     {
@@ -1320,7 +1419,6 @@ namespace Xceed.Wpf.DataGrid
       if( autoFilterMode == AutoFilterMode.None )
         return true;
 
-      DistinctValuesConstraint distinctValuesConstraint = this.DistinctValuesConstraint;
       bool isRowAccepted = false;
       bool isColumnFiltered = false;
 
@@ -1548,22 +1646,29 @@ namespace Xceed.Wpf.DataGrid
             Debug.Assert( ( newCurrentPosition == -1 ) || ( newCurrentPosition >= ( globalRawItemCount - 1 ) ) );
 #endif
 
-          this.SetCurrentItemAndPositionCore(
-            newCurrentItem, newCurrentPosition, isCurrentBeforeFirst, isCurrentAfterLast );
+          this.SetCurrentItemAndPositionCore( newCurrentItem, newCurrentPosition, isCurrentBeforeFirst, isCurrentAfterLast );
 
           if( !this.IsCurrencyDeferred )
           {
             if( !object.Equals( oldCurrentItem, newCurrentItem ) )
+            {
               this.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentItem" ) );
+            }
 
             if( oldCurrentPosition != this.CurrentPosition )
+            {
               this.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentPosition" ) );
+            }
 
             if( oldIsCurrentBeforeFirst != this.IsCurrentBeforeFirst )
+            {
               this.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentBeforeFirst" ) );
+            }
 
             if( oldIsCurrentAfterLast != this.IsCurrentAfterLast )
+            {
               this.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentAfterLast" ) );
+            }
 
             this.OnCurrentChanged();
           }
@@ -1577,8 +1682,7 @@ namespace Xceed.Wpf.DataGrid
     {
       int count = items.Count;
 
-      if( ( oldStartIndex < 0 ) || ( oldStartIndex + count > m_sourceItemList.Count )
-        || ( newStartIndex < 0 ) || ( newStartIndex > ( m_sourceItemList.Count - count ) ) )
+      if( ( oldStartIndex < 0 ) || ( oldStartIndex + count > m_sourceItemList.Count ) || ( newStartIndex < 0 ) || ( newStartIndex > ( m_sourceItemList.Count - count ) ) )
       {
         this.ForceRefresh( true, !this.Loaded, true );
         return false;
@@ -1595,7 +1699,9 @@ namespace Xceed.Wpf.DataGrid
 
         // If our parent group is null, we are filtered out.
         if( rawItem.ParentGroup != null )
+        {
           filteredRawItems.Add( rawItem );
+        }
       }
 
       int filteredItemCount = this.RemoveRawItemInFilteredList( rawItems );
@@ -1629,6 +1735,62 @@ namespace Xceed.Wpf.DataGrid
       return true;
     }
 
+    private bool ResetSourceItem( object dataItem )
+    {
+      RawItem rawItem = null;
+
+      //Verify if the item is in the same detail CollectionView as the previous item was found in.
+      if( m_currentChildCollectionView != null )
+      {
+        rawItem = m_currentChildCollectionView.GetFirstRawItemFromDataItem( dataItem );
+
+        //If the item was found, refresh it.
+        if( rawItem != null )
+        {
+          int globalSortedIndex = rawItem.GetGlobalSortedIndex();
+          m_currentChildCollectionView.EnsurePosition( rawItem, globalSortedIndex );
+          return true;
+        }
+      }
+
+      //If the item has not been found, try to find it in the current CollectionView.
+      rawItem = this.GetFirstRawItemFromDataItem( dataItem );
+      m_currentChildCollectionView = null;
+
+      //If the item was found, refresh it.
+      if( rawItem != null )
+      {
+        int globalSortedIndex = rawItem.GetGlobalSortedIndex();
+        this.EnsurePosition( rawItem, globalSortedIndex );
+        return true;
+      }
+
+      //If the item was not found, look for it in an expended detail.
+      foreach( DataGridContext detailContext in this.DataGridContext.GetChildContextsCore() )
+      {
+        DataGridCollectionView detailCollectionView = detailContext.Items as DataGridCollectionView;
+        if( detailCollectionView != null )
+        {
+          if( detailCollectionView.ResetSourceItem( dataItem ) )
+          {
+            //keep a reference to the detail CollectionView the item was found in, in case following items belong to the same detail.
+            m_currentChildCollectionView = detailCollectionView;
+            return true;
+          }
+        }
+      }
+
+      return false;
+    }
+
+    private void ResetSourceItems( IList items )
+    {
+      foreach( object dataItem in items )
+      {
+        this.ResetSourceItem( dataItem );
+      }
+    }
+
     private void AddRawItemInSourceList( int startIndex, IList<RawItem> rawItems )
     {
       m_sourceItemList.InsertRange( startIndex, rawItems );
@@ -1659,13 +1821,14 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        index = m_filteredItemList.BinarySearch(
-          rawItems[ 0 ], DataGridCollectionView.RawItemIndexComparer );
+        index = m_filteredItemList.BinarySearch( rawItems[ 0 ], DataGridCollectionView.RawItemIndexComparer );
 
         Debug.Assert( index < 0 );
 
         if( index < 0 )
+        {
           index = ~index;
+        }
 
         Debug.Assert( index <= m_filteredItemList.Count );
       }
@@ -1691,7 +1854,9 @@ namespace Xceed.Wpf.DataGrid
         int index = newGroup.BinarySearchRawItem( rawItem, this.RawItemSortComparer );
 
         if( index < 0 )
+        {
           index = ~index;
+        }
 
         int globalIndex = newGroup.GetFirstRawItemGlobalSortedIndex() + index;
         this.AdjustCurrencyBeforeAdd( globalIndex );
@@ -1702,8 +1867,7 @@ namespace Xceed.Wpf.DataGrid
           m_sortedItemVersion++;
         }
 
-        this.OnCollectionChanged( new NotifyCollectionChangedEventArgs(
-          NotifyCollectionChangedAction.Add, rawItem.DataItem, globalIndex ) );
+        this.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, rawItem.DataItem, globalIndex ) );
       }
     }
 
@@ -1729,11 +1893,12 @@ namespace Xceed.Wpf.DataGrid
       // The function take for granted that all RawItem's index are sequential,
       // There should not be any gap in the index sequence.
 
-      int index = m_filteredItemList.BinarySearch(
-        rawItems[ 0 ], DataGridCollectionView.RawItemIndexComparer );
+      int index = m_filteredItemList.BinarySearch( rawItems[ 0 ], DataGridCollectionView.RawItemIndexComparer );
 
       if( index < 0 )
+      {
         index = ~index;
+      }
 
       if( index > m_filteredItemList.Count )
         return 0;
@@ -1746,11 +1911,15 @@ namespace Xceed.Wpf.DataGrid
       for( int i = index; i < count; i++ )
       {
         if( m_filteredItemList[ i ].Index <= lastRawItemIndex )
+        {
           countToRemove++;
+        }
       }
 
       if( countToRemove > 0 )
+      {
         m_filteredItemList.RemoveRange( index, countToRemove );
+      }
 
       return countToRemove;
     }
@@ -1779,14 +1948,76 @@ namespace Xceed.Wpf.DataGrid
             }
           }
 
-          // In the case of a remove, the CollectionChanged must be after the CurrentChanged
-          // since when the DataGridCollectionView is used with a Selector having the 
-          // IsSynchronizedWithCurrent set, the Selector will sett the current position to 
-          // -1 if the selected item is removed. 
-          this.OnCollectionChanged( new NotifyCollectionChangedEventArgs(
-            NotifyCollectionChangedAction.Remove, oldRawItem.DataItem, globalSortedIndex ) );
+          // In the case of a remove, the CollectionChanged must be after the CurrentChanged since when the DataGridCollectionView is used with a Selector having the 
+          // IsSynchronizedWithCurrent set, the Selector will set the current position to -1 if the selected item is removed. 
+          this.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Remove, oldRawItem.DataItem, globalSortedIndex ) );
+        }
+      }
+    }
+
+    private bool RefreshUnboundItemPropertiesCore( object dataItem = null )
+    {
+      if( dataItem != null )
+      {
+        //Verify if the item is in the same detail CollectionView as the previous item was found in.
+        if( m_currentChildCollectionView != null && m_currentChildCollectionView.m_sourceItems.Contains( dataItem ) )
+        {
+          m_currentChildCollectionView.ItemProperties.RefreshUnboundItemProperty( dataItem );
+          return true;
+        }
+
+        //Since the item was not found in the previous detail, it means items are not sequential, thus no need to keep looking into this detail.
+        m_currentChildCollectionView = null;
+
+        //Try to find it in the current CollectionView.
+        if( m_sourceItems.Contains( dataItem ) )
+        {
+          this.ItemProperties.RefreshUnboundItemProperty( dataItem );
+          return true;
+        }
+
+        //If not, try to find it in an expended detail
+        foreach( DataGridContext detailContext in this.DataGridContext.GetChildContextsCore() )
+        {
+          DataGridCollectionView detailCollectionView = detailContext.Items as DataGridCollectionView;
+          if( detailCollectionView != null )
+          {
+            if( detailCollectionView.RefreshUnboundItemPropertiesCore( dataItem ) )
+            {
+              m_currentChildCollectionView = detailCollectionView;
+              return true;
+            }
+          }
+        }
+
+        return false;
+      }
+
+      //If dataItem is null, it means every item must be Refreshed.  Let's start with the level we're on.
+      foreach( RawItem rawItem in m_sourceItemList )
+      {
+        this.ItemProperties.RefreshUnboundItemProperty( rawItem.DataItem );
+      }
+
+      //Refresh every expended detail of the parent
+      foreach( DataGridContext detailContext in this.DataGridContext.GetChildContextsCore() )
+      {
+        DataGridCollectionView detailCollectionView = detailContext.Items as DataGridCollectionView;
+        if( detailCollectionView != null )
+        {
+          detailCollectionView.RefreshUnboundItemPropertiesCore();
         }
       }
+
+      return true;
+    }
+
+    private void RefreshUnboundItemPropertiesCore( IList items )
+    {
+      foreach( object dataItem in items )
+      {
+        this.RefreshUnboundItemPropertiesCore( dataItem );
+      }
     }
 
     private void GroupItems()
@@ -1815,7 +2046,9 @@ namespace Xceed.Wpf.DataGrid
           DataGridGroupDescription groupDescription = groupDescriptions[ i ] as DataGridGroupDescription;
 
           if( groupDescription != null )
+          {
             groupDescription.SetContext( this );
+          }
         }
 
         try
@@ -1831,8 +2064,7 @@ namespace Xceed.Wpf.DataGrid
             for( int j = 1; j <= groupDescriptionCount; j++ )
             {
               // We set SortComparers to null to avoid Sorting since we are in the middle of a "batch operation"
-              // The sorting will be done after the batch operation which is faster than sorting for each
-              // group modification
+              // The sorting will be done after the batch operation which is faster than sorting for each group modification
               currentGroup = currentGroup.GetGroup( rawItem, j - 1, culture, groupDescriptions, null );
             }
 
@@ -1846,7 +2078,9 @@ namespace Xceed.Wpf.DataGrid
             DataGridGroupDescription groupDescription = groupDescriptions[ i ] as DataGridGroupDescription;
 
             if( groupDescription != null )
+            {
               groupDescription.SetContext( null );
+            }
           }
         }
       }
@@ -1866,8 +2100,7 @@ namespace Xceed.Wpf.DataGrid
 
     private void SortItems( SortDescriptionInfo[] sortDescriptionInfos )
     {
-      // We set the current item to -1 to prevent the developper to get an invalid position.
-      // We will replace the current item to the correct one later.
+      // We set the current item to -1 to prevent the developper to get an invalid position. We will replace the current item to the correct one later.
       this.SetCurrentItem( -1, null, false, false );
 
       DataGridCollectionViewGroupRoot rootGroup = this.RootGroup;
@@ -1878,13 +2111,10 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        // We use a new DataGridCollectionViewGroupRoot to prevent
-        // some event to be raised.
+        // We use a new DataGridCollectionViewGroupRoot to prevent some event to be raised.
         DataGridCollectionViewGroupRoot newRootGroup = new DataGridCollectionViewGroupRoot( rootGroup );
 
-        rootGroup.SortItems(
-          sortDescriptionInfos, this.GetGroupSortComparers(),
-          0, m_sourceItemList, newRootGroup );
+        rootGroup.SortItems( sortDescriptionInfos, this.GetGroupSortComparers(), 0, m_sourceItemList, newRootGroup );
 
         this.RootGroup = newRootGroup;
       }
@@ -1895,6 +2125,21 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private void SortGroups()
+    {
+      DataGridCollectionViewGroupRoot rootGroup = this.RootGroup;
+
+      if( rootGroup.IsBottomLevel )
+        return;
+
+      rootGroup.SortGroups( this.GetGroupSortComparers(), 0 );
+
+      unchecked
+      {
+        m_sortedItemVersion++;
+      }
+    }
+
     private void PrepareSort( out SortDescriptionInfo[] sortDescriptionInfos )
     {
       sortDescriptionInfos = null;
@@ -1917,8 +2162,7 @@ namespace Xceed.Wpf.DataGrid
               SortDescription sortDescription = sortDescriptions[ i ];
               DataGridItemPropertyBase dataProperty = itemProperties[ sortDescription.PropertyName ];
 
-              SortDescriptionInfo sortDescriptionInfo =
-                new SortDescriptionInfo( dataProperty, sortDescription.Direction );
+              SortDescriptionInfo sortDescriptionInfo = new SortDescriptionInfo( dataProperty, sortDescription.Direction );
 
               sortDescriptionInfos[ i ] = sortDescriptionInfo;
 
@@ -1943,7 +2187,9 @@ namespace Xceed.Wpf.DataGrid
               ISupportInitialize supportInitialize = dataProperty as ISupportInitialize;
 
               if( supportInitialize != null )
+              {
                 supportInitialize.BeginInit();
+              }
 
               try
               {
@@ -1955,7 +2201,9 @@ namespace Xceed.Wpf.DataGrid
               finally
               {
                 if( supportInitialize != null )
+                {
                   supportInitialize.EndInit();
+                }
               }
             }
           }
@@ -1963,36 +2211,27 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private GroupSortComparer[] GetGroupSortComparers()
+    private List<GroupSortComparer> GetGroupSortComparers()
     {
-      SortDescriptionCollection sortDescriptions = this.SortDescriptions;
-      ObservableCollection<GroupDescription> groupDescriptions = this.GroupDescriptions;
+      if( m_groupSortComparers.Count > 0 )
+        return m_groupSortComparers;
 
-      int groupDescriptionCount = groupDescriptions.Count;
-      int sortDescriptionCount = sortDescriptions.Count;
-      GroupSortComparer[] sortComparers = new GroupSortComparer[ groupDescriptionCount ];
+      m_hasGroupSortBasedOnStats = false;
 
+      SortDescriptionCollection sortDescriptions = this.SortDescriptions;
       DataGridItemPropertyCollection itemProperties = this.ItemProperties;
 
-      for( int j = 0; j < groupDescriptionCount; j++ )
+      foreach( GroupDescription groupDescription in this.GroupDescriptions )
       {
-        GroupDescription groupDescription = groupDescriptions[ j ];
-
         // Find the sortDescriptionInfo for the current sub group.
-        ListSortDirection sortDirection = ListSortDirection.Ascending;
-        string groupName = DataGridCollectionView.GetPropertyNameFromGroupDescription( groupDescription );
-        DataGridGroupDescription dataGridGroupDescription = groupDescription as DataGridGroupDescription;
-        bool defaultGroupSortAdded = false;
-
-        List<GroupSortComparer.SortInfo> sortInfos =
-          new List<GroupSortComparer.SortInfo>( sortDescriptionCount );
+        string groupDescriptionName = DataGridCollectionView.GetPropertyNameFromGroupDescription( groupDescription );
+        List<GroupSortComparer.SortInfo> sortInfos = new List<GroupSortComparer.SortInfo>( sortDescriptions.Count );
 
-        for( int i = 0; i < sortDescriptionCount; i++ )
+        foreach( SortDescription sortDescription in sortDescriptions )
         {
-          SortDescription sortDescription = sortDescriptions[ i ];
-          sortDirection = sortDescription.Direction;
-          string sortDescriptionPropertyName = sortDescription.PropertyName;
-          DataGridItemPropertyBase itemProperty = itemProperties[ sortDescriptionPropertyName ];
+          ListSortDirection sortDirection = sortDescription.Direction;
+          string sortDescriptionName = sortDescription.PropertyName;
+          DataGridItemPropertyBase itemProperty = itemProperties[ sortDescriptionName ];
 
           if( itemProperty != null )
           {
@@ -2000,67 +2239,51 @@ namespace Xceed.Wpf.DataGrid
 
             if( !string.IsNullOrEmpty( sortStatResultPropertyName ) )
             {
+              m_hasGroupSortBasedOnStats = true;
+
               IComparer sortComparer = itemProperty.GroupSortStatResultComparer;
 
               if( sortComparer == null )
+              {
                 sortComparer = StatResultComparer.Singleton;
+              }
 
-              sortInfos.Add( new GroupSortComparer.SortInfo(
-                sortStatResultPropertyName, sortDirection, sortComparer ) );
+              sortInfos.Add( new GroupSortComparer.SortInfo( sortStatResultPropertyName, sortDirection, sortComparer ) );
             }
           }
 
-          if( string.Equals( groupName, sortDescriptionPropertyName ) )
-          {
-            sortInfos.Add( this.CreateDefaultGroupSortInfo(
-              groupDescription, itemProperty, sortDirection, true ) );
-
-            defaultGroupSortAdded = true;
-          }
-        }
-
-        if( !defaultGroupSortAdded )
-        {
-          GroupSortComparer.SortInfo sortInfo = this.CreateDefaultGroupSortInfo(
-            groupDescription, itemProperties[ groupName ], sortDirection, false );
-
-          if( sortInfo != null )
+          if( string.Equals( groupDescriptionName, sortDescriptionName ) )
           {
-            sortInfos.Add( sortInfo );
+            sortInfos.Add( this.CreateDefaultGroupSortInfo( groupDescription, itemProperty, sortDirection ) );
           }
         }
 
-        sortComparers[ j ] = new GroupSortComparer( sortInfos );
+        m_groupSortComparers.Add( new GroupSortComparer( sortInfos ) );
       }
 
-      return sortComparers;
+      return m_groupSortComparers;
     }
 
-    private GroupSortComparer.SortInfo CreateDefaultGroupSortInfo(
-      GroupDescription groupDescription,
-      DataGridItemPropertyBase itemProperty,
-      ListSortDirection sortDirection,
-      bool useDefaultComparer )
+    private GroupSortComparer.SortInfo CreateDefaultGroupSortInfo( GroupDescription groupDescription, DataGridItemPropertyBase itemProperty, ListSortDirection sortDirection )
     {
       DataGridGroupDescription dataGridGroupDescription = groupDescription as DataGridGroupDescription;
       IComparer sortComparer = null;
 
       if( dataGridGroupDescription != null )
+      {
         sortComparer = dataGridGroupDescription.SortComparer;
+      }
 
       if( ( sortComparer == null ) && ( itemProperty != null ) )
       {
         sortComparer = itemProperty.SortComparer;
       }
 
-      if( ( sortComparer == null ) && ( useDefaultComparer ) )
+      if( sortComparer == null )
       {
         sortComparer = ObjectComparer.Singleton;
       }
 
-      if( sortComparer == null )
-        return null;
-
       return new GroupSortComparer.SortInfo( null, sortDirection, sortComparer );
     }
 
@@ -2068,8 +2291,7 @@ namespace Xceed.Wpf.DataGrid
     {
       this.AdjustCurrencyAfterReset( oldCurrentRawItem, oldCurrentPosition, false );
 
-      this.OnCollectionChanged( new NotifyCollectionChangedEventArgs(
-        NotifyCollectionChangedAction.Reset ) );
+      this.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
     }
 
     private void TriggerRootGroupChanged()
@@ -2077,9 +2299,11 @@ namespace Xceed.Wpf.DataGrid
       // All the groups will be recreated. No need to trigger the StatFunctions PropertyChanged.
       this.DeferredOperationManager.ClearInvalidatedGroups();
 
-      // The previous GroupItems or SortItems have changed RootGroup but have not
-      // send the RootGroupChanged event. Do it here.
+      // The previous GroupItems or SortItems have changed RootGroup but have not send the RootGroupChanged event. Do it here.
       this.OnRootGroupChanged( EventArgs.Empty );
+
+      //Flag that the Collection of groups itself has changed.
+      this.OnPropertyChanged( new PropertyChangedEventArgs( "Groups" ) );
     }
 
     private DataGridCollectionViewGroup GetRawItemNewGroup( RawItem rawItem )
@@ -2091,14 +2315,16 @@ namespace Xceed.Wpf.DataGrid
         return this.RootGroup;
 
       CultureInfo culture = this.Culture;
-      GroupSortComparer[] sortComparers = this.GetGroupSortComparers();
+      List<GroupSortComparer> sortComparers = this.GetGroupSortComparers();
 
       for( int i = 0; i < groupDescriptionCount; i++ )
       {
         DataGridGroupDescription groupDescription = groupDescriptions[ i ] as DataGridGroupDescription;
 
         if( groupDescription != null )
+        {
           groupDescription.SetContext( this );
+        }
       }
 
       try
@@ -2119,87 +2345,21 @@ namespace Xceed.Wpf.DataGrid
           DataGridGroupDescription groupDescription = groupDescriptions[ i ] as DataGridGroupDescription;
 
           if( groupDescription != null )
+          {
             groupDescription.SetContext( null );
+          }
         }
       }
     }
 
     private void AddRawItemDataItemMapping( RawItem rawItem )
     {
-      object dataItem = rawItem.DataItem;
-
-      object cached;
-      if( m_dataItemToRawItemList.TryGetValue( dataItem, out cached ) )
-      {
-        // rawItems will either be a RawItem or an array of RawItem.
-        // For sure, after this, we will have an array of RawItem.
-        RawItem temp = cached as RawItem;
-        RawItem[] rawItems;
-
-        if( temp != null )
-        {
-          System.Diagnostics.Debug.Assert( rawItem != temp, "It's not normal to be called twice for the same RawItem." );
-
-          // We need to convert the entry to an array.
-          rawItems = new RawItem[ 2 ] { temp, rawItem };
-        }
-        else
-        {
-          rawItems = ( RawItem[] )cached;
-
-          int count = rawItems.Length;
-          for( int i = 0; i < count; i++ )
-          {
-            if( rawItems[ i ] == rawItem )
-            {
-              System.Diagnostics.Debug.Fail( "It's not normal to be called twice for the same RawItem." );
-              return;
-            }
-          }
-
-          // Resize the array and add the new RawItem into it.
-          Array.Resize<RawItem>( ref rawItems, rawItems.Length + 1 );
-          rawItems[ rawItems.Length - 1 ] = rawItem;
-        }
-
-        m_dataItemToRawItemList[ dataItem ] = rawItems;
-      }
-      else
-      {
-        // This is the first time that we are adding a map for this
-        // data item. No need for an array here.
-        m_dataItemToRawItemList.Add( dataItem, rawItem );
-      }
+      m_dataItemToRawItemMap.Add( rawItem.DataItem, rawItem );
     }
 
     private void RemoveRawItemDataItemMapping( RawItem rawItem )
     {
-      object dataItem = rawItem.DataItem;
-
-      object cached;
-      if( m_dataItemToRawItemList.TryGetValue( dataItem, out cached ) )
-      {
-        RawItem temp = cached as RawItem;
-        if( temp != null )
-        {
-          // We only had one RawItem for the data item.
-          // Simply remove the cached entry.
-          m_dataItemToRawItemList.Remove( dataItem );
-        }
-        else
-        {
-          // Remove the RawItem from the mapping.
-          List<RawItem> rawItemList = new List<RawItem>( ( RawItem[] )cached );
-          if( rawItemList.Remove( rawItem ) )
-          {
-            // If there is only one RawItem left in the list,
-            // we convert the list to store only the RawItem.
-            m_dataItemToRawItemList[ dataItem ] = ( rawItemList.Count == 1 )
-              ? ( object )rawItemList[ 0 ]
-              : rawItemList.ToArray();
-          }
-        }
-      }
+      m_dataItemToRawItemMap.Remove( rawItem.DataItem, rawItem );
     }
 
     private void SaveCurrentBeforeReset( out RawItem oldCurrentRawItem, out int oldCurrentPosition )
@@ -2215,8 +2375,7 @@ namespace Xceed.Wpf.DataGrid
         oldCurrentPosition = this.CurrentPosition;
       }
 
-      oldCurrentRawItem = ( oldCurrentPosition < 0 ) || ( oldCurrentPosition == int.MaxValue ) ?
-        null : this.RootGroup.GetRawItemAtGlobalSortedIndex( oldCurrentPosition );
+      oldCurrentRawItem = ( oldCurrentPosition < 0 ) || ( oldCurrentPosition == int.MaxValue ) ? null : this.RootGroup.GetRawItemAtGlobalSortedIndex( oldCurrentPosition );
     }
 
     private void AdjustCurrencyAfterReset( RawItem oldCurrentRawItem, int oldCurrentPosition, bool itemsChanged )
@@ -2251,10 +2410,7 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        this.SetCurrentItem(
-          oldCurrentRawItem.GetGlobalSortedIndex(),
-          oldCurrentRawItem.DataItem,
-          false, false );
+        this.SetCurrentItem( oldCurrentRawItem.GetGlobalSortedIndex(), oldCurrentRawItem.DataItem, false, false );
       }
     }
 
@@ -2337,10 +2493,7 @@ namespace Xceed.Wpf.DataGrid
         }
         else
         {
-          this.SetCurrentItem(
-            index,
-            rootGroup.GetRawItemAtGlobalSortedIndex( index + 1 ).DataItem,
-            false, true );
+          this.SetCurrentItem( index, rootGroup.GetRawItemAtGlobalSortedIndex( index + 1 ).DataItem, false, true );
         }
       }
     }
@@ -2348,7 +2501,9 @@ namespace Xceed.Wpf.DataGrid
     private void AdjustCurrencyBeforeReplace( int index, object newItem )
     {
       if( index == this.CurrentPosition )
+      {
         this.SetCurrentItem( index, newItem, false, false );
+      }
     }
 
     #region ICancelAddNew Members
@@ -2384,7 +2539,9 @@ namespace Xceed.Wpf.DataGrid
     private void OnInitialized( EventArgs e )
     {
       if( this.Initialized != null )
+      {
         this.Initialized( this, e );
+      }
     }
 
     bool ISupportInitializeNotification.IsInitialized
@@ -2413,7 +2570,9 @@ namespace Xceed.Wpf.DataGrid
     void ISupportInitialize.EndInit()
     {
       if( m_batchInitializationCount > 0 )
+      {
         m_batchInitializationCount--;
+      }
 
       if( m_batchInitializationCount == 0 )
       {
@@ -2699,8 +2858,8 @@ namespace Xceed.Wpf.DataGrid
     #endregion IEnumerable Members
 
     private static RawItemIndexComparer m_rawItemIndexComparer;
-
     private RawItemSortComparer m_rawItemSortComparer;
+    private List<GroupSortComparer> m_groupSortComparers = new List<GroupSortComparer>();
 
     private int m_lastAddCount;
     private int m_lastAddIndex;
@@ -2710,12 +2869,14 @@ namespace Xceed.Wpf.DataGrid
 
     private List<RawItem> m_sourceItemList;
     private List<RawItem> m_filteredItemList;
-    private Dictionary<object, object> m_dataItemToRawItemList;
+    private readonly RawItemMap m_dataItemToRawItemMap = new RawItemMap();
 
     private PropertyDescriptorCollection m_statisticalProperties;
     private List<WeakReference> m_tempStatFunctions = new List<WeakReference>();
+    private bool m_hasGroupSortBasedOnStats;
 
     private int m_sortedItemVersion;
+    private DataGridCollectionView m_currentChildCollectionView;
 
     #region Private Class StatFunctionPropertyDescriptor
 
@@ -2813,5 +2974,6 @@ namespace Xceed.Wpf.DataGrid
     }
 
     #endregion
+
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewBase.cs
index 1f46abc5..3cb5ba7a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewBase.cs
@@ -15,23 +15,22 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows.Data;
 using System.Collections.ObjectModel;
-using System.Collections;
-using Xceed.Utils.Collections;
 using System.Collections.Specialized;
-using System.Diagnostics;
 using System.ComponentModel;
-using System.Globalization;
 using System.Data;
-using System.Windows;
-using System.Xml;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
 using System.Reflection;
-using System.Data.Objects.DataClasses;
+using System.Threading;
+using System.Windows;
+using System.Windows.Data;
 using System.Windows.Threading;
+using System.Xml;
+using Xceed.Utils.Collections;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -41,14 +40,12 @@ namespace Xceed.Wpf.DataGrid
 
     internal static string GetPropertyNameFromGroupDescription( GroupDescription groupDescription )
     {
-      PropertyGroupDescription propertyGroupDescription =
-        groupDescription as PropertyGroupDescription;
+      PropertyGroupDescription propertyGroupDescription = groupDescription as PropertyGroupDescription;
 
       if( propertyGroupDescription != null )
         return propertyGroupDescription.PropertyName;
 
-      DataGridGroupDescription dataGridGroupDescription =
-        groupDescription as DataGridGroupDescription;
+      DataGridGroupDescription dataGridGroupDescription = groupDescription as DataGridGroupDescription;
 
       if( dataGridGroupDescription != null )
         return dataGridGroupDescription.PropertyName;
@@ -153,7 +150,7 @@ namespace Xceed.Wpf.DataGrid
 
       this.SetupDefaultItemProperties();
       this.CreateDefaultCollections( null );
-      this.RegisterCollectionChanged();
+      this.RegisterChangedEvents();
     }
 
     internal DataGridCollectionViewBase( IEnumerable collection, DataGridDetailDescription parentDetailDescription, DataGridCollectionViewBase rootDataGridCollectionViewBase )
@@ -316,10 +313,17 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return this;
+        if( m_syncRoot == null )
+        {
+          Interlocked.CompareExchange( ref m_syncRoot, new object(), null );
+        }
+
+        return m_syncRoot;
       }
     }
 
+    private object m_syncRoot; //null
+
     #endregion
 
     #region DeferredOperationManager Property
@@ -340,7 +344,7 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_deferRefreshCount > 0;
+        return ( m_deferRefreshCount > 0 );
       }
     }
 
@@ -479,6 +483,60 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region DetailDeferRefreshes Property
+
+    internal List<List<IDisposable>> DetailDeferRefreshes
+    {
+      get
+      {
+        return m_detailDeferRefreshes;
+      }
+    }
+
+    private List<List<IDisposable>> m_detailDeferRefreshes;
+
+    #endregion
+
+    #region DataGridContext Private Property
+
+    internal DataGridContext DataGridContext
+    {
+      get
+      {
+        if( m_dataGridContext == null )
+          return null;
+
+        return m_dataGridContext.Target as DataGridContext;
+      }
+      set
+      {
+        if( value == null )
+        {
+          m_dataGridContext = null;
+        }
+        else
+        {
+          m_dataGridContext = new WeakReference( value );
+        }
+      }
+    }
+
+    private WeakReference m_dataGridContext;
+
+    #endregion
+
+    #region IsRootCollectionView Private Property
+
+    private bool IsRootCollectionView
+    {
+      get
+      {
+        return ( m_rootDataGridCollectionViewBase == null )
+            || ( m_rootDataGridCollectionViewBase == this );
+      }
+    }
+
+    #endregion
 
     #region DataGridCollectionViewBase ABSTRACT MEMBERS
 
@@ -490,7 +548,7 @@ namespace Xceed.Wpf.DataGrid
     internal abstract DataGridCollectionViewBase CreateDetailDataGridCollectionViewBase(
       IEnumerable detailDataSource,
       DataGridDetailDescription parentDetailDescription,
-      DataGridCollectionViewBase rootDataGridCollectionViewBase );
+      DataGridCollectionViewBase parentDataGridCollectionViewBase );
 
     internal abstract void EnsurePosition( int globalSortedIndex );
 
@@ -532,25 +590,33 @@ namespace Xceed.Wpf.DataGrid
 
       // Unsubscribe from old list event
       if( m_notifyCollectionChanged != null )
+      {
         CollectionChangedEventManager.RemoveListener( m_notifyCollectionChanged, this );
+      }
 
       IBindingList oldBindingList = m_enumeration as IBindingList;
 
       if( ( oldBindingList != null ) && ( oldBindingList.SupportsChangeNotification ) )
+      {
         ListChangedEventManager.RemoveListener( oldBindingList, this );
+      }
 
       m_enumeration = source;
       m_notifyCollectionChanged = m_enumeration as INotifyCollectionChanged;
 
       if( m_notifyCollectionChanged != null )
+      {
         CollectionChangedEventManager.AddListener( m_notifyCollectionChanged, this );
+      }
 
       if( m_notifyCollectionChanged == null )
       {
         IBindingList newBindingList = m_enumeration as IBindingList;
 
         if( ( newBindingList != null ) && ( newBindingList.SupportsChangeNotification ) )
+        {
           ListChangedEventManager.AddListener( newBindingList, this );
+        }
       }
 
       m_dataTable = m_enumeration as DataTable;
@@ -582,6 +648,21 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    internal void RemoveSourceChangedListenersForDetail()
+    {
+      if( m_notifyCollectionChanged != null )
+      {
+        CollectionChangedEventManager.RemoveListener( m_notifyCollectionChanged, this );
+      }
+
+      IBindingList bindingList = m_enumeration as IBindingList;
+
+      if( ( bindingList != null ) && ( bindingList.SupportsChangeNotification ) )
+      {
+        ListChangedEventManager.RemoveListener( bindingList, this );
+      }
+    }
+
     internal IEnumerable Enumeration
     {
       get
@@ -697,120 +778,125 @@ namespace Xceed.Wpf.DataGrid
       Debug.Assert( !( this is DataGridVirtualizingCollectionViewBase ),
         "The DataGridVirtualizingCollectionView is unbound and therefore should never receive a notification from a source." );
 
-      IBindingList bindingList = ( IBindingList )m_enumeration;
-      int index = e.NewIndex;
-      IList items = null;
+      Action<PropertyDescriptor> propertyDescriptorHandler;
       ListChangedType listChangedType = e.ListChangedType;
 
-      //If we're within bounds
-      if( ( index > -1 ) && ( index < bindingList.Count ) )
+      switch( listChangedType )
       {
-        //Let's get the item
-        items = new object[] { bindingList[ index ] };
+        case ListChangedType.PropertyDescriptorAdded:
+          propertyDescriptorHandler = this.HandlePropertyDescriptorAdded;
+          break;
+
+        case ListChangedType.PropertyDescriptorChanged:
+          propertyDescriptorHandler = this.HandlePropertyDescriptorChanged;
+          break;
+
+        case ListChangedType.PropertyDescriptorDeleted:
+          propertyDescriptorHandler = this.HandlePropertyDescriptorDeleted;
+          break;
+
+        default:
+          propertyDescriptorHandler = null;
+          break;
       }
-      else
+
+      if( propertyDescriptorHandler != null )
       {
-        //Let's reset the list because a change to the list has happenned (e.g. a delete) before we had a chance to process the current change.
-        listChangedType = ListChangedType.Reset;
+        if( this.CheckAccess() )
+        {
+          propertyDescriptorHandler.Invoke( e.PropertyDescriptor );
+        }
+        else
+        {
+          this.Dispatcher.Invoke( new Action<PropertyDescriptor>( propertyDescriptorHandler ), e.PropertyDescriptor );
+        }
       }
-
-      lock( m_deferredOperationManager )
+      else
       {
-        if( m_deferredOperationManager.RefreshPending )
-          return;
+        IBindingList bindingList = ( IBindingList )m_enumeration;
+        int index = e.NewIndex;
+        IList items = null;
 
-        DeferredOperation deferredOperation = null;
+        if( ( listChangedType != ListChangedType.Reset ) && ( listChangedType != ListChangedType.ItemDeleted ) )
+        {
+          var indexInBound = ( index >= 0 ) && ( index < bindingList.Count );
+
+          //If we're within bounds
+          if( indexInBound )
+          {
+            //Let's get the item
+            items = new object[] { bindingList[ index ] };
+          }
+          else
+          {
+            //Let's reset the list because a change to the list has happenned (e.g. a delete) before we had a chance to process the current change.
+            listChangedType = ListChangedType.Reset;
+          }
+        }
 
-        switch( listChangedType )
+        lock( m_deferredOperationManager )
         {
-          case ListChangedType.ItemAdded:
-            {
-              deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Add, bindingList.Count, index, items );
-              break;
-            }
+          if( m_deferredOperationManager.RefreshPending )
+            return;
 
-          case ListChangedType.ItemChanged:
-            {
-              DataGridCollectionView view = this as DataGridCollectionView;
-              if( view != null && view.UpdateChangedPropertyStatsOnly && e.PropertyDescriptor != null )
+          DeferredOperation deferredOperation;
+
+          switch( listChangedType )
+          {
+            case ListChangedType.ItemAdded:
               {
-                view.CalculateChangedPropertyStatsOnly = true;
-                foreach( Stats.StatFunction statFunc in view.StatFunctions )
-                {
-                  if( statFunc.SourcePropertyName.Contains( e.PropertyDescriptor.Name ) && !view.InvalidatedStatFunctions.Contains( statFunc ) )
-                  {
-                    view.InvalidatedStatFunctions.Add( statFunc );
-                  }
-                }
+                deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Add, bindingList.Count, index, items );
+                break;
               }
 
-              deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Replace, -1, index, items, index, items );
-              break;
-            }
+            case ListChangedType.ItemChanged:
+              {
+                var collectionView = this as DataGridCollectionView;
 
-          case ListChangedType.ItemDeleted:
-            {
-              deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Remove, index, new object[ 1 ] );
-              break;
-            }
+                if( ( collectionView != null ) && collectionView.UpdateChangedPropertyStatsOnly && ( e.PropertyDescriptor != null ) )
+                {
+                  collectionView.CalculateChangedPropertyStatsOnly = true;
 
-          case ListChangedType.ItemMoved:
-            {
-              deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Move, -1, index, items, e.OldIndex, items );
-              break;
-            }
+                  var propertyName = e.PropertyDescriptor.Name;
+                  var invalidatedStatFunctions = collectionView.InvalidatedStatFunctions;
 
-          case ListChangedType.Reset:
-            {
-              deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Refresh, -1, null );
-              break;
-            }
+                  foreach( var statFunction in collectionView.StatFunctions.Where( sf => sf.SourcePropertyNames.Contains( propertyName ) ) )
+                  {
+                    if( !invalidatedStatFunctions.Contains( statFunction ) )
+                    {
+                      invalidatedStatFunctions.Add( statFunction );
+                    }
+                  }
+                }
 
-          case ListChangedType.PropertyDescriptorAdded:
-            {
-              if( this.CheckAccess() )
-              {
-                this.HandlePropertyDescriptorAdded( e.PropertyDescriptor );
-              }
-              else
-              {
-                this.Dispatcher.Invoke( new Action<PropertyDescriptor>( this.HandlePropertyDescriptorAdded ), e.PropertyDescriptor );
+                deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Replace, -1, index, items, index, items );
+                break;
               }
-              break;
-            }
 
-          case ListChangedType.PropertyDescriptorChanged:
-            {
-              if( this.CheckAccess() )
-              {
-                this.HandlePropertyDescriptorChanged( e.PropertyDescriptor );
-              }
-              else
+            case ListChangedType.ItemDeleted:
               {
-                this.Dispatcher.Invoke( new Action<PropertyDescriptor>( this.HandlePropertyDescriptorChanged ), e.PropertyDescriptor );
+                deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Remove, index, new object[ 1 ] );
+                break;
               }
-              break;
-            }
 
-          case ListChangedType.PropertyDescriptorDeleted:
-            {
-              if( this.CheckAccess() )
+            case ListChangedType.ItemMoved:
               {
-                this.HandlePropertyDescriptorDeleted( e.PropertyDescriptor );
+                deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Move, -1, index, items, e.OldIndex, items );
+                break;
               }
-              else
+
+            case ListChangedType.Reset:
               {
-                this.Dispatcher.Invoke( new Action<PropertyDescriptor>( this.HandlePropertyDescriptorDeleted ), e.PropertyDescriptor );
+                deferredOperation = new DeferredOperation( DeferredOperation.DeferredOperationAction.Refresh, -1, null );
+                break;
               }
-              break;
-            }
 
-          default:
-            throw new NotSupportedException( "This ListChangedType (" + listChangedType.ToString() + ") is not supported." );
-        }
+            default:
+              throw new NotSupportedException( "This ListChangedType (" + listChangedType.ToString() + ") is not supported." );
+          }
+
+          Debug.Assert( deferredOperation != null );
 
-        if( deferredOperation != null )
-        {
           this.ExecuteOrQueueSourceItemOperation( deferredOperation );
         }
       }
@@ -818,7 +904,7 @@ namespace Xceed.Wpf.DataGrid
 
     private void HandlePropertyDescriptorAdded( PropertyDescriptor property )
     {
-      // setting m_defaultItemProperties, will force the collection view to reanalyse the source to get a new list of default ItemProperties.
+      // setting m_defaultItemProperties, will force the collection view to reanalyze the source to get a new list of default ItemProperties.
       m_defaultItemProperties = null;
 
       if( this.AutoCreateItemProperties )
@@ -1094,6 +1180,8 @@ namespace Xceed.Wpf.DataGrid
       {
         lock( this.DeferredOperationManager )
         {
+          this.ClearGroupSortComparers();
+
           this.OnProxySortDescriptionsChanged( this, e );
 
           if( this.DataGridSortDescriptions.IsResortDefered )
@@ -1112,6 +1200,8 @@ namespace Xceed.Wpf.DataGrid
       {
         lock( this.DeferredOperationManager )
         {
+          this.ClearGroupSortComparers();
+
           this.OnProxyGroupDescriptionsChanged( this, e );
 
           this.ExecuteOrQueueSourceItemOperation( new DeferredOperation( DeferredOperation.DeferredOperationAction.Regroup, -1, null ) );
@@ -1136,7 +1226,9 @@ namespace Xceed.Wpf.DataGrid
     private void OnProxyApplyingFilterCriterias( object sender, EventArgs e )
     {
       if( m_rootDataGridCollectionViewBase.ProxyApplyingFilterCriterias != null )
+      {
         m_rootDataGridCollectionViewBase.ProxyApplyingFilterCriterias( sender, e );
+      }
     }
 
     internal event NotifyCollectionChangedEventHandler ProxyAutoFilterValuesChanged;
@@ -1144,7 +1236,9 @@ namespace Xceed.Wpf.DataGrid
     private void OnProxyAutoFilterValuesChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       if( m_rootDataGridCollectionViewBase.ProxyAutoFilterValuesChanged != null )
+      {
         m_rootDataGridCollectionViewBase.ProxyAutoFilterValuesChanged( sender, e );
+      }
     }
 
     internal event EventHandler ProxyCollectionRefresh;
@@ -1152,7 +1246,9 @@ namespace Xceed.Wpf.DataGrid
     internal void OnProxyCollectionRefresh()
     {
       if( m_rootDataGridCollectionViewBase.ProxyCollectionRefresh != null )
+      {
         m_rootDataGridCollectionViewBase.ProxyCollectionRefresh( this, EventArgs.Empty );
+      }
     }
 
     internal event NotifyCollectionChangedEventHandler ProxySortDescriptionsChanged;
@@ -1160,7 +1256,9 @@ namespace Xceed.Wpf.DataGrid
     internal void OnProxySortDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       if( m_rootDataGridCollectionViewBase.ProxySortDescriptionsChanged != null )
+      {
         m_rootDataGridCollectionViewBase.ProxySortDescriptionsChanged( sender, e );
+      }
     }
 
     internal event NotifyCollectionChangedEventHandler ProxyGroupDescriptionsChanged;
@@ -1168,7 +1266,9 @@ namespace Xceed.Wpf.DataGrid
     internal void OnProxyGroupDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       if( m_rootDataGridCollectionViewBase.ProxyGroupDescriptionsChanged != null )
+      {
         m_rootDataGridCollectionViewBase.ProxyGroupDescriptionsChanged( sender, e );
+      }
     }
 
     #endregion PROXY EVENTS
@@ -1319,10 +1419,14 @@ namespace Xceed.Wpf.DataGrid
     internal virtual void OnEditCanceled( DataGridItemEventArgs e )
     {
       if( this.EditCanceled != null )
+      {
         this.EditCanceled( this, e );
+      }
 
       if( m_parentCollectionViewSourceBase != null )
+      {
         m_parentCollectionViewSourceBase.OnEditCanceled( e );
+      }
     }
 
     public event EventHandler<DataGridItemCancelEventArgs> CommittingEdit;
@@ -1541,14 +1645,10 @@ namespace Xceed.Wpf.DataGrid
         {
           m_defaultDetailDescriptions = this.CreateDetailDescriptions();
 
-          // Ensure to Affect the AutoCreateForeignKeyDescription for every 
-          // DataGridDetailDescription created
-          foreach( DataGridDetailDescription description in m_defaultDetailDescriptions )
+          // Propagate the AutoCreateForeignKeyDescriptions values to the auto created DataGridDetailDescription.
+          foreach( var description in m_defaultDetailDescriptions.Where( item => item.IsAutoCreated ) )
           {
-            if( description.IsAutoCreated )
-            {
-              description.AutoCreateForeignKeyDescriptions = this.AutoCreateForeignKeyDescriptions;
-            }
+            description.AutoCreateForeignKeyDescriptions = this.AutoCreateForeignKeyDescriptions;
           }
         }
         else
@@ -1595,18 +1695,11 @@ namespace Xceed.Wpf.DataGrid
         return DataGridCollectionViewBase.CreateDetailDescriptionsForListSource();
 
       //If the Source collection implements ITypedList
-      ITypedList typedList = m_enumeration as ITypedList;
-
+      var typedList = m_enumeration as ITypedList;
       if( typedList != null )
         return DataGridCollectionViewBase.GetDataGridDetailDescriptions( typedList.GetItemProperties( null ) );
 
-      TypeDescriptionProvider typeDescriptionProvider = TypeDescriptor.GetProvider( m_itemType );
-      object firstItem = ItemsSourceHelper.GetFirstItemByEnumerable( m_enumeration );
-      ICustomTypeDescriptor customTypeDescriptor = firstItem as ICustomTypeDescriptor;
-
-      if( customTypeDescriptor == null )
-        customTypeDescriptor = typeDescriptionProvider.GetTypeDescriptor( m_itemType, firstItem );
-
+      var customTypeDescriptor = ItemsSourceHelper.GetCustomTypeDescriptor( m_enumeration, m_itemType );
       if( customTypeDescriptor != null )
         return DataGridCollectionViewBase.GetDataGridDetailDescriptions( customTypeDescriptor.GetProperties() );
 
@@ -1721,10 +1814,14 @@ namespace Xceed.Wpf.DataGrid
           m_autoFilterMode = value;
 
           if( value == AutoFilterMode.None )
+          {
             this.ResetDistinctValues();
+          }
 
           if( this.Loaded )
+          {
             this.Refresh();
+          }
 
           this.OnPropertyChanged( new PropertyChangedEventArgs( "AutoFilterMode" ) );
         }
@@ -1848,7 +1945,9 @@ namespace Xceed.Wpf.DataGrid
       }
 
       if( needsResort )
+      {
         cachedValues.Sort( sortComparer );
+      }
     }
 
     internal void RaiseAutoFilterValuesChangedEvent( AutoFilterValuesChangedEventArgs e )
@@ -1906,7 +2005,7 @@ namespace Xceed.Wpf.DataGrid
       return autoFilterValues;
     }
 
-    internal void ForceRefreshDistinctValuesForFieldName( string fieldName, ObservableHashList columnDistinctValues )
+    internal void ForceRefreshDistinctValuesForFieldName( string fieldName )
     {
       if( this.AutoFilterMode == AutoFilterMode.None )
         return;
@@ -1918,18 +2017,18 @@ namespace Xceed.Wpf.DataGrid
 
       this.IsRefreshingDistinctValues = true;
 
-      DataGridItemPropertyBase dataGridItemProperty = this.ItemProperties[ fieldName ];
+      try
+      {
+        var dataGridItemProperty = this.ItemProperties[ fieldName ];
+        if( ( dataGridItemProperty == null ) || ( !dataGridItemProperty.CalculateDistinctValues ) )
+          return;
 
-      if( ( dataGridItemProperty == null ) || ( !dataGridItemProperty.CalculateDistinctValues ) )
+        this.RefreshDistinctValuesForField( dataGridItemProperty );
+      }
+      finally
       {
         this.IsRefreshingDistinctValues = false;
-        return;
       }
-
-      this.RefreshDistinctValuesForField( dataGridItemProperty );
-
-      // Reset flags
-      this.IsRefreshingDistinctValues = false;
     }
 
     internal abstract void RefreshDistinctValuesForField( DataGridItemPropertyBase dataGridItemProperty );
@@ -1946,27 +2045,29 @@ namespace Xceed.Wpf.DataGrid
 
       this.IsRefreshingDistinctValues = true;
 
-      int dataGridItemPropertiesCount = m_itemProperties.Count;
-
-      for( int propertyIndex = 0; propertyIndex < dataGridItemPropertiesCount; propertyIndex++ )
+      try
       {
-        DataGridItemPropertyBase dataGridItemProperty = m_itemProperties[ propertyIndex ];
+        for( int propertyIndex = 0; propertyIndex < m_itemProperties.Count; propertyIndex++ )
+        {
+          var dataGridItemProperty = m_itemProperties[ propertyIndex ];
 
-        if( !dataGridItemProperty.CalculateDistinctValues )
-          continue;
+          if( !dataGridItemProperty.CalculateDistinctValues )
+            continue;
 
-        if( dataGridItemProperty == m_excludedItemPropertyFromDistinctValueCalculation )
-          continue;
+          if( dataGridItemProperty == m_excludedItemPropertyFromDistinctValueCalculation )
+            continue;
 
-        // No modifications to filtered items, do not calculated Distinct Values for this DataGridItemProperty
-        if( ( this.DistinctValuesConstraint == DistinctValuesConstraint.Filtered ) && ( !filteredItemsChanged ) )
-          continue;
+          // No modifications to filtered items, do not calculated Distinct Values for this DataGridItemProperty
+          if( ( this.DistinctValuesConstraint != DistinctValuesConstraint.All ) && ( !filteredItemsChanged ) )
+            continue;
 
-        this.RefreshDistinctValuesForField( dataGridItemProperty );
+          this.RefreshDistinctValuesForField( dataGridItemProperty );
+        }
+      }
+      finally
+      {
+        this.IsRefreshingDistinctValues = false;
       }
-
-      // Reset flags
-      this.IsRefreshingDistinctValues = false;
     }
 
     internal void RefreshDistinctValues( bool filteredItemsChanged )
@@ -1977,37 +2078,27 @@ namespace Xceed.Wpf.DataGrid
 
       lock( this.SyncRoot )
       {
-        lock( m_deferredOperationManager )
+        lock( this.DeferredOperationManager )
         {
-          this.ExecuteOrQueueSourceItemOperation(
-            new DeferredOperation(
-              DeferredOperation.DeferredOperationAction.RefreshDistincValues,
-              filteredItemsChanged ) );
+          if( m_autoFilterMode == DataGrid.AutoFilterMode.None )
+            return;
+
+          if( filteredItemsChanged )
+          {
+            this.ExecuteOrQueueSourceItemOperation( DeferredOperation.RefreshDistinctValuesOperationWithFilteredItemsChanged );
+          }
+          else
+          {
+            this.ExecuteOrQueueSourceItemOperation( DeferredOperation.RefreshDistinctValuesOperation );
+          }
         }
       }
     }
 
     private void ResetDistinctValues()
     {
-      if( m_distinctValues == null )
-        return;
-
-      foreach( DataGridItemPropertyBase dataGridItemProperty in this.ItemProperties )
-      {
-        ReadOnlyObservableHashList readOnlyList = null;
-
-        // Not all field will be initialized
-        if( ( ( DistinctValuesDictionary )this.DistinctValues ).InternalTryGetValue( dataGridItemProperty.Name, out readOnlyList ) )
-        {
-          if( readOnlyList != null )
-          {
-            IList values = readOnlyList.InnerObservableHashList;
-
-            if( values != null )
-              values.Clear();
-          }
-        }
-      }
+      //The internal ReadOnlyObservableHashList's must be removed, so they are re-created and properly populated when they are queried again.
+      m_distinctValues.InternalClear();
     }
 
     private void ResetAutoFilterValues()
@@ -2208,6 +2299,27 @@ namespace Xceed.Wpf.DataGrid
 
     #region DEFERRED OPERATIONS HANDLING
 
+    internal event EventHandler PreBatchCollectionChanged;
+    internal event EventHandler PostBatchCollectionChanged;
+
+    internal void RaisePreBatchCollectionChanged()
+    {
+      var handler = this.PreBatchCollectionChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, EventArgs.Empty );
+    }
+
+    internal void RaisePostBatchCollectionChanged()
+    {
+      var handler = this.PostBatchCollectionChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, EventArgs.Empty );
+    }
+
     internal void EnsureThread()
     {
       if( !this.CheckAccess() )
@@ -2241,13 +2353,12 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
+        if( this.InDeferRefresh || !this.CheckAccess() )
+          return true;
+
         lock( m_deferredOperationManager )
         {
-          return
-            ( !this.Loaded )
-            || ( m_deferRefreshCount != 0 )
-            || ( m_deferredOperationManager.HasPendingOperations )
-            || ( !this.CheckAccess() );
+          return ( !this.Loaded ) || ( m_deferredOperationManager.HasPendingOperations );
         }
       }
     }
@@ -2288,16 +2399,13 @@ namespace Xceed.Wpf.DataGrid
     {
       bool queueOperationForPendingAddNew = this.MustQueueOperationForPendingAddNew( deferredOperation.OldStartingIndex, deferredOperation.OldItems, deferredOperation.NewItems );
 
-      if( ( this.ShouldDeferOperation ) || ( queueOperationForPendingAddNew ) )
+      if( queueOperationForPendingAddNew )
       {
-        if( queueOperationForPendingAddNew )
-        {
-          this.AddDeferredOperationForAddNew( deferredOperation );
-        }
-        else
-        {
-          this.AddDeferredOperation( deferredOperation );
-        }
+        this.AddDeferredOperationForAddNew( deferredOperation );
+      }
+      else if( this.ShouldDeferOperation )
+      {
+        this.AddDeferredOperation( deferredOperation );
       }
       else
       {
@@ -2326,7 +2434,24 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion DEFERRED OPERATIONS HANDLING
 
-    internal virtual void ProcessInvalidatedGroupStats( List<DataGridCollectionViewGroup> invalidatedGroups, bool ensurePosition )
+    protected override void OnCollectionChanged( NotifyCollectionChangedEventArgs args )
+    {
+
+      if( ( args != null )
+        && ( ( ( args.NewItems != null ) && ( args.NewItems.Count > 1 ) )
+          || ( ( args.OldItems != null ) && ( args.OldItems.Count > 1 ) ) ) )
+      {
+        args = new NotifyRangeCollectionChangedEventArgs( args );
+      }
+
+      base.OnCollectionChanged( args );
+    }
+
+    internal virtual void ProcessInvalidatedGroupStats( HashSet<DataGridCollectionViewGroup> invalidatedGroups )
+    {
+    }
+
+    internal virtual void ClearGroupSortComparers()
     {
     }
 
@@ -2342,24 +2467,24 @@ namespace Xceed.Wpf.DataGrid
       m_sortDescriptions = ( parentDetailDescription == null ) ? new DataGridSortDescriptionCollection() :
         parentDetailDescription.SortDescriptions as DataGridSortDescriptionCollection;
 
-      m_groupDescriptions = ( parentDetailDescription == null ) ? new GroupDescriptionCollection() :
-        parentDetailDescription.GroupDescriptions;
+      m_groupDescriptions = ( parentDetailDescription == null ) ? new GroupDescriptionCollection() : parentDetailDescription.GroupDescriptions;
     }
 
-    internal virtual void RegisterCollectionChanged()
+    internal virtual void RegisterChangedEvents()
     {
-      ( ( INotifyCollectionChanged )m_sortDescriptions ).CollectionChanged +=
-        new NotifyCollectionChangedEventHandler( this.OnSortDescriptionsChanged );
+      ( ( INotifyCollectionChanged )m_sortDescriptions ).CollectionChanged += new NotifyCollectionChangedEventHandler( this.OnSortDescriptionsChanged );
+      ( ( INotifyCollectionChanged )m_groupDescriptions ).CollectionChanged += new NotifyCollectionChangedEventHandler( this.OnGroupDescriptionsChanged );
 
-      ( ( INotifyCollectionChanged )m_groupDescriptions ).CollectionChanged +=
-        new NotifyCollectionChangedEventHandler( this.OnGroupDescriptionsChanged );
+      ItemPropertyGroupSortStatNameChangedEventManager.AddListener( m_itemProperties, this );
     }
 
-    internal virtual void UnregisterChangedEvent()
+    internal virtual void UnregisterChangedEvents()
     {
       ( ( INotifyCollectionChanged )m_sortDescriptions ).CollectionChanged -= this.OnSortDescriptionsChanged;
       ( ( INotifyCollectionChanged )m_groupDescriptions ).CollectionChanged -= this.OnGroupDescriptionsChanged;
 
+      ItemPropertyGroupSortStatNameChangedEventManager.RemoveListener( m_itemProperties, this );
+
       m_itemProperties.CollectionChanged -= this.ItemProperties_CollectionChanged;
       m_itemProperties.FilterCriterionChanged -= this.ItemProperties_FilterCriterionChanged;
 
@@ -2374,6 +2499,12 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    internal void PrepareRootContextForDeferRefresh( DataGridContext dataGridContext )
+    {
+      this.DataGridContext = dataGridContext;
+      m_detailDeferRefreshes = new List<List<IDisposable>>();
+    }
+
     private void SetupDefaultDetailDescriptions()
     {
       if( this.CanHaveDetails )
@@ -2440,7 +2571,7 @@ namespace Xceed.Wpf.DataGrid
       m_filterCriteriaMode = m_parentDetailDescription.FilterCriteriaMode;
 
       //Register to the change notifications for the Group/Sort descriptions collections
-      this.RegisterCollectionChanged();
+      this.RegisterChangedEvents();
 
       // - then call the SetSource, with the source and the itemType...
       this.SetSource( null, collection, itemType, false );
@@ -2466,23 +2597,15 @@ namespace Xceed.Wpf.DataGrid
         m_itemProperties.DefaultItemProperties = new List<DataGridItemPropertyBase>( this.GetDefaultItemProperties() );
       }
 
-      // Creates the item properties if auto-creation is ON no one already created them.
+      // Creates the item properties if auto-creation is ON and no one already created them.
       if( ( this.AutoCreateItemProperties )
         && ( !m_parentDetailDescription.AutoCreateItemPropertiesCompleted ) )
       {
+        this.DetectSynonyms( m_itemProperties );
+
         foreach( DataGridItemPropertyBase itemProperty in m_defaultItemProperties )
         {
-          //  
-          if( !itemProperty.Browsable )
-            continue;
-
-          if( itemProperty.IsASubRelationship )
-            continue;
-
-          if( m_itemProperties[ itemProperty.Name ] == null )
-          {
-            m_itemProperties.Add( itemProperty );
-          }
+          this.AddValidItemProperty( itemProperty );
         }
 
         m_parentDetailDescription.AutoCreateItemPropertiesCompleted = true;
@@ -2604,6 +2727,9 @@ namespace Xceed.Wpf.DataGrid
         if( this.CanCreateItemProperties() )
         {
           m_defaultItemProperties = this.CreateItemProperties();
+
+          // Set the synonyms on the item properties of the detail collection.
+          this.DetectSynonyms( m_defaultItemProperties );
         }
         else
         {
@@ -2668,6 +2794,30 @@ namespace Xceed.Wpf.DataGrid
       return properties;
     }
 
+    private void DetectSynonyms( IEnumerable<DataGridItemPropertyBase> itemProperties )
+    {
+      // The root CollectionView does not need to have its ItemProperties binded.
+      if( this.IsRootCollectionView || ( itemProperties == null ) )
+        return;
+
+      var rootItemsProperties = m_rootDataGridCollectionViewBase.ItemProperties;
+      Debug.Assert( rootItemsProperties != null );
+
+      foreach( var itemProperty in itemProperties )
+      {
+        // A Synonym is already set.
+        if( itemProperty.Synonym != null )
+          continue;
+
+        // Bind the DataGridItemProperty to a DataGridItemProperty of the root CollectionView.
+        var matchingItemProperty = rootItemsProperties[ itemProperty.Name ];
+        if( ( matchingItemProperty != null ) && ( matchingItemProperty.DataType == itemProperty.DataType ) )
+        {
+          itemProperty.SetSynonym( matchingItemProperty.Name );
+        }
+      }
+    }
+
     #region IWeakEventListener Members
 
     bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
@@ -2692,6 +2842,12 @@ namespace Xceed.Wpf.DataGrid
         return true;
       }
 
+      if( managerType == typeof( ItemPropertyGroupSortStatNameChangedEventManager ) )
+      {
+        this.ClearGroupSortComparers();
+        return true;
+      }
+
       return false;
     }
 
@@ -2701,6 +2857,22 @@ namespace Xceed.Wpf.DataGrid
 
     public override IDisposable DeferRefresh()
     {
+      this.EnsureThread();
+
+      var dataGridContext = this.DataGridContext;
+
+      if( dataGridContext != null )
+      {
+        //Make sure detail DataGridCollectionView's are also deferred.
+        List<IDisposable> detailDisposables = new List<IDisposable>();
+        foreach( DataGridContext detailContext in dataGridContext.GetChildContextsCore() )
+        {
+          detailDisposables.Add( detailContext.Items.DeferRefresh() );
+        }
+
+        m_detailDeferRefreshes.Add( detailDisposables );
+      }
+
       return new DataGridCollectionView.DeferRefreshHelper( this );
     }
 
@@ -2708,15 +2880,32 @@ namespace Xceed.Wpf.DataGrid
     {
       this.EnsureThread();
 
-      // We are not calling ShouldDeferOperation, we only want to defer operation if we are
-      // in defer refresh.
-      if( m_deferRefreshCount != 0 )
+      var dataGridContext = this.DataGridContext;
+
+      if( this.InDeferRefresh )
       {
-        this.AddDeferredOperation( new DeferredOperation(
-          DeferredOperation.DeferredOperationAction.Refresh, -1, null ) );
+        if( dataGridContext != null )
+        {
+          //Make sure to queue a Refresh on all detail DataGridCollectionView's.
+          foreach( DataGridContext detailContext in dataGridContext.GetChildContextsCore() )
+          {
+            detailContext.Items.Refresh();
+          }
+        }
+
+        this.AddDeferredOperation( new DeferredOperation( DeferredOperation.DeferredOperationAction.Refresh, -1, null ) );
       }
       else
       {
+        if( dataGridContext != null )
+        {
+          //Make sure all detail DataGridCollectionView's are refreshed.
+          foreach( DataGridContext detailContext in dataGridContext.GetChildContextsCore() )
+          {
+            detailContext.Items.Refresh();
+          }
+        }
+
         this.OnProxyCollectionRefresh();
         this.ForceRefresh( true, !this.Loaded, true );
       }
@@ -2822,6 +3011,9 @@ namespace Xceed.Wpf.DataGrid
         if( !this.CanFilter )
           throw new NotSupportedException();
 
+        if( ( value == null ) && ( value == m_filter ) )
+          return;
+
         m_filter = value;
         this.Refresh();
       }
@@ -3191,8 +3383,7 @@ namespace Xceed.Wpf.DataGrid
               bool readOnly = ( ( m_currentEditItem == m_currentAddItem )
                               && itemProperty.OverrideReadOnlyForInsertion.HasValue
                               && itemProperty.OverrideReadOnlyForInsertion.Value )
-                ? false
-                : itemProperty.IsReadOnly;
+                ? false : itemProperty.IsReadOnly;
 
               if( !readOnly )
               {
@@ -3435,58 +3626,84 @@ namespace Xceed.Wpf.DataGrid
       AutoCreateForeignKeyDescriptions = 4096,
     }
 
-    #region Private Class DeferRefreshHelper
-
     private sealed class DeferRefreshHelper : IDisposable
     {
       public DeferRefreshHelper( DataGridCollectionViewBase collectionView )
       {
         m_collectionView = collectionView;
-        collectionView.m_deferRefreshCount++;
+
+        Interlocked.Increment( ref collectionView.m_deferRefreshCount );
       }
 
-      public void Dispose()
+      void IDisposable.Dispose()
       {
-        if( m_collectionView == null )
-          return;
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var collectionView = m_collectionView;
 
-        m_collectionView.m_deferRefreshCount--;
+        // Prevent this method from being invoked more than once by the same IDisposable.
+        if( Interlocked.CompareExchange<DataGridCollectionViewBase>( ref m_collectionView, null, collectionView ) == null )
+          return;
 
-        if( m_collectionView.CheckAccess() )
+        if( collectionView.CheckAccess() )
         {
-          this.ProcessDispose();
+          DeferRefreshHelper.ProcessDispose( collectionView );
         }
         else
         {
-          //In case Dispose is called from a different thread, make sure the refresh is not lost!
-          m_collectionView.Dispatcher.BeginInvoke( DispatcherPriority.Send, new Action( this.ProcessDispose ) );
+          //In case Dispose is called from a different thread, make sure the refresh is done on the UI thread.
+          collectionView.Dispatcher.BeginInvoke( new Action<DataGridCollectionViewBase>( DeferRefreshHelper.ProcessDispose ), DispatcherPriority.Send, collectionView );
         }
       }
 
-      private void ProcessDispose()
+      private static void ProcessDispose( DataGridCollectionViewBase collectionView )
       {
-        if( m_collectionView.Loaded )
+        //If there are detail DataGridCollectionView's being defered.
+        if( collectionView.m_detailDeferRefreshes != null && collectionView.m_detailDeferRefreshes.Count > 0 )
         {
-          m_collectionView.m_deferredOperationManager.Process();
+          //Dispose them.
+          foreach( IDisposable detailDisposable in collectionView.m_detailDeferRefreshes[ 0 ] )
+          {
+            if( detailDisposable != null )
+            {
+              detailDisposable.Dispose();
+            }
+          }
+
+          //Clear and remove the list that was just disposed of.
+          collectionView.m_detailDeferRefreshes[ 0 ].Clear();
+          collectionView.m_detailDeferRefreshes.RemoveAt( 0 );
+        }
+
+        //Only process the DeferRefresh when count is back to 0.
+        if( Interlocked.Decrement( ref collectionView.m_deferRefreshCount ) > 0 )
+          return;
+
+        if( collectionView.Loaded )
+        {
+          collectionView.m_deferredOperationManager.Process();
         }
         else
         {
-          // We call ForceRefresh when not yet "Loaded" because we want the Dispose here to
-          // triger the CollectionChanged( NotifyCollectionChangedAction.Reset )
-          // That is needed because of the way the ItemsControl, other than our grid, work.
-          m_collectionView.ForceRefresh( true, true, true );
+          // We call ForceRefresh when not yet "Loaded" because we want the Dispose here to triger the CollectionChanged( NotifyCollectionChangedAction.Reset )
+          // This is needed because of the way the ItemsControl works (other than our grid).
+          collectionView.ForceRefresh( true, true, true );
         }
+      }
 
-        m_collectionView = null;
+      ~DeferRefreshHelper()
+      {
+        //Make sure the defering process for the CollectionView stays in a valid state, by disposing of details and properly setting the count.
+        this.Dispose( false );
       }
 
       private DataGridCollectionViewBase m_collectionView;
     }
 
-    #endregion Private Class DeferRefreshHelper
-
-    #region Private Class DeferCurrencyEventHelper
-
     private sealed class DeferCurrencyEventHelper : IDisposable
     {
       public DeferCurrencyEventHelper( DataGridCollectionViewBase collectionView )
@@ -3494,60 +3711,97 @@ namespace Xceed.Wpf.DataGrid
         m_collectionView = collectionView;
         m_oldCurrentItem = m_collectionView.CurrentItem;
         m_oldCurrentPosition = m_collectionView.CurrentPosition;
-        m_oldIsCurrentAfterLast = m_collectionView.IsCurrentAfterLast;
         m_oldIsCurrentBeforeFirst = m_collectionView.IsCurrentBeforeFirst;
-        m_collectionView.m_deferCurrencyEventCount++;
+        m_oldIsCurrentAfterLast = m_collectionView.IsCurrentAfterLast;
+
+        Interlocked.Increment( ref m_collectionView.m_deferCurrencyEventCount );
       }
 
-      public void Dispose()
+      void IDisposable.Dispose()
       {
-        if( m_collectionView == null )
-          return;
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var collectionView = m_collectionView;
 
-        m_collectionView.m_deferCurrencyEventCount--;
+        // Prevent this method from being invoked more than once by the same IDisposable.
+        if( Interlocked.CompareExchange<DataGridCollectionViewBase>( ref m_collectionView, null, collectionView ) == null )
+          return;
 
-        if( m_collectionView.m_deferCurrencyEventCount == 0 )
+        if( collectionView.CheckAccess() )
         {
-          bool itemChanged = false;
+          DeferCurrencyEventHelper.ProcessDispose( collectionView, m_oldCurrentItem, m_oldCurrentPosition, m_oldIsCurrentBeforeFirst, m_oldIsCurrentAfterLast );
+        }
+        else
+        {
+          // Make sure the calls to the collection view will be done on the collection view's thread.
+          collectionView.Dispatcher.BeginInvoke(
+            new Action<DataGridCollectionViewBase, object, int, bool, bool>( DeferCurrencyEventHelper.ProcessDispose ),
+            DispatcherPriority.Send,
+            collectionView,
+            m_oldCurrentItem,
+            m_oldCurrentPosition,
+            m_oldIsCurrentBeforeFirst,
+            m_oldIsCurrentAfterLast );
+        }
+      }
 
-          if( !object.Equals( m_oldCurrentItem, m_collectionView.CurrentItem ) )
-          {
-            itemChanged = true;
-            m_collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentItem" ) );
-          }
+      private static void ProcessDispose(
+        DataGridCollectionViewBase collectionView,
+        object oldCurrentItem,
+        int oldCurrentPosition,
+        bool oldIsCurrentBeforeFirst,
+        bool oldIsCurrentAfterLast )
+      {
+        if( Interlocked.Decrement( ref collectionView.m_deferCurrencyEventCount ) > 0 )
+          return;
 
-          if( m_oldCurrentPosition != m_collectionView.CurrentPosition )
-          {
-            itemChanged = true;
-            m_collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentPosition" ) );
-          }
+        bool itemChanged = false;
 
-          if( m_oldIsCurrentBeforeFirst != m_collectionView.IsCurrentBeforeFirst )
-          {
-            itemChanged = true;
-            m_collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentBeforeFirst" ) );
-          }
+        if( !object.Equals( oldCurrentItem, collectionView.CurrentItem ) )
+        {
+          itemChanged = true;
+          collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentItem" ) );
+        }
 
-          if( m_oldIsCurrentAfterLast != m_collectionView.IsCurrentAfterLast )
-          {
-            itemChanged = true;
-            m_collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentAfterLast" ) );
-          }
+        if( oldCurrentPosition != collectionView.CurrentPosition )
+        {
+          itemChanged = true;
+          collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentPosition" ) );
+        }
 
-          if( itemChanged )
-            m_collectionView.OnCurrentChanged();
+        if( oldIsCurrentBeforeFirst != collectionView.IsCurrentBeforeFirst )
+        {
+          itemChanged = true;
+          collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentBeforeFirst" ) );
+        }
+
+        if( oldIsCurrentAfterLast != collectionView.IsCurrentAfterLast )
+        {
+          itemChanged = true;
+          collectionView.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentAfterLast" ) );
         }
 
-        m_collectionView = null;
+        if( itemChanged )
+        {
+          collectionView.OnCurrentChanged();
+        }
       }
 
-      private int m_oldCurrentPosition;
-      private object m_oldCurrentItem;
-      private bool m_oldIsCurrentAfterLast;
-      private bool m_oldIsCurrentBeforeFirst;
+      ~DeferCurrencyEventHelper()
+      {
+        this.Dispose( false );
+      }
+
+      private readonly int m_oldCurrentPosition;
+      private readonly object m_oldCurrentItem;
+      private readonly bool m_oldIsCurrentAfterLast;
+      private readonly bool m_oldIsCurrentBeforeFirst;
+
       private DataGridCollectionViewBase m_collectionView;
     }
-
-    #endregion Private Class DeferCurrencyEventHelper
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewEnumerator.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewEnumerator.cs
index 254bd0b7..500fe8d3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewEnumerator.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewEnumerator.cs
@@ -58,7 +58,7 @@ namespace Xceed.Wpf.DataGrid
       {
         m_beforeStart = false;
 
-        if( ( m_currentGroup != null ) && ( m_currentGroup.RawItems == null ) )
+        if( ( m_currentGroup != null ) && ( m_currentGroup.RawItems.Count == 0 ) )
         {
           // This should only occur if the first leaf group encountered after the Reset call was empty.
           this.MoveToNextNonEmptyLeafGroup();
@@ -71,14 +71,14 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        if( ( m_currentGroup == null ) || ( m_currentGroup.RawItems == null ) )
+        if( ( m_currentGroup == null ) || ( m_currentGroup.RawItems.Count == 0 ) )
         {
           m_afterEnd = true;
         }
         else
         {
           //check indexes
-          if( m_currentItemIndex < m_currentGroup.RawItems.Count ) 
+          if( m_currentItemIndex < m_currentGroup.RawItems.Count )
           {
             m_current = m_currentGroup.RawItems[ m_currentItemIndex ];
             m_currentItemIndex++;
@@ -114,7 +114,7 @@ namespace Xceed.Wpf.DataGrid
         {
           m_currentGroup = this.MoveToFirstLeafGroup( m_currentGroup, index );
 
-          foundNonEmptyLeafGroup = ( ( m_currentGroup.RawItems != null ) && ( m_currentGroup.RawItems.Count > 0 ) );
+          foundNonEmptyLeafGroup = ( m_currentGroup.RawItems.Count > 0 );
         }
       }
 
@@ -144,8 +144,7 @@ namespace Xceed.Wpf.DataGrid
       m_currentItemIndex = 0;
       m_currentGroupIndex.Clear();
 
-      m_currentGroup = ( m_collectionView.Count == 0 ) ?
-        null : this.MoveToFirstLeafGroup( m_collectionView.RootGroup, 0 );
+      m_currentGroup = ( m_collectionView.Count == 0 ) ? null : this.MoveToFirstLeafGroup( m_collectionView.RootGroup, 0 );
     }
 
     #endregion
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroup.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroup.cs
index 787aa712..5a6ae74f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroup.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroup.cs
@@ -18,36 +18,46 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Text;
-using System.Windows.Data;
+using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Globalization;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Windows.Data;
+using Xceed.Wpf.DataGrid.Stats;
 
 namespace Xceed.Wpf.DataGrid
 {
   internal class DataGridCollectionViewGroup : CollectionViewGroup, ICustomTypeDescriptor
   {
-    public DataGridCollectionViewGroup( object name, DataGridCollectionViewGroup parent, int unsortedIndex )
-      : base( name )
+    protected DataGridCollectionViewGroup( int capacity )
+      : this( null, null, 0, capacity, 4 )
     {
-      m_parent = parent;
-      m_unsortedIndex = unsortedIndex;
     }
 
-    internal DataGridCollectionViewGroup(
-      DataGridCollectionViewGroup template,
-      DataGridCollectionViewGroup parent )
-      : this( template.Name, parent, template.m_unsortedIndex )
+    protected DataGridCollectionViewGroup( DataGridCollectionViewGroup template, DataGridCollectionViewGroup parent )
+      : this( template.Name, parent, template.m_unsortedIndex, template.m_sortedRawItems.Count, template.m_subGroups.Count )
     {
       m_nextSubGroupUnsortedIndex = template.m_nextSubGroupUnsortedIndex;
       m_subGroupBy = template.m_subGroupBy;
+    }
 
-      if( template.m_groupsDictionary != null )
-        m_groupsDictionary = new Hashtable();
+    private DataGridCollectionViewGroup( object name, DataGridCollectionViewGroup parent, int unsortedIndex )
+      : this( name, parent, unsortedIndex, 4, 4 )
+    {
+    }
 
-      if( template.m_sortedRawItems != null )
-        m_sortedRawItems = new List<RawItem>( template.m_sortedRawItems.Count );
+    private DataGridCollectionViewGroup( object name, DataGridCollectionViewGroup parent, int unsortedIndex, int rawCapacity, int groupCapacity )
+      : base( name )
+    {
+      m_parent = parent;
+      m_unsortedIndex = unsortedIndex;
+      m_protectedItems = ObservableCollectionHelper.GetItems( base.ProtectedItems );
+      m_protectedItemsCollectionChanged = ObservableCollectionHelper.GetCollectionChanged( base.ProtectedItems );
+      m_optimizedItems = new OptimizedReadOnlyObservableCollection( this );
+      m_subGroups = new Dictionary<object, DataGridCollectionViewGroup>( groupCapacity );
+      m_sortedRawItems = new List<RawItem>( rawCapacity );
     }
 
     #region IsBottomLevel Property
@@ -56,40 +66,24 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        // return true if .Items contain DataItem
+        // returns true if .Items contain DataItem
         return ( m_subGroupBy == null );
       }
     }
 
-    #endregion IsBottomLevel Property
+    #endregion
 
     #region Items Property
 
-    public new ReadOnlyObservableCollection<object> Items
+    internal new ReadOnlyObservableCollection<object> Items
     {
       get
       {
-        // The optimized list is only able to handle Items. When we are not at the bottom level,
-        // this means that our Items collection return sub-groups.
-        if( this.IsBottomLevel )
-        {
-          if( m_optimizedItems == null )
-            m_optimizedItems = new OptimizedReadOnlyObservableCollection( this );
-
-          return m_optimizedItems;
-        }
-
-        // The group hierarchy can change over time. If, at this point, 
-        // we are not eligible to return the optimized list (we contains
-        // sub groups or our source item list is not a DataGridCollectionView),
-        // we must reset our cached list.
-        m_optimizedItems = null;
-
-        return base.Items;
+        return m_optimizedItems;
       }
     }
 
-    #endregion Items Property
+    #endregion
 
     #region ProtectedItems Property
 
@@ -101,7 +95,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion ProtectedItems Property
+    #endregion
 
     #region UnsortedIndex Property
 
@@ -113,7 +107,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion UnsortedIndex Property
+    #endregion
 
     #region SubGroupBy Property
 
@@ -125,7 +119,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion SubGroupBy Property
+    #endregion
 
     #region Parent Property
 
@@ -137,7 +131,41 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion Parent Property
+    #endregion
+
+    #region CalculateAllStats Property
+
+    internal bool CalculateAllStats
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region GlobalRawItemCount Property
+
+    internal int GlobalRawItemCount
+    {
+      get
+      {
+        return m_globalRawItemCount;
+      }
+    }
+
+    #endregion
+
+    #region RawItems Property
+
+    internal List<RawItem> RawItems
+    {
+      get
+      {
+        return m_sortedRawItems;
+      }
+    }
+
+    #endregion
 
     protected virtual DataGridCollectionView GetCollectionView()
     {
@@ -147,34 +175,43 @@ namespace Xceed.Wpf.DataGrid
       return null;
     }
 
-    internal bool Contains( object dataItem )
+    internal bool Contains( object item )
     {
+      var group = item as DataGridCollectionViewGroup;
+      if( group != null )
+      {
+        //Must make sure the group the group is ref equals, because there can be groups with a null name at more than one level.
+        DataGridCollectionViewGroup foundGroup;
+        if( m_subGroups.TryGetValue( DataGridCollectionViewGroup.GetHashKeyFromName( group.Name ), out foundGroup ) )
+          return ( foundGroup == group );
+
+        return false;
+      }
+
       DataGridCollectionView collectionView = this.GetCollectionView();
       if( collectionView != null )
       {
-        RawItem rawItem = collectionView.GetFirstRawItemFromDataItem( dataItem );
+        RawItem rawItem = collectionView.GetFirstRawItemFromDataItem( item );
         if( rawItem != null )
-        {
           return ( rawItem.ParentGroup == this );
-        }
       }
 
       return false;
     }
 
-    internal int IndexOf( object dataItem )
+    internal int IndexOf( object item )
     {
+      if( item is DataGridCollectionViewGroup )
+        return this.ProtectedItems.IndexOf( item );
+
       DataGridCollectionView collectionView = this.GetCollectionView();
 
       if( collectionView != null )
       {
-        RawItem rawItem = collectionView.GetFirstRawItemFromDataItem( dataItem );
+        RawItem rawItem = collectionView.GetFirstRawItemFromDataItem( item );
 
-        if( ( rawItem != null )
-          && ( rawItem.ParentGroup == this ) )
-        {
+        if( ( rawItem != null ) && ( rawItem.ParentGroup == this ) )
           return rawItem.SortedIndex;
-        }
       }
 
       return -1;
@@ -184,24 +221,18 @@ namespace Xceed.Wpf.DataGrid
     {
       int index = 0;
       DataGridCollectionViewGroup group = this;
-      DataGridCollectionViewGroup parent = group;
-
-      if( parent != null )
-        parent = parent.Parent;
+      DataGridCollectionViewGroup parent = this.Parent;
+      DataGridCollectionViewGroup currentGroup = null;
 
       while( parent != null )
       {
-        ReadOnlyObservableCollection<object> subGroups = parent.Items;
-        int subGroupCount = subGroups.Count;
-        DataGridCollectionViewGroup currentGroup = null;
-
-        for( int i = 0; i < subGroupCount; i++ )
+        foreach( object value in parent.ProtectedItems )
         {
-          currentGroup = subGroups[ i ] as DataGridCollectionViewGroup;
-
-          if( currentGroup == group )
+          if( value == group )
             break;
 
+          currentGroup = value as DataGridCollectionViewGroup;
+
           index += currentGroup.GlobalRawItemCount;
         }
 
@@ -217,14 +248,10 @@ namespace Xceed.Wpf.DataGrid
       bool oldIsBottomLevel = this.IsBottomLevel;
       m_subGroupBy = groupBy;
 
-      if( m_subGroupBy != null )
-      {
-        if( m_groupsDictionary == null )
-          m_groupsDictionary = new Hashtable();
-      }
-
       if( oldIsBottomLevel != this.IsBottomLevel )
+      {
         this.OnPropertyChanged( new PropertyChangedEventArgs( "IsBottomLevel" ) );
+      }
     }
 
     internal DataGridCollectionViewGroup GetGroup(
@@ -232,7 +259,7 @@ namespace Xceed.Wpf.DataGrid
       int level,
       CultureInfo culture,
       ObservableCollection<GroupDescription> groupByList,
-      GroupSortComparer[] groupSortComparers )
+      List<GroupSortComparer> groupSortComparers )
     {
       // If sortComparers is null, we are in massive group creation, no order check.
 
@@ -240,23 +267,19 @@ namespace Xceed.Wpf.DataGrid
         throw new InvalidOperationException( "An attempt was made to get a group for which a GroupDescription has not been provided." );
 
       object groupName = m_subGroupBy.GroupNameFromItem( rawItem.DataItem, level, culture );
-      DataGridGroupDescription dataGridGroupDescription = m_subGroupBy as DataGridGroupDescription;
       DataGridCollectionViewGroup group;
 
-      if( dataGridGroupDescription != null )
+      if( ( m_subGroupBy is DataGridGroupDescription ) || ( m_subGroupBy is PropertyGroupDescription ) )
       {
-        group = m_groupsDictionary[ DataGridCollectionViewGroup.GetHashKeyFromName( groupName ) ]
-          as DataGridCollectionViewGroup;
+        m_subGroups.TryGetValue( DataGridCollectionViewGroup.GetHashKeyFromName( groupName ), out group );
       }
       else
       {
-        int itemCount = this.ItemCount;
+        //If dealing with an unknown GroupDescription type, use the standard method to retrieve a group, in case group retrival is handle differently.
         group = null;
 
-        for( int i = 0; i < itemCount; i++ )
+        foreach( var tempGroup in m_subGroups.Values )
         {
-          DataGridCollectionViewGroup tempGroup = this.ProtectedItems[ i ] as DataGridCollectionViewGroup;
-
           if( m_subGroupBy.NamesMatch( tempGroup.Name, groupName ) )
           {
             group = tempGroup;
@@ -267,8 +290,7 @@ namespace Xceed.Wpf.DataGrid
 
       if( group == null )
       {
-        group = this.CreateSubGroup(
-          groupName, level, groupByList, groupSortComparers );
+        group = this.CreateSubGroup( groupName, level, groupByList, groupSortComparers );
       }
 
       return group;
@@ -276,32 +298,27 @@ namespace Xceed.Wpf.DataGrid
 
     internal void SortItems(
       SortDescriptionInfo[] sortDescriptionInfos,
-      GroupSortComparer[] groupSortComparers,
+      List<GroupSortComparer> groupSortComparers,
       int level,
       List<RawItem> globalRawItems,
       DataGridCollectionViewGroup newSortedGroup )
     {
-      int itemCount = this.ItemCount;
+      int itemCount = this.ProtectedItemCount;
 
       if( itemCount == 0 )
         return;
 
-      ObservableCollection<object> groupItems = this.ProtectedItems;
-
       if( this.IsBottomLevel )
       {
         int[] indexes;
-
         indexes = new int[ itemCount + 1 ];
-
         for( int i = 0; i < itemCount; i++ )
         {
           indexes[ i ] = m_sortedRawItems[ i ].Index;
         }
 
         // "Weak heap sort" sort array[0..NUM_ELEMENTS-1] to array[1..NUM_ELEMENTS]
-        DataGridCollectionViewSort collectionViewSort =
-          new DataGridCollectionViewSort( indexes, sortDescriptionInfos );
+        DataGridCollectionViewSort collectionViewSort = new DataGridCollectionViewSort( indexes, sortDescriptionInfos );
 
         collectionViewSort.Sort( itemCount );
         int index = 0;
@@ -315,17 +332,17 @@ namespace Xceed.Wpf.DataGrid
       else
       {
         int[] indexes;
-
         indexes = new int[ itemCount + 1 ];
-
         for( int i = 0; i < itemCount; i++ )
         {
           indexes[ i ] = i;
         }
 
+        DataGridCollectionViewGroup[] subGroupsArray = new DataGridCollectionViewGroup[ itemCount ];
+        m_subGroups.Values.CopyTo( subGroupsArray, 0 );
+
         // "Weak heap sort" sort array[0..NUM_ELEMENTS-1] to array[1..NUM_ELEMENTS]
-        DataGridCollectionViewGroupSort collectionViewSort =
-          new DataGridCollectionViewGroupSort( indexes, groupSortComparers[ level ], this );
+        DataGridCollectionViewGroupSort collectionViewSort = new DataGridCollectionViewGroupSort( indexes, groupSortComparers[ level ], subGroupsArray );
 
         collectionViewSort.Sort( itemCount );
         int index = 0;
@@ -333,7 +350,7 @@ namespace Xceed.Wpf.DataGrid
 
         for( int i = 1; i <= itemCount; i++ )
         {
-          DataGridCollectionViewGroup oldGroup = ( DataGridCollectionViewGroup )groupItems[ indexes[ i ] ];
+          DataGridCollectionViewGroup oldGroup = subGroupsArray[ indexes[ i ] ];
           DataGridCollectionViewGroup newGroup = new DataGridCollectionViewGroup( oldGroup, newSortedGroup );
 
           // Sort sub items
@@ -345,62 +362,48 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    internal int BinarySearchGroup( DataGridCollectionViewGroup value, IComparer<DataGridCollectionViewGroup> comparer )
+    internal void SortGroups( List<GroupSortComparer> groupSortComparers, int level )
     {
-      if( comparer == null )
-        throw new ArgumentNullException( "comparer" );
-
-      ObservableCollection<object> items = this.ProtectedItems;
-
-      Debug.Assert( items.Count == this.ItemCount );
+      int itemCount = this.ProtectedItemCount;
 
-      int low = 0;
-      int hi = ( items.Count ) - 1;
+      if( itemCount == 0 )
+        return;
 
-      while( low <= hi )
+      int[] indexes;
+      indexes = new int[ itemCount + 1 ];
+      for( int i = 0; i < itemCount; i++ )
       {
-        int compareResult;
-        int median = ( low + ( ( hi - low ) >> 1 ) );
+        indexes[ i ] = i;
+      }
 
-        DataGridCollectionViewGroup medianGroup = items[ median ] as DataGridCollectionViewGroup;
+      DataGridCollectionViewGroup[] subGroupsArray = new DataGridCollectionViewGroup[ itemCount ];
+      m_subGroups.Values.CopyTo( subGroupsArray, 0 );
 
-        // We exclude ourself from the research because we seek for a new valid position
-        if( medianGroup == value )
-        {
-          if( low == hi )
-            return low;
+      // "Weak heap sort" sort array[0..NUM_ELEMENTS-1] to array[1..NUM_ELEMENTS]
+      DataGridCollectionViewGroupSort collectionViewSort = new DataGridCollectionViewGroupSort( indexes, groupSortComparers[ level ], subGroupsArray );
 
-          median++;
-          medianGroup = items[ median ] as DataGridCollectionViewGroup;
-        }
+      collectionViewSort.Sort( itemCount );
+      level++;
+      m_protectedItems.Clear();
 
-        try
-        {
-          compareResult = comparer.Compare( medianGroup, value );
-        }
-        catch( Exception exception )
-        {
-          throw new InvalidOperationException( "IComparer has failed to compare the values.", exception );
-        }
+      for( int i = 1; i <= itemCount; i++ )
+      {
+        DataGridCollectionViewGroup group = subGroupsArray[ indexes[ i ] ];
 
-        if( compareResult == 0 )
-        {
-          return median;
-        }
-        if( compareResult < 0 )
+        // Sort sub groups
+        if( !group.IsBottomLevel )
         {
-          low = median + 1;
-        }
-        else
-        {
-          hi = median - 1;
+          group.SortGroups( groupSortComparers, level );
         }
+
+        m_protectedItems.Add( group );
       }
 
-      return ~low;
+      this.ProtectedItemCount = m_protectedItems.Count;
+      m_protectedItemsCollectionChanged.Invoke( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
     }
 
-    internal void CreateFixedGroupNames( int fixedGroupLevel, ObservableCollection<GroupDescription> groupByList, GroupSortComparer[] groupSortComparers )
+    internal void CreateFixedGroupNames( int fixedGroupLevel, ObservableCollection<GroupDescription> groupByList, List<GroupSortComparer> groupSortComparers )
     {
       GroupDescription groupDescription = this.SubGroupBy;
 
@@ -419,43 +422,6 @@ namespace Xceed.Wpf.DataGrid
     }
 
 
-    internal int GlobalRawItemCount
-    {
-      get
-      {
-        return m_globalRawItemCount;
-      }
-    }
-
-    internal List<RawItem> RawItems
-    {
-      get
-      {
-        return m_sortedRawItems;
-      }
-    }
-
-    internal void GetGlobalItems( List<object> items )
-    {
-      if( this.IsBottomLevel )
-      {
-        items.AddRange( this.ProtectedItems );
-        return;
-      }
-
-      int count = this.ItemCount;
-
-      for( int i = 0; i < count; i++ )
-      {
-        DataGridCollectionViewGroup subGroup = this.ProtectedItems[ i ] as DataGridCollectionViewGroup;
-
-        if( subGroup == null )
-          throw new InvalidOperationException( "Sub-groups cannot be null (Nothing in Visual Basic)." );
-
-        subGroup.GetGlobalItems( items );
-      }
-    }
-
     internal RawItem GetRawItemAtGlobalSortedIndex( int index )
     {
       if( this.IsBottomLevel )
@@ -464,19 +430,14 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        int count = this.ItemCount;
-
-        for( int i = 0; i < count; i++ )
+        foreach( object value in this.ProtectedItems )
         {
-          DataGridCollectionViewGroup subGroups = this.ProtectedItems[ i ] as DataGridCollectionViewGroup;
-
-          if( subGroups == null )
-            throw new InvalidOperationException( "Sub-groups cannot be null (Nothing in Visual Basic)." );
+          DataGridCollectionViewGroup subGroup = value as DataGridCollectionViewGroup;
 
-          int subGroupCount = subGroups.GlobalRawItemCount;
+          int subGroupCount = subGroup.GlobalRawItemCount;
 
           if( index < subGroupCount )
-            return subGroups.GetRawItemAtGlobalSortedIndex( index );
+            return subGroup.GetRawItemAtGlobalSortedIndex( index );
 
           index -= subGroupCount;
         }
@@ -499,9 +460,6 @@ namespace Xceed.Wpf.DataGrid
     {
       Debug.Assert( this.IsBottomLevel );
 
-      if( m_sortedRawItems == null )
-        m_sortedRawItems = new List<RawItem>( 4 );
-
       m_globalRawItemCount++;
       DataGridCollectionViewGroup parent = m_parent;
 
@@ -526,21 +484,13 @@ namespace Xceed.Wpf.DataGrid
       this.ProtectedItems.Insert( index, rawItem.DataItem );
     }
 
-    internal void RemoveRawItem( RawItem rawItem )
-    {
-      if( !this.IsBottomLevel )
-        throw new InvalidOperationException( "An attempt was made to remove a data item from a group other than the bottom-level group." );
-
-      int index = this.RawItemIndexOf( rawItem );
-      this.RemoveRawItemAt( index );
-    }
-
     internal virtual void RemoveRawItemAt( int index )
     {
       Debug.Assert( this.IsBottomLevel );
-      Debug.Assert( m_sortedRawItems != null );
+      Debug.Assert( m_sortedRawItems.Count > 0 );
 
-      if( m_sortedRawItems == null )
+      int count = m_sortedRawItems.Count;
+      if( count == 0 )
         return;
 
       if( index != -1 )
@@ -554,8 +504,6 @@ namespace Xceed.Wpf.DataGrid
           parent = parent.Parent;
         }
 
-        int count = m_sortedRawItems.Count;
-
         for( int i = index + 1; i < count; i++ )
         {
           m_sortedRawItems[ i ].SetSortedIndex( i - 1 );
@@ -570,7 +518,9 @@ namespace Xceed.Wpf.DataGrid
         this.ProtectedItems.RemoveAt( index );
 
         if( ( this.ProtectedItemCount == 0 ) && ( m_parent != null ) )
+        {
           m_parent.RemoveGroup( this );
+        }
       }
     }
 
@@ -606,7 +556,7 @@ namespace Xceed.Wpf.DataGrid
       if( m_sortedRawItems == null )
         return -1; // ~0
 
-      Debug.Assert( ( m_sortedRawItems.Count == this.ItemCount ) || ( this is DataGridCollectionViewGroupRoot ) );
+      Debug.Assert( ( m_sortedRawItems.Count == this.ProtectedItemCount ) || ( this is DataGridCollectionViewGroupRoot ) );
 
       int low = 0;
       int hi = ( m_sortedRawItems.Count ) - 1;
@@ -664,7 +614,7 @@ namespace Xceed.Wpf.DataGrid
       if( view == null )
         return null;
 
-      Stats.StatFunction statFunction = view.StatFunctions[ propertyName ];
+      StatFunction statFunction = view.StatFunctions[ propertyName ];
 
       Debug.Assert( view != null );
 
@@ -674,12 +624,17 @@ namespace Xceed.Wpf.DataGrid
       return this.GetStatFunctionResult( statFunction, view ).Value;
     }
 
-    internal Stats.StatResult GetStatFunctionResult( Stats.StatFunction statFunction, DataGridCollectionView view )
+    internal StatResult GetStatFunctionResult( StatFunction statFunction, DataGridCollectionView view )
     {
-      if( !m_statFunctionValues.ContainsKey( statFunction ) )
-        this.CalculateStatFunctionValue( statFunction, view );
+      StatResult result;
+
+      if( !m_statFunctionValues.TryGetValue( statFunction, out result ) )
+      {
+        result = null;
+        m_statFunctionValues[ statFunction ] = result;
+      }
 
-      return m_statFunctionValues[ statFunction ];
+      return result;
     }
 
     // This clears the value of all the previously calculated StatFunction Results for  this group.
@@ -688,31 +643,80 @@ namespace Xceed.Wpf.DataGrid
       m_statFunctionValues.Clear();
     }
 
-    internal void InvokeStatFunctionsPropertyChanged( DataGridCollectionView view )
+    internal void InvokeStatFunctionsPropertyChanged( DataGridCollectionView collectionView )
     {
-      if( view.CalculateChangedPropertyStatsOnly )
+      if( this.HasPropertyChangedListeners )
       {
-        foreach( Stats.StatFunction statFunction in view.InvalidatedStatFunctions )
+        if( collectionView.CalculateChangedPropertyStatsOnly && !this.CalculateAllStats )
         {
+          foreach( StatFunction statFunction in collectionView.InvalidatedStatFunctions )
           {
-            this.OnPropertyChanged( new PropertyChangedEventArgs( statFunction.ResultPropertyName ) );
+            {
+              this.OnPropertyChanged( new PropertyChangedEventArgs( statFunction.ResultPropertyName ) );
+            }
           }
         }
-      }
-      else
-      {
-        foreach( PropertyDescriptor statFunctionPropertyDescriptor in view.GetStatFunctionProperties() )
+        else
         {
-          this.OnPropertyChanged( new PropertyChangedEventArgs( statFunctionPropertyDescriptor.Name ) );
+          foreach( PropertyDescriptor statFunctionPropertyDescriptor in collectionView.GetStatFunctionProperties() )
+          {
+            this.OnPropertyChanged( new PropertyChangedEventArgs( statFunctionPropertyDescriptor.Name ) );
+          }
         }
       }
+
+      this.CalculateAllStats = false;
     }
 
-    private void CalculateStatFunctionValue( Stats.StatFunction statFunction, DataGridCollectionView view )
+
+    private int BinarySearchGroup( DataGridCollectionViewGroup value, IComparer<DataGridCollectionViewGroup> comparer )
     {
-      m_statFunctionValues[ statFunction ] = new Stats.StatResult(
-        new InvalidOperationException( Log.NotToolkitStr( "Statistical functions" ) )
-        );
+      if( comparer == null )
+        throw new ArgumentNullException( "comparer" );
+
+      int low = 0;
+      int hi = ( this.ProtectedItemCount ) - 1;
+      int median;
+      int compareResult;
+
+      while( low <= hi )
+      {
+        median = ( low + ( ( hi - low ) >> 1 ) );
+
+        DataGridCollectionViewGroup medianGroup = this.ProtectedItems[ median ] as DataGridCollectionViewGroup;
+
+        if( medianGroup == value )
+        {
+          if( low == hi )
+            return low;
+
+          return median;
+        }
+
+        try
+        {
+          compareResult = comparer.Compare( medianGroup, value );
+        }
+        catch( Exception exception )
+        {
+          throw new InvalidOperationException( "IComparer has failed to compare the values.", exception );
+        }
+
+        if( compareResult == 0 )
+        {
+          return median;
+        }
+        if( compareResult < 0 )
+        {
+          low = median + 1;
+        }
+        else
+        {
+          hi = median - 1;
+        }
+      }
+
+      return ~low;
     }
 
     private static object GetHashKeyFromName( object groupName )
@@ -723,7 +727,8 @@ namespace Xceed.Wpf.DataGrid
       return groupName;
     }
 
-    private DataGridCollectionViewGroup CreateSubGroup( object groupName, int level, ObservableCollection<GroupDescription> groupByList, GroupSortComparer[] groupSortComparers )
+    private DataGridCollectionViewGroup CreateSubGroup( object groupName, int level, ObservableCollection<GroupDescription> groupByList,
+                                                        List<GroupSortComparer> groupSortComparers )
     {
       // If sortComparers is null, we are in massive group creation, no order check.
       DataGridCollectionViewGroup group = new DataGridCollectionViewGroup( groupName, this, m_nextSubGroupUnsortedIndex );
@@ -745,7 +750,9 @@ namespace Xceed.Wpf.DataGrid
         index = this.BinarySearchGroup( group, groupSortComparers[ level ] );
 
         if( index < 0 )
+        {
           index = ~index;
+        }
       }
 
       level++;
@@ -764,7 +771,7 @@ namespace Xceed.Wpf.DataGrid
     {
       Debug.Assert( !this.IsBottomLevel );
 
-      m_groupsDictionary.Add( DataGridCollectionViewGroup.GetHashKeyFromName( group.Name ), group );
+      m_subGroups.Add( DataGridCollectionViewGroup.GetHashKeyFromName( group.Name ), group );
       this.ProtectedItemCount++;
       this.ProtectedItems.Insert( index, group );
     }
@@ -783,12 +790,15 @@ namespace Xceed.Wpf.DataGrid
       Debug.Assert( !this.IsBottomLevel );
       Debug.Assert( ( group.m_globalRawItemCount == 0 ) && ( group.ProtectedItemCount == 0 ) );
 
+      m_subGroups.Remove( DataGridCollectionViewGroup.GetHashKeyFromName( group.Name ) );
+
       this.ProtectedItemCount--;
-      m_groupsDictionary.Remove( DataGridCollectionViewGroup.GetHashKeyFromName( group.Name ) );
       this.ProtectedItems.Remove( group );
 
-      if( ( this.ProtectedItemCount == 0 ) && ( m_parent != null ) )
+      if( ( m_subGroups.Count == 0 ) && ( m_parent != null ) )
+      {
         m_parent.RemoveGroup( this );
+      }
     }
 
     #region ICustomTypeDescriptor Members
@@ -893,20 +903,211 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region INotifyPropertyChanged Members
+
+    protected sealed override event PropertyChangedEventHandler PropertyChanged
+    {
+      add
+      {
+        this.PropertyChangedImpl += value;
+      }
+      remove
+      {
+        this.PropertyChangedImpl -= value;
+      }
+    }
+
+    protected override void OnPropertyChanged( PropertyChangedEventArgs e )
+    {
+      var handler = this.PropertyChangedImpl;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, e );
+    }
+
+    private bool HasPropertyChangedListeners
+    {
+      get
+      {
+        return ( this.PropertyChangedImpl != null );
+      }
+    }
+
+    private event PropertyChangedEventHandler PropertyChangedImpl;
+
+    #endregion
+
     private PropertyDescriptorCollection m_classProperties;
-    private Dictionary<Stats.StatFunction, Stats.StatResult> m_statFunctionValues = new Dictionary<Stats.StatFunction, Stats.StatResult>( s_statFunctionComparer );
+    private readonly Dictionary<StatFunction, StatResult> m_statFunctionValues = new Dictionary<StatFunction, StatResult>( StatFunctionComparer.Default );
 
     protected int m_globalRawItemCount;
-    protected List<RawItem> m_sortedRawItems;
+    protected readonly List<RawItem> m_sortedRawItems;
+
+    private readonly OptimizedReadOnlyObservableCollection m_optimizedItems;
+    private readonly Dictionary<object, DataGridCollectionViewGroup> m_subGroups;
+    private readonly IList<object> m_protectedItems;
+    private readonly Action<NotifyCollectionChangedEventArgs> m_protectedItemsCollectionChanged;
 
-    private Hashtable m_groupsDictionary;
     private GroupDescription m_subGroupBy;
-    private DataGridCollectionViewGroup m_parent;
-    private int m_unsortedIndex;
+    private readonly DataGridCollectionViewGroup m_parent;
+    private readonly int m_unsortedIndex;
     private int m_nextSubGroupUnsortedIndex;
 
-    private static Stats.StatFunctionComparer s_statFunctionComparer = new Stats.StatFunctionComparer();
+    #region OptimizedReadOnlyObservableCollection Private Class
+
+    // We re-implement IList and IList<object> to override the implementation of the 
+    // IndexOf and Contains methods to use our optimized way.
+    private sealed class OptimizedReadOnlyObservableCollection : ReadOnlyObservableCollection<object>, IList, IList<object>
+    {
+      internal OptimizedReadOnlyObservableCollection( DataGridCollectionViewGroup dataGridCollectionViewGroup )
+        : base( dataGridCollectionViewGroup.ProtectedItems )
+      {
+        if( dataGridCollectionViewGroup == null )
+          throw new ArgumentNullException( "dataGridCollectionViewGroup" );
+
+        m_dataGridCollectionViewGroup = dataGridCollectionViewGroup;
+      }
+
+      public new int IndexOf( object item )
+      {
+        // The DataGridCollectionViewGroup has been optimized to use the information
+        // stored on the RawItem associated with the data item instead of searching the item in the list.
+        return m_dataGridCollectionViewGroup.IndexOf( item );
+      }
+
+      public new bool Contains( object item )
+      {
+        // The DataGridCollectionViewGroup has been optimized to use the information
+        // stored on the RawItem associated with the data item instead of searching the item in the list.
+        return m_dataGridCollectionViewGroup.Contains( item );
+      }
+
+      private readonly DataGridCollectionViewGroup m_dataGridCollectionViewGroup;
+    }
+
+    #endregion
+
+    #region ObservableCollectionHelper Private Class
+
+    private static class ObservableCollectionHelper
+    {
+      private const string AssemblyName = "Xceed.Wpf.DataGrid.CollectionViewGroupExtractor";
+      private const string GetItemsMethodName = "GetItems";
+      private const string GetCollectionChangedMethodName = "GetCollectionChanged";
+
+      private static readonly Func<ObservableCollection<object>, IList<object>> s_getItems;
+      private static readonly Func<ObservableCollection<object>, Action<NotifyCollectionChangedEventArgs>> s_collectionChanged;
+
+      static ObservableCollectionHelper()
+      {
+        var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( new AssemblyName( ObservableCollectionHelper.AssemblyName ), AssemblyBuilderAccess.RunAndCollect );
+        var moduleBuilder = assemblyBuilder.DefineDynamicModule( ObservableCollectionHelper.AssemblyName );
+
+        var typeBuilder = moduleBuilder.DefineType( "ObservableCollectionExtractor", TypeAttributes.Class | TypeAttributes.NotPublic | TypeAttributes.AutoLayout, typeof( ObservableCollection<object> ) );
+
+        ObservableCollectionHelper.DefineGetItemsMethod( typeBuilder );
+        ObservableCollectionHelper.DefineGetCollectionChangedMethod( typeBuilder );
+
+        var targetType = typeBuilder.CreateType();
+
+        s_getItems = ( Func<ObservableCollection<object>, IList<object>> )Delegate.CreateDelegate( typeof( Func<ObservableCollection<object>, IList<object>> ), targetType.GetMethod( ObservableCollectionHelper.GetItemsMethodName, BindingFlags.Public | BindingFlags.Static ) );
+        s_collectionChanged = ( Func<ObservableCollection<object>, Action<NotifyCollectionChangedEventArgs>> )Delegate.CreateDelegate( typeof( Func<ObservableCollection<object>, Action<NotifyCollectionChangedEventArgs>> ), targetType.GetMethod( ObservableCollectionHelper.GetCollectionChangedMethodName, BindingFlags.Public | BindingFlags.Static ) );
+      }
+
+      internal static IList<object> GetItems( ObservableCollection<object> source )
+      {
+        if( source == null )
+          throw new ArgumentNullException( "source" );
+
+        var storage = ( s_getItems != null ) ? s_getItems.Invoke( source ) : null;
+        if( storage == null )
+          throw new InvalidOperationException( "TODODOC: Unable to retrieve the ObservableCollection<>'s items storage." );
 
-    private OptimizedReadOnlyObservableCollection m_optimizedItems;
+        return storage;
+      }
+
+      internal static Action<NotifyCollectionChangedEventArgs> GetCollectionChanged( ObservableCollection<object> source )
+      {
+        if( source == null )
+          throw new ArgumentNullException( "source" );
+
+        var collectionChanged = ( s_collectionChanged != null ) ? s_collectionChanged.Invoke( source ) : null;
+        if( collectionChanged == null )
+          throw new InvalidOperationException( "TODODOC: Unable to retrieve the ObservableCollection<>'s collection change method." );
+
+        return collectionChanged;
+      }
+
+      private static void DefineGetItemsMethod( TypeBuilder typeBuilder )
+      {
+        var propertyInfo = typeof( ObservableCollection<object> ).GetProperty( "Items", BindingFlags.Instance | BindingFlags.NonPublic, null, typeof( IList<object> ), new Type[ 0 ], null );
+        if( ( propertyInfo == null ) || !propertyInfo.CanRead )
+          throw new InvalidOperationException( "TODODOC: Unable to retrieve the ObservableCollection<>.Items property." );
+
+        var methodInfo = propertyInfo.GetGetMethod( true );
+        if( ( methodInfo == null ) || !ObservableCollectionHelper.HasCallingConvention( methodInfo.CallingConvention, CallingConventions.HasThis ) )
+          throw new InvalidOperationException( "TODODOC: Unable to retrieve the ObservableCollection<>.Items property." );
+
+        var methodBuilder = typeBuilder.DefineMethod(
+                              ObservableCollectionHelper.GetItemsMethodName,
+                              MethodAttributes.Public | MethodAttributes.Static,
+                              CallingConventions.Standard,
+                              typeof( IList<object> ),
+                              new Type[] { typeof( ObservableCollection<object> ) } );
+
+        var body = methodBuilder.GetILGenerator();
+        // Load the reference to the ObservableCollection and put it on top of the stack.
+        body.Emit( OpCodes.Ldarg_0 );
+        // Invoke the property getter of the reference.  This operation pops the reference
+        // from the stack and pushes the result of the property getter.
+        body.Emit( OpCodes.Callvirt, methodInfo );
+        // Since the result of the propery getter will be retrieved by the method's caller,
+        // we may leave it on the stack and simply return.
+        body.Emit( OpCodes.Ret );
+      }
+
+      private static void DefineGetCollectionChangedMethod( TypeBuilder typeBuilder )
+      {
+        var methodInfo = typeof( ObservableCollection<object> ).GetMethod( "OnCollectionChanged", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof( NotifyCollectionChangedEventArgs ) }, null );
+        if( ( methodInfo == null ) || methodInfo.IsPrivate || !ObservableCollectionHelper.HasCallingConvention( methodInfo.CallingConvention, CallingConventions.HasThis ) )
+          throw new InvalidOperationException( "TODODOC: Unable to retrieve the ObservableCollection<>.OnCollectionChanged method." );
+
+        var constructorInfo = typeof( Action<NotifyCollectionChangedEventArgs> ).GetConstructor( new Type[] { typeof( object ), typeof( IntPtr ) } );
+        if( ( constructorInfo == null ) || constructorInfo.IsPrivate || !ObservableCollectionHelper.HasCallingConvention( constructorInfo.CallingConvention, CallingConventions.HasThis ) )
+          throw new InvalidOperationException( "TODODOC: Unable to retrieve the Action<>'s constructor." );
+
+        var methodBuilder = typeBuilder.DefineMethod(
+                              ObservableCollectionHelper.GetCollectionChangedMethodName,
+                              MethodAttributes.Public | MethodAttributes.Static,
+                              CallingConventions.Standard,
+                              typeof( Action<NotifyCollectionChangedEventArgs> ),
+                              new Type[] { typeof( ObservableCollection<object> ) } );
+
+        var body = methodBuilder.GetILGenerator();
+        // Load the reference to the ObservableCollection and put it on top of the stack.
+        body.Emit( OpCodes.Ldarg_0 );
+        // The last loaded reference will be consume in the call to "new Action<>".
+        // We must duplicate the value since it will be consume by the call that retrieve the
+        // target method's address.
+        body.Emit( OpCodes.Dup );
+        // This operation pops the top ObservableCollection's reference from the stack
+        // and pushes the ObservableCollection<>.OnCollectionChanged method's address.
+        body.Emit( OpCodes.Ldvirtftn, methodInfo );
+        // Create an Action<> delegate from the first ObservableCollection's reference we
+        // have put on the stack and the target method's address.
+        body.Emit( OpCodes.Newobj, constructorInfo );
+        // The resulting delegate should be on top of the stack.  We simply leave it there
+        // so it will be retrieved by the method's caller.
+        body.Emit( OpCodes.Ret );
+      }
+
+      private static bool HasCallingConvention( CallingConventions source, CallingConventions value )
+      {
+        return ( ( source & value ) == value );
+      }
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupRoot.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupRoot.cs
index 5cce5afa..56b01404 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupRoot.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupRoot.cs
@@ -16,22 +16,15 @@
 
 using System;
 using System.Collections.Generic;
-using System.Text;
-using System.Windows.Data;
 using System.Diagnostics;
 
 namespace Xceed.Wpf.DataGrid
 {
   internal class DataGridCollectionViewGroupRoot : DataGridCollectionViewGroup
   {
-    #region CONSTRUCTORS
-
-    public DataGridCollectionViewGroupRoot( DataGridCollectionView parentCollectionView )
-      : base( null, null, 0 )
+    internal DataGridCollectionViewGroupRoot( DataGridCollectionView parentCollectionView )
+      : base( 128 )
     {
-      if( parentCollectionView == null )
-        throw new ArgumentNullException( "parentCollectionView" );
-
       m_parentCollectionView = parentCollectionView;
     }
 
@@ -41,44 +34,28 @@ namespace Xceed.Wpf.DataGrid
       m_parentCollectionView = template.m_parentCollectionView;
     }
 
-    #endregion CONSTRUCTORS
-
-    #region PROTECTED METHODS
-
     protected override DataGridCollectionView GetCollectionView()
     {
       return m_parentCollectionView;
     }
 
-    #endregion PROTECTED METHODS
-
-    #region INTERNAL METHODS
-
     internal void SortRootRawItems( SortDescriptionInfo[] sortDescriptionInfos, List<RawItem> globalRawItems )
     {
       Debug.Assert( this.IsBottomLevel );
-      List<RawItem> rawItems = this.RawItems;
-
-      if( rawItems == null )
-        return;
-
-      int itemCount = rawItems.Count;
 
+      int itemCount = m_sortedRawItems.Count;
       if( itemCount == 0 )
         return;
 
       int[] indexes;
-
       indexes = new int[ itemCount + 1 ];
-
       for( int i = 0; i < itemCount; i++ )
       {
-        indexes[ i ] = rawItems[ i ].Index;
+        indexes[ i ] = m_sortedRawItems[ i ].Index;
       }
 
       // "Weak heap sort" sort array[0..NUM_ELEMENTS-1] to array[1..NUM_ELEMENTS]
-      DataGridCollectionViewSort collectionViewSort =
-        new DataGridCollectionViewSort( indexes, sortDescriptionInfos );
+      DataGridCollectionViewSort collectionViewSort = new DataGridCollectionViewSort( indexes, sortDescriptionInfos );
 
       collectionViewSort.Sort( itemCount );
       int index = 0;
@@ -87,22 +64,15 @@ namespace Xceed.Wpf.DataGrid
       {
         RawItem newRawItem = globalRawItems[ indexes[ i ] ];
         newRawItem.SetSortedIndex( index );
-        rawItems[ index ] = newRawItem;
+        m_sortedRawItems[ index ] = newRawItem;
         index++;
       }
     }
 
-    #endregion INTERNAL METHODS
-
-    #region RawItem management for BottomLevel
-
     internal override void InsertRawItem( int index, RawItem rawItem )
     {
       Debug.Assert( this.IsBottomLevel );
 
-      if( m_sortedRawItems == null )
-        m_sortedRawItems = new List<RawItem>( 128 );
-
       m_globalRawItemCount++;
       int count = m_sortedRawItems.Count;
 
@@ -119,11 +89,15 @@ namespace Xceed.Wpf.DataGrid
     internal override void RemoveRawItemAt( int index )
     {
       Debug.Assert( this.IsBottomLevel );
+      Debug.Assert( m_sortedRawItems.Count > 0 );
+
+      int count = m_sortedRawItems.Count;
+      if( count == 0 )
+        return;
 
       if( index != -1 )
       {
         m_globalRawItemCount--;
-        int count = m_sortedRawItems.Count;
 
         for( int i = index + 1; i < count; i++ )
         {
@@ -155,12 +129,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion RawItem management for BottomLevel
-
-    #region PRIVATE FILEDS
-
     private DataGridCollectionView m_parentCollectionView;
-
-    #endregion PRIVATE FIELDS
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupSort.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupSort.cs
index e7eaae3f..40627242 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupSort.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewGroupSort.cs
@@ -27,31 +27,25 @@ namespace Xceed.Wpf.DataGrid
 {
   internal class DataGridCollectionViewGroupSort : IndexWeakHeapSort
   {
-    public DataGridCollectionViewGroupSort( 
-      int[] dataIndexArray,
-      GroupSortComparer groupSortedComparer,
-      DataGridCollectionViewGroup parentGroup )
+    public DataGridCollectionViewGroupSort( int[] dataIndexArray, GroupSortComparer groupSortedComparer, DataGridCollectionViewGroup[] protectedItems )
       : base( dataIndexArray )
     {
-      if( parentGroup == null )
-        throw new ArgumentNullException( "parentGroup" );
-
       if( groupSortedComparer == null )
         throw new ArgumentNullException( "groupSortedComparer" );
 
       m_groupSortedComparer = groupSortedComparer;
-      m_groups = parentGroup.ProtectedItems;
+      m_groups = protectedItems;
     }
 
     public override int Compare( int xDataIndex, int yDataIndex )
     {
-      DataGridCollectionViewGroup xGroup = m_groups[ xDataIndex ] as DataGridCollectionViewGroup;
-      DataGridCollectionViewGroup yGroup = m_groups[ yDataIndex ] as DataGridCollectionViewGroup;
+      DataGridCollectionViewGroup xGroup = m_groups[ xDataIndex ];
+      DataGridCollectionViewGroup yGroup = m_groups[ yDataIndex ];
 
       return m_groupSortedComparer.Compare( xGroup, yGroup );
     }
 
     private GroupSortComparer m_groupSortedComparer;
-    private ObservableCollection<object> m_groups;
+    private DataGridCollectionViewGroup[] m_groups;
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSource.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSource.cs
index dbe4fcf1..195bb6db 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSource.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSource.cs
@@ -15,15 +15,11 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Windows;
 using System.Windows.Data;
-using System.Collections;
-using System.Globalization;
-using System.Collections.ObjectModel;
-using System.Collections.Specialized;
-using System.Collections.Generic;
-using System.Diagnostics;
 using Xceed.Wpf.DataGrid.Stats;
 
 namespace Xceed.Wpf.DataGrid
@@ -64,7 +60,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region StatFunctions Property
 
-    internal ObservableCollection<Stats.StatFunction> StatFunctions
+    internal ObservableCollection<StatFunction> StatFunctions
     {
       get
       {
@@ -72,7 +68,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private ObservableCollection<Stats.StatFunction> m_statFunctions;
+    private StatFunctionCollection m_statFunctions;
 
     #endregion StatFunctions Property
 
@@ -115,11 +111,10 @@ namespace Xceed.Wpf.DataGrid
       DataGridCollectionView dataGridCollectionView = currentView as DataGridCollectionView;
 
       dataGridCollectionView.StatFunctions.Clear();
-      int count = m_statFunctions.Count;
 
-      for( int i = 0; i < count; i++ )
+      foreach( var statFunction in m_statFunctions )
       {
-        dataGridCollectionView.StatFunctions.Add( m_statFunctions[ i ] );
+        dataGridCollectionView.StatFunctions.Add( statFunction );
       }
 
       dataGridCollectionView.UpdateChangedPropertyStatsOnly = this.UpdateChangedPropertyStatsOnly;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSourceBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSourceBase.cs
index 25fbce7b..8900c0c6 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSourceBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridCollectionViewSourceBase.cs
@@ -482,7 +482,9 @@ namespace Xceed.Wpf.DataGrid
     internal void OnEditCanceled( DataGridItemEventArgs e )
     {
       if( this.EditCanceled != null )
+      {
         this.EditCanceled( this, e );
+      }
     }
 
     public event EventHandler<DataGridItemCancelEventArgs> CommittingEdit;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridDetailDescription.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridDetailDescription.cs
index e8f81cd0..b74e6e1c 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridDetailDescription.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridDetailDescription.cs
@@ -108,7 +108,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region AutoCreateItemProperty Public Property
+    #region AutoCreateItemProperties Public Property
 
     public bool AutoCreateItemProperties
     {
@@ -258,7 +258,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region StatFunctions Public Property
 
-    public StatFunctionCollection StatFunctions
+    internal StatFunctionCollection StatFunctions
     {
       get
       {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemProperty.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemProperty.cs
index 4fac5037..a3797db3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemProperty.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemProperty.cs
@@ -384,7 +384,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion PropertyDescriptor Property
 
-    #region IsAutoCreated
+    #region IsAutoCreated Property
 
     public bool IsAutoCreated
     {
@@ -392,7 +392,7 @@ namespace Xceed.Wpf.DataGrid
       private set;
     }
 
-    #endregion IsAutoCreated
+    #endregion IsAutoCreated Property
 
     #region PUBLIC METHODS
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyBase.cs
index ed946600..1637c45f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyBase.cs
@@ -15,15 +15,12 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.ComponentModel;
 using System.Collections;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Globalization;
-using Xceed.Wpf.DataGrid.Converters;
 using System.Windows.Data;
+using Xceed.Wpf.DataGrid.Converters;
 using Xceed.Wpf.DataGrid.FilterCriteria;
 
 namespace Xceed.Wpf.DataGrid
@@ -31,22 +28,25 @@ namespace Xceed.Wpf.DataGrid
   public abstract partial class DataGridItemPropertyBase : INotifyPropertyChanged, ICloneable
   {
 
-    #region CONSTRUCTORS
-
     protected DataGridItemPropertyBase()
     {
+      this.Browsable = true;
     }
 
     protected DataGridItemPropertyBase( DataGridItemPropertyBase template )
+      : this()
     {
       m_name = template.m_name;
       m_dataType = template.m_dataType;
       m_title = template.m_title;
-      m_readOnly = template.m_readOnly;
-      m_overrideReadOnlyForInsertion = template.m_overrideReadOnlyForInsertion;
-      m_isASubRelationship = template.m_isASubRelationship;
-      m_browsable = template.m_browsable;
-      m_calculateDistinctValues = template.m_calculateDistinctValues;
+      m_synonym = template.m_synonym;
+      m_flags[ DataGridItemPropertyBaseFlags.IsReadOnly ] = template.m_flags[ DataGridItemPropertyBaseFlags.IsReadOnly ];
+      m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertionSet ] = template.m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertionSet ];
+      m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertion ] = template.m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertion ];
+      m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationshipSet ] = template.m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationshipSet ];
+      m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationship ] = template.m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationship ];
+      m_flags[ DataGridItemPropertyBaseFlags.IsBrowsable ] = template.m_flags[ DataGridItemPropertyBaseFlags.IsBrowsable ];
+      m_flags[ DataGridItemPropertyBaseFlags.CalculateDistinctValues ] = template.m_flags[ DataGridItemPropertyBaseFlags.CalculateDistinctValues ];
       m_converter = template.m_converter;
       m_converterCulture = template.m_converterCulture;
       m_converterParameter = template.m_converterParameter;
@@ -86,20 +86,18 @@ namespace Xceed.Wpf.DataGrid
 
       if( isReadOnly.HasValue )
       {
-        m_readOnly = isReadOnly.Value;
+        this.SetIsReadOnly( isReadOnly.Value );
       }
 
-      m_overrideReadOnlyForInsertion = overrideReadOnlyForInsertion;
+      this.SetOverrideReadOnlyForInsertion( overrideReadOnlyForInsertion );
       m_dataType = dataType;
 
       if( isASubRelationship != null )
       {
-        m_isASubRelationship = isASubRelationship;
+        this.SetIsASubRelationship( isASubRelationship );
       }
     }
 
-    #endregion CONSTRUCTORS
-
     #region Name Property
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly" )]
@@ -114,7 +112,7 @@ namespace Xceed.Wpf.DataGrid
         if( string.IsNullOrEmpty( value ) )
           throw new ArgumentException( "Name is null (Nothing in Visual Basic) or empty.", "Name" );
 
-        if( m_initialized )
+        if( this.Initialized )
           throw new InvalidOperationException( "An attempt was made to change the name of a property already added to a containing collection." );
 
         m_name = value;
@@ -136,7 +134,7 @@ namespace Xceed.Wpf.DataGrid
       }
       set
       {
-        if( m_initialized )
+        if( this.Initialized )
           throw new InvalidOperationException( "An attempt was made to change the DataType of a property already added to a containing collection." );
 
         this.SetDataType( value );
@@ -161,11 +159,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_readOnly;
+        return m_flags[ DataGridItemPropertyBaseFlags.IsReadOnly ];
       }
       set
       {
-        if( m_initialized )
+        if( this.Initialized )
           throw new InvalidOperationException( "An attempt was made to change the IsReadOnly property of a DataGridItemProperty already added to a containing collection." );
 
         this.SetIsReadOnly( value );
@@ -174,11 +172,9 @@ namespace Xceed.Wpf.DataGrid
 
     internal void SetIsReadOnly( bool isReadOnly )
     {
-      m_readOnly = isReadOnly;
+      m_flags[ DataGridItemPropertyBaseFlags.IsReadOnly ] = isReadOnly;
     }
 
-    private bool m_readOnly;
-
     #endregion IsReadOnly Property
 
     #region OverrideReadOnlyForInsertion Property
@@ -187,11 +183,14 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_overrideReadOnlyForInsertion;
+        if( !m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertionSet ] )
+          return null;
+
+        return m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertion ];
       }
       set
       {
-        if( m_initialized )
+        if( this.Initialized )
           throw new InvalidOperationException( "An attempt was made to change the OverrideReadOnlyForInsertion property of a DataGridItemProperty already added to a containing collection." );
 
         this.SetOverrideReadOnlyForInsertion( value );
@@ -200,11 +199,18 @@ namespace Xceed.Wpf.DataGrid
 
     internal void SetOverrideReadOnlyForInsertion( Nullable<bool> overrideReadOnlyForInsertion )
     {
-      m_overrideReadOnlyForInsertion = overrideReadOnlyForInsertion;
+      if( overrideReadOnlyForInsertion.HasValue )
+      {
+        m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertion ] = overrideReadOnlyForInsertion.Value;
+        m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertionSet ] = true;
+      }
+      else
+      {
+        m_flags[ DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertionSet
+               | DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertion ] = false;
+      }
     }
 
-    private Nullable<bool> m_overrideReadOnlyForInsertion;
-
     #endregion OverrideReadOnlyForInsertion Property
 
     #region IsASubRelationship Property
@@ -213,24 +219,37 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        if( m_isASubRelationship == null )
-        {
-          if( m_dataType == null )
-            return false;
+        if( m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationshipSet ] )
+          return m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationship ];
 
-          bool isASubRelationship = ItemsSourceHelper.IsASubRelationship( m_dataType );
+        if( m_dataType == null )
+          return false;
 
-          if( m_initialized )
-            m_isASubRelationship = isASubRelationship;
+        bool isASubRelationship = ItemsSourceHelper.IsASubRelationship( m_dataType );
 
-          return isASubRelationship;
+        if( this.Initialized )
+        {
+          m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationship ] = isASubRelationship;
+          m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationshipSet ] = true;
         }
 
-        return m_isASubRelationship.Value;
+        return isASubRelationship;
       }
     }
 
-    private Nullable<bool> m_isASubRelationship;
+    private void SetIsASubRelationship( Nullable<bool> isASubRelationship )
+    {
+      if( isASubRelationship.HasValue )
+      {
+        m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationship ] = isASubRelationship.Value;
+        m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationshipSet ] = true;
+      }
+      else
+      {
+        m_flags[ DataGridItemPropertyBaseFlags.IsASubRelationshipSet
+               | DataGridItemPropertyBaseFlags.IsASubRelationship ] = false;
+      }
+    }
 
     #endregion IsASubRelationship Property
 
@@ -256,6 +275,33 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion Title Property
 
+    #region Synonym Property
+
+    [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly" )]
+    public string Synonym
+    {
+      get
+      {
+        return m_synonym;
+      }
+      set
+      {
+        if( this.Initialized )
+          throw new InvalidOperationException( "An attempt was made to change the Synonym of a property already added to a containing collection." );
+
+        this.SetSynonym( value );
+      }
+    }
+
+    internal void SetSynonym( string value )
+    {
+      m_synonym = value;
+    }
+
+    private string m_synonym;
+
+    #endregion Synonym Property
+
     #region SortComparer Property
 
     public IComparer SortComparer
@@ -284,7 +330,7 @@ namespace Xceed.Wpf.DataGrid
       }
       set
       {
-        if( m_initialized )
+        if( this.Initialized )
           throw new InvalidOperationException( "An attempt was made to change the Converter property of a DataGridItemProperty already added to a containing collection." );
 
         m_converter = value;
@@ -293,7 +339,7 @@ namespace Xceed.Wpf.DataGrid
 
     internal IValueConverter GetBindingConverter( object sourceItem )
     {
-      if( !m_initialized )
+      if( !this.Initialized )
         throw new InvalidOperationException( "An attempt was made to apply a binding to a DataGridItemProperty that has not be added to the ItemProperties collection." );
 
       if( m_bindingConverter == null )
@@ -328,7 +374,7 @@ namespace Xceed.Wpf.DataGrid
       }
       set
       {
-        if( m_initialized )
+        if( this.Initialized )
           throw new InvalidOperationException( "An attempt was made to change the ConverterCulture property of a DataGridItemProperty already added to a containing collection." );
 
         m_converterCulture = value;
@@ -349,7 +395,7 @@ namespace Xceed.Wpf.DataGrid
       }
       set
       {
-        if( m_initialized )
+        if( this.Initialized )
           throw new InvalidOperationException( "An attempt was made to change the ConverterParameter property of a DataGridItemProperty already added to a containing collection." );
 
         m_converterParameter = value;
@@ -409,18 +455,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion FilterCriterion Property
 
-    #region ValueChanged Event
-
-    private void OnValueChanged( ValueChangedEventArgs e )
-    {
-      if( this.ValueChanged != null )
-        this.ValueChanged( this, e );
-    }
-
-    internal event EventHandler<ValueChangedEventArgs> ValueChanged;
-
-    #endregion ComponentValueChanged Event
-
     #region CalculateDistinctValues Property
 
     public bool CalculateDistinctValues
@@ -428,20 +462,20 @@ namespace Xceed.Wpf.DataGrid
       get
       {
         // Always activate DistinctValues if not explicitly specified
-        if( !m_isCalculateDistinctValuesInitialized )
+        if( !this.IsCalculateDistinctValuesInitialized )
           return true;
 
-        return m_calculateDistinctValues;
+        return m_flags[ DataGridItemPropertyBaseFlags.CalculateDistinctValues ];
       }
       set
       {
-        if( m_calculateDistinctValues != value )
+        if( value != m_flags[ DataGridItemPropertyBaseFlags.CalculateDistinctValues ] )
         {
-          m_calculateDistinctValues = value;
+          m_flags[ DataGridItemPropertyBaseFlags.CalculateDistinctValues ] = value;
           this.OnPropertyChanged( "CalculateDistinctValues" );
         }
 
-        m_isCalculateDistinctValuesInitialized = true;
+        this.IsCalculateDistinctValuesInitialized = true;
       }
     }
 
@@ -449,17 +483,14 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_isCalculateDistinctValuesInitialized;
+        return m_flags[ DataGridItemPropertyBaseFlags.IsCalculateDistinctValuesInitialized ];
       }
       set
       {
-        m_isCalculateDistinctValuesInitialized = value;
+        m_flags[ DataGridItemPropertyBaseFlags.IsCalculateDistinctValuesInitialized ] = value;
       }
     }
 
-    private bool m_calculateDistinctValues; // = null; 
-    private bool m_isCalculateDistinctValuesInitialized;
-
     #endregion CalculateDistinctValues Property
 
     #region MaxDistinctValues Property
@@ -484,7 +515,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion MaxDistinctValues Property
 
-    #region DistinctValuesSortComparer
+    #region DistinctValuesSortComparer Property
 
     public IComparer DistinctValuesSortComparer
     {
@@ -494,7 +525,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region DistinctValuesEqualityComparer
+    #region DistinctValuesEqualityComparer Property
 
     public IEqualityComparer DistinctValuesEqualityComparer
     {
@@ -510,18 +541,16 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_initialized;
+        return m_flags[ DataGridItemPropertyBaseFlags.IsInitialized ];
       }
       set
       {
         Debug.Assert( value );
 
-        m_initialized = value;
+        m_flags[ DataGridItemPropertyBaseFlags.IsInitialized ] = value;
       }
     }
 
-    private bool m_initialized;
-
     #endregion Initialized Property
 
     #region Browsable Property
@@ -532,48 +561,16 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_browsable;
+        return m_flags[ DataGridItemPropertyBaseFlags.IsBrowsable ];
       }
       set
       {
-        m_browsable = value;
+        m_flags[ DataGridItemPropertyBaseFlags.IsBrowsable ] = value;
       }
     }
 
-    private bool m_browsable = true;
-
     #endregion Browsable Property
 
-    #region DistinctValueSelector Event
-
-    public event EventHandler<QueryDistinctValueEventArgs> QueryDistinctValue
-    {
-      add
-      {
-        m_queryDistinctValue = ( EventHandler<QueryDistinctValueEventArgs> )Delegate.Combine( m_queryDistinctValue, value );
-      }
-      remove
-      {
-        m_queryDistinctValue = ( EventHandler<QueryDistinctValueEventArgs> )Delegate.Remove( m_queryDistinctValue, value );
-      }
-    }
-
-    private EventHandler<QueryDistinctValueEventArgs> m_queryDistinctValue;
-
-    internal object GetDistinctValueFromItem( object dataSourceValue )
-    {
-      if( m_queryDistinctValue == null )
-        return dataSourceValue;
-
-      QueryDistinctValueEventArgs args = new QueryDistinctValueEventArgs( dataSourceValue );
-
-      m_queryDistinctValue( this, args );
-
-      return args.DistinctValue;
-    }
-
-    #endregion
-
     #region ForeignKeyDescription Property
 
     public DataGridForeignKeyDescription ForeignKeyDescription
@@ -614,6 +611,8 @@ namespace Xceed.Wpf.DataGrid
         if( m_groupSortStatResultPropertyName != value )
         {
           m_groupSortStatResultPropertyName = value;
+
+          this.OnPropertyChanged( "GroupSortStatResultPropertyName" );
         }
       }
     }
@@ -632,7 +631,49 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion GroupSortStatResultComparer Property
 
-    #region PUBLIC METHODS
+    #region ValueChanged Event
+
+    private void OnValueChanged( ValueChangedEventArgs e )
+    {
+      if( this.ValueChanged != null )
+      {
+        this.ValueChanged( this, e );
+      }
+    }
+
+    internal event EventHandler<ValueChangedEventArgs> ValueChanged;
+
+    #endregion ComponentValueChanged Event
+
+    #region DistinctValueSelector Event
+
+    public event EventHandler<QueryDistinctValueEventArgs> QueryDistinctValue
+    {
+      add
+      {
+        m_queryDistinctValue = ( EventHandler<QueryDistinctValueEventArgs> )Delegate.Combine( m_queryDistinctValue, value );
+      }
+      remove
+      {
+        m_queryDistinctValue = ( EventHandler<QueryDistinctValueEventArgs> )Delegate.Remove( m_queryDistinctValue, value );
+      }
+    }
+
+    private EventHandler<QueryDistinctValueEventArgs> m_queryDistinctValue;
+
+    internal object GetDistinctValueFromItem( object dataSourceValue )
+    {
+      if( m_queryDistinctValue == null )
+        return dataSourceValue;
+
+      QueryDistinctValueEventArgs args = new QueryDistinctValueEventArgs( dataSourceValue );
+
+      m_queryDistinctValue( this, args );
+
+      return args.DistinctValue;
+    }
+
+    #endregion
 
     public object GetValue( object component )
     {
@@ -661,11 +702,11 @@ namespace Xceed.Wpf.DataGrid
       UnboundDataItem unboundDataItem = component as UnboundDataItem;
 
       if( unboundDataItem != null )
+      {
         component = unboundDataItem.DataItem;
+      }
 
-      bool isReadOnly = ( this.OverrideReadOnlyForInsertion.HasValue && this.OverrideReadOnlyForInsertion.Value )
-        ? false
-        : this.IsReadOnly;
+      bool isReadOnly = ( this.OverrideReadOnlyForInsertion.HasValue && this.OverrideReadOnlyForInsertion.Value ) ? false : this.IsReadOnly;
 
       if( isReadOnly )
         throw new InvalidOperationException( "An attempt was made to set a read-only property." );
@@ -699,10 +740,6 @@ namespace Xceed.Wpf.DataGrid
     }
 #endif
 
-    #endregion PUBLIC METHODS
-
-    #region PROTECTED METHODS
-
     protected abstract object GetValueCore( object component );
 
     protected virtual void SetValueCore( object component, object value )
@@ -710,10 +747,6 @@ namespace Xceed.Wpf.DataGrid
       this.OnValueChanged( new ValueChangedEventArgs( component ) );
     }
 
-    #endregion PROTECTED METHODS
-
-    #region INTERNAL METHODS
-
     internal PropertyDescriptorFromItemPropertyBase GetPropertyDescriptorForBinding()
     {
       if( m_propertyDescriptorFromItemProperty == null )
@@ -731,8 +764,6 @@ namespace Xceed.Wpf.DataGrid
     {
     }
 
-    #endregion INTERNAL METHODS
-
     #region INotifyPropertyChanged Members
 
     public event PropertyChangedEventHandler PropertyChanged;
@@ -745,11 +776,8 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region PRIVATE FIELDS
-
     private PropertyDescriptorFromItemPropertyBase m_propertyDescriptorFromItemProperty;
-
-    #endregion PRIVATE FIELDS
+    private BitFlags m_flags;
 
     internal class ValueChangedEventArgs : EventArgs
     {
@@ -764,5 +792,67 @@ namespace Xceed.Wpf.DataGrid
         private set;
       }
     }
+
+    private struct BitFlags
+    {
+      internal bool this[ DataGridItemPropertyBaseFlags flag ]
+      {
+        get
+        {
+          return ( ( m_data & flag ) == flag );
+        }
+        set
+        {
+          this.CheckIfIsDefined( flag );
+
+          if( value )
+          {
+            m_data |= flag;
+          }
+          else
+          {
+            m_data &= ~flag;
+          }
+        }
+      }
+
+      [Conditional( "DEBUG" )]
+      private void CheckIfIsDefined( DataGridItemPropertyBaseFlags value )
+      {
+        if( Enum.IsDefined( typeof( DataGridItemPropertyBaseFlags ), value ) )
+          return;
+
+        int flags = Convert.ToInt32( value );
+        foreach( var flag in Enum.GetValues( typeof( DataGridItemPropertyBaseFlags ) ) )
+        {
+          int flagValue = Convert.ToInt32( flag );
+          if( ( flags & flagValue ) == flagValue )
+          {
+            flags &= ~flagValue;
+
+            if( flags == 0 )
+              break;
+          }
+        }
+
+        Debug.Assert( flags == 0 );
+      }
+
+      private DataGridItemPropertyBaseFlags m_data;
+    }
+
+    [Flags]
+    private enum DataGridItemPropertyBaseFlags : ushort
+    {
+      IsReadOnly = 0x0001,
+      IsOverrideReadOnlyForInsertionSet = 0x0002,
+      IsOverrideReadOnlyForInsertion = 0x0004,
+      IsASubRelationshipSet = 0x0008,
+      IsASubRelationship = 0x0010,
+      CalculateDistinctValues = 0x0020,
+      IsCalculateDistinctValuesInitialized = 0x0040,
+      IsInitialized = 0x0080,
+      IsBrowsable = 0x0100,
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyCollection.cs
index 06e6de66..cf3c2069 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyCollection.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridItemPropertyCollection.cs
@@ -96,6 +96,7 @@ namespace Xceed.Wpf.DataGrid
 
         oldItem.FilterCriterionChanged -= new EventHandler( DataGridItemProperty_FilterCriterionChanged );
         oldItem.ValueChanged -= new EventHandler<DataGridItemPropertyBase.ValueChangedEventArgs>( DataGridItemProperty_ValueChanged );
+        oldItem.PropertyChanged -= new PropertyChangedEventHandler( OnDataGridItemProperty_PropertyChanged );
       }
     }
 
@@ -118,6 +119,7 @@ namespace Xceed.Wpf.DataGrid
       }
 
       item.ValueChanged += new EventHandler<DataGridItemPropertyBase.ValueChangedEventArgs>( DataGridItemProperty_ValueChanged );
+      item.PropertyChanged += new PropertyChangedEventHandler( OnDataGridItemProperty_PropertyChanged );
       item.SetUnspecifiedPropertiesValues( this );
 
       try
@@ -127,6 +129,7 @@ namespace Xceed.Wpf.DataGrid
       catch
       {
         item.ValueChanged -= new EventHandler<DataGridItemPropertyBase.ValueChangedEventArgs>( DataGridItemProperty_ValueChanged );
+        item.PropertyChanged -= new PropertyChangedEventHandler( OnDataGridItemProperty_PropertyChanged );
         throw;
       }
 
@@ -144,6 +147,7 @@ namespace Xceed.Wpf.DataGrid
 
         oldItem.FilterCriterionChanged -= new EventHandler( DataGridItemProperty_FilterCriterionChanged );
         oldItem.ValueChanged -= new EventHandler<DataGridItemPropertyBase.ValueChangedEventArgs>( DataGridItemProperty_ValueChanged );
+        oldItem.PropertyChanged -= new PropertyChangedEventHandler( OnDataGridItemProperty_PropertyChanged );
       }
 
       item.FilterCriterionChanged += new EventHandler( DataGridItemProperty_FilterCriterionChanged );
@@ -165,6 +169,7 @@ namespace Xceed.Wpf.DataGrid
       }
 
       item.ValueChanged += new EventHandler<DataGridItemPropertyBase.ValueChangedEventArgs>( DataGridItemProperty_ValueChanged );
+      item.PropertyChanged += new PropertyChangedEventHandler( OnDataGridItemProperty_PropertyChanged );
       item.SetUnspecifiedPropertiesValues( this );
       item.Initialized = true;
 
@@ -180,6 +185,7 @@ namespace Xceed.Wpf.DataGrid
       catch
       {
         item.ValueChanged -= new EventHandler<DataGridItemPropertyBase.ValueChangedEventArgs>( DataGridItemProperty_ValueChanged );
+        item.PropertyChanged -= new PropertyChangedEventHandler( OnDataGridItemProperty_PropertyChanged );
         item.Initialized = false;
 
         if( item is DataGridUnboundItemProperty )
@@ -255,6 +261,7 @@ namespace Xceed.Wpf.DataGrid
 
         item.FilterCriterionChanged -= this.DataGridItemProperty_FilterCriterionChanged;
         item.ValueChanged -= this.DataGridItemProperty_ValueChanged;
+        item.PropertyChanged -= new PropertyChangedEventHandler( OnDataGridItemProperty_PropertyChanged );
       }
     }
 
@@ -308,7 +315,9 @@ namespace Xceed.Wpf.DataGrid
     internal void SuspendUnboundItemPropertyChanged( object component )
     {
       if( m_unboundItemPropertyChangedSuspended == null )
+      {
         m_unboundItemPropertyChangedSuspended = new Hashtable( 1 );
+      }
 
       m_unboundItemPropertyChangedSuspended[ component ] = DBNull.Value;
     }
@@ -324,7 +333,9 @@ namespace Xceed.Wpf.DataGrid
       m_unboundItemPropertyChangedSuspended.Remove( component );
 
       if( m_unboundItemPropertyChangedSuspended.Count == 0 )
+      {
         m_unboundItemPropertyChangedSuspended = null;
+      }
 
       this.RefreshUnboundItemProperty( component );
     }
@@ -405,6 +416,25 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    #region ItemPropertyGroupSortStatNameChanged Event
+
+    internal event EventHandler ItemPropertyGroupSortStatNameChanged;
+
+    private void OnDataGridItemProperty_PropertyChanged( object sender, PropertyChangedEventArgs e )
+    {
+      if( e.PropertyName != "GroupSortStatResultPropertyName" )
+        return;
+
+      var handler = this.ItemPropertyGroupSortStatNameChanged;
+
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, e );
+    }
+
+    #endregion
+
     private List<DataGridItemPropertyBase> m_defaultItemProperties;
     private Type m_itemType;
     private int m_unboundItemPropertyCount;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridLINQPageManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridLINQPageManager.cs
index 69d9a07a..dd240e68 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridLINQPageManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridLINQPageManager.cs
@@ -24,8 +24,6 @@ namespace Xceed.Wpf.DataGrid
 {
   internal class DataGridLINQPageManager : DataGridPageManagerBase
   {
-    #region CONSTRUCTORS
-
     public DataGridLINQPageManager( DataGridVirtualizingQueryableCollectionView collectionView, object syncRoot, bool supportsPrimaryKeyOptimizations )
       : base( collectionView )
     {
@@ -33,9 +31,11 @@ namespace Xceed.Wpf.DataGrid
       m_syncRoot = syncRoot;
     }
 
-    #endregion CONSTRUCTORS
-
-    #region DATA VIRTUALIZATION
+    protected override void DisposeCore()
+    {
+      m_syncRoot = null;
+      base.DisposeCore();
+    }
 
     protected override int OnQueryItemCountCore( VirtualList virtualList )
     {
@@ -80,6 +80,19 @@ namespace Xceed.Wpf.DataGrid
       System.Threading.ThreadPool.QueueUserWorkItem( new System.Threading.WaitCallback( this.AsyncGatherItems ), new object[] { queryInfo, queryableToUse, queryableIsReversed } );
     }
 
+    protected internal override void OnQueryItemsCompleted( VirtualPage page, AsyncQueryInfo queryInfo, object[] fetchedItems )
+    {
+      DataGridVirtualizingQueryableCollectionView collectionView = this.CollectionView as DataGridVirtualizingQueryableCollectionView;
+
+      // The VirtualPageManager was Disposed
+      if( collectionView == null )
+        return;
+
+      using( collectionView.DeferRefresh() )
+      {
+        base.OnQueryItemsCompleted( page, queryInfo, fetchedItems );
+      }
+    }
 
     private void AsyncGatherItems( object workItem )
     {
@@ -91,8 +104,8 @@ namespace Xceed.Wpf.DataGrid
         return;
 
       IQueryable queryable = ( IQueryable )parameters[ 1 ];
-
-      object[] items = new object[ queryInfo.RequestedItemCount ];
+      int requestedItemCount = queryInfo.RequestedItemCount;
+      object[] items = new object[ requestedItemCount ];
 
       System.Collections.IEnumerator enumerator;
 
@@ -104,22 +117,23 @@ namespace Xceed.Wpf.DataGrid
 
         try
         {
-          Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization,"Beginning Provider Execute for page at start index: " + queryInfo.StartIndex.ToString() );
+          Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization, "Beginning Provider Execute for page at start index: " + queryInfo.StartIndex.ToString() );
 
           enumerator = queryable.GetEnumerator();
 
-          Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization,"Ended Provider Execute for page at start index: " + queryInfo.StartIndex.ToString() );
+          Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization, "Ended Provider Execute for page at start index: " + queryInfo.StartIndex.ToString() );
 
           int i = 0;
 
-          while( enumerator.MoveNext() )
+          while( enumerator.MoveNext() && ( i < requestedItemCount ) )
           {
             object current = enumerator.Current;
 
             if( current != null )
+            {
               items[ i ] = enumerator.Current;
-
-            i++;
+              i++;
+            }
           }
         }
         catch( Exception exception )
@@ -131,6 +145,18 @@ namespace Xceed.Wpf.DataGrid
         }
       }
 
+      items = items.Where( item => item != null ).ToArray();
+
+      try
+      {
+        if( items.Count() != requestedItemCount )
+          throw new InvalidOperationException( "TODODOC : The number of non-null items return by the source must be equal to the provided item count" );
+      }
+      catch
+      {
+        //go silently here, in case the next sequance give a valid result.  At the same time, if it does not, the dev has information when debugging.
+      }
+
       bool queryableWasReversed = ( bool )parameters[ 2 ];
 
       if( queryableWasReversed )
@@ -139,33 +165,7 @@ namespace Xceed.Wpf.DataGrid
       queryInfo.EndQuery( items );
     }
 
-    protected internal override void OnQueryItemsCompleted( VirtualPage page, AsyncQueryInfo queryInfo, object[] fetchedItems )
-    {
-      DataGridVirtualizingQueryableCollectionView collectionView = this.CollectionView as DataGridVirtualizingQueryableCollectionView;
-
-      // The VirtualPageManager was Disposed
-      if( collectionView == null )
-        return;
-
-      using( collectionView.DeferRefresh() )
-      {
-        base.OnQueryItemsCompleted( page, queryInfo, fetchedItems );
-      }
-    }
-
-    protected override void DisposeCore()
-    {
-      m_syncRoot = null;
-      base.DisposeCore();
-    }
-
-    #endregion DATA VIRTUALIZATION
-
-    #region PRIVATE FIELDS
-
     private object m_syncRoot;
     private bool m_supportsPrimaryKeyOptimizations;
-
-    #endregion PRIVATE FIELDS
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridSortDescriptionCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridSortDescriptionCollection.cs
index 0e06cb10..c9b4ec2f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridSortDescriptionCollection.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridSortDescriptionCollection.cs
@@ -95,7 +95,6 @@ namespace Xceed.Wpf.DataGrid
         m_parentCollection.m_deferResortCount++;
       }
 
-
       #region IDisposable Members
 
       public void Dispose()
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridUnboundItemProperty.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridUnboundItemProperty.cs
index a570ef29..38942c0c 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridUnboundItemProperty.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridUnboundItemProperty.cs
@@ -23,8 +23,6 @@ namespace Xceed.Wpf.DataGrid
 {
   public class DataGridUnboundItemProperty : DataGridItemPropertyBase
   {
-    #region CONSTRUTORS
-
     public DataGridUnboundItemProperty()
     {
     }
@@ -69,10 +67,6 @@ namespace Xceed.Wpf.DataGrid
       this.CommittingValue += template.CommittingValue;
     }
 
-    #endregion CONSTRUTORS
-
-    #region PUBLIC METHODS
-
     public override object Clone()
     {
       Type type = this.GetType();
@@ -83,17 +77,9 @@ namespace Xceed.Wpf.DataGrid
       return base.Clone();
     }
 
-    #endregion PUBLIC METHODS
-
-    #region PUBLIC EVENTS
-
     public event EventHandler<DataGridItemPropertyQueryValueEventArgs> QueryValue;
     public event EventHandler<DataGridItemPropertyCommittingValueEventArgs> CommittingValue;
 
-    #endregion PUBLIC EVENTS
-
-    #region PROTECTED METHODS
-
     protected override object GetValueCore( object component )
     {
       if( this.QueryValue != null )
@@ -116,10 +102,6 @@ namespace Xceed.Wpf.DataGrid
       base.SetValueCore( component, value );
     }
 
-    #endregion PROTECTED METHODS
-
-    #region INTERNAL METHODS
-
     internal void Refresh( object component )
     {
       PropertyDescriptorFromItemPropertyBase propertyDescriptor = this.GetPropertyDescriptorForBinding();
@@ -147,7 +129,5 @@ namespace Xceed.Wpf.DataGrid
         this.OverrideReadOnlyForInsertion = false;
       }
     }
-
-    #endregion INTERNAL METHODS
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridVirtualizingCollectionViewBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridVirtualizingCollectionViewBase.cs
index bad967af..33d4d67e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridVirtualizingCollectionViewBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DataGridVirtualizingCollectionViewBase.cs
@@ -15,20 +15,10 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows.Data;
-using System.Globalization;
-using System.ComponentModel;
-using System.Collections.ObjectModel;
 using System.Collections;
 using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Diagnostics;
-using System.Data;
-using Xceed.Utils.Collections;
-using Xceed.Utils.Data;
-using System.Windows.Threading;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -47,7 +37,6 @@ namespace Xceed.Wpf.DataGrid
     internal DataGridVirtualizingCollectionViewBase( object sourceModel, Type itemType, bool autoCreateItemProperties, int pageSize, int maxRealizedItemCount )
       : base( sourceModel, null, itemType, autoCreateItemProperties, false, false )
     {
-
       if( itemType == null )
         itemType = typeof( object );
 
@@ -68,7 +57,7 @@ namespace Xceed.Wpf.DataGrid
     internal override DataGridCollectionViewBase CreateDetailDataGridCollectionViewBase(
       IEnumerable detailDataSource,
       DataGridDetailDescription parentDetailDescription,
-      DataGridCollectionViewBase rootDataGridCollectionViewBase )
+      DataGridCollectionViewBase parentDataGridCollectionViewBase )
     {
       throw new NotImplementedException();
     }
@@ -82,7 +71,6 @@ namespace Xceed.Wpf.DataGrid
       get
       {
         bool canGroup = true;
-
         return canGroup;
       }
     }
@@ -368,7 +356,9 @@ namespace Xceed.Wpf.DataGrid
           m_maxRealizedItemCount = value;
 
           if( value < this.PageSize )
+          {
             value = this.PageSize;
+          }
 
           // Cannot modify this PageManager property.  Must Refresh which will recreate the CollectionViewGroupRoot
           // and the DataGridVirtualPageManagerBase taking the new pageSize into account.
@@ -925,7 +915,11 @@ namespace Xceed.Wpf.DataGrid
         }
 
         if( sendResetNotification )
+        {
           this.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+        }
+
+        this.OnPropertyChanged( new PropertyChangedEventArgs( "Groups" ) );
       }
     }
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperation.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperation.cs
index 5576ef68..f6694682 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperation.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperation.cs
@@ -23,29 +23,34 @@ namespace Xceed.Wpf.DataGrid
 {
   internal class DeferredOperation
   {
-    #region CONSTRUCTORS
+    internal static DeferredOperation RefreshDistinctValuesOperation = new DeferredOperation( DeferredOperationAction.RefreshDistincValues, false );
 
-    public DeferredOperation(
-      DeferredOperationAction action,
-      bool filteredItemsChanged )
+    internal static DeferredOperation RefreshDistinctValuesOperationWithFilteredItemsChanged = new DeferredOperation( DeferredOperationAction.RefreshDistincValues, true );
+
+    public DeferredOperation( DeferredOperationAction action, bool filteredItemsChanged )
       : this( action, -1, -1, null )
     {
       m_filteredItemsChanged = filteredItemsChanged;
     }
 
-    public DeferredOperation(
-      DeferredOperationAction action,
-      int startingIndex,
-      IList items )
+    public DeferredOperation( DeferredOperationAction action, object dataItem )
+    {
+      m_action = action;
+      m_dataItem = dataItem;
+    }
+
+    public DeferredOperation( DeferredOperationAction action, IList items )
+    {
+      m_action = action;
+      m_newItems = items;
+    }
+
+    public DeferredOperation( DeferredOperationAction action, int startingIndex, IList items )
       : this( action, -1, startingIndex, items )
     {
     }
 
-    public DeferredOperation(
-      DeferredOperationAction action,
-      int newSourceItemCount,
-      int startingIndex,
-      IList items )
+    public DeferredOperation( DeferredOperationAction action, int newSourceItemCount, int startingIndex, IList items )
     {
       // newSourceItemCount is for when we are adding item in a IBindingList
       // It is use to detect we 2 add are in fact only one, bcause the second one is just for confirming the first one.
@@ -82,13 +87,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public DeferredOperation(
-      DeferredOperationAction action,
-      int newSourceItemCount,
-      int newStartingIndex,
-      IList newItems,
-      int oldStartingIndex,
-      IList oldItems )
+    public DeferredOperation( DeferredOperationAction action, int newSourceItemCount, int newStartingIndex, IList newItems, int oldStartingIndex, IList oldItems )
     {
       // newSourceItemCount is for when we are adding item in a IBindingList
       // It is use to detect that 2 add are in fact only one, because the second one is just for confirming the first one.
@@ -100,8 +99,6 @@ namespace Xceed.Wpf.DataGrid
       m_oldStartingIndex = oldStartingIndex;
     }
 
-    #endregion CONSTRUCTORS
-
     #region Action Property
 
     public DeferredOperationAction Action
@@ -186,6 +183,20 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion OldItems Property
 
+    #region DataItem Property
+
+    public object DataItem
+    {
+      get
+      {
+        return m_dataItem;
+      }
+    }
+
+    private object m_dataItem;
+
+    #endregion
+
     #region FilteredItemsChanged Property
 
     public bool FilteredItemsChanged
@@ -210,7 +221,9 @@ namespace Xceed.Wpf.DataGrid
       Refresh = 5,
       Resort = 6,
       Regroup = 7,
-      RefreshDistincValues = 8
+      RefreshDistincValues = 8,
+      ResetItem = 9,
+      RefreshUnboundItemProperties = 10
     }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperationManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperationManager.cs
index dae8b5c2..5acc863e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperationManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DeferredOperationManager.cs
@@ -16,27 +16,31 @@
 
 using System;
 using System.Collections.Generic;
-using System.Text;
-using System.Collections;
 using System.Collections.Specialized;
-using System.Windows.Threading;
 using System.Diagnostics;
-using System.Collections.ObjectModel;
+using System.Windows.Threading;
 
 namespace Xceed.Wpf.DataGrid
 {
-
-  internal class DeferredOperationManager
+  internal sealed class DeferredOperationManager
   {
-    public DeferredOperationManager(
-      DataGridCollectionViewBase collectionViewToUpdate,
-      Dispatcher dispatcher,
-      bool postPendingRefreshWithoutDispatching )
+    #region Static Fields
+
+    private static readonly TimeSpan MaxProcessDuration = TimeSpan.FromMilliseconds( 100d );
+    private static readonly TimeSpan MaxQueueDuration = TimeSpan.FromMilliseconds( 20d );
+
+    #endregion
+
+    internal DeferredOperationManager( DataGridCollectionViewBase collectionView, Dispatcher dispatcher, bool postPendingRefreshWithoutDispatching )
     {
-      m_collectionViewToUpdate = collectionViewToUpdate;
+      m_collectionView = collectionView;
+      m_deferredOperations = new List<DeferredOperation>( 1000 );
+      m_invalidatedGroups = new HashSet<DataGridCollectionViewGroup>();
 
       if( postPendingRefreshWithoutDispatching )
+      {
         this.Add( new DeferredOperation( DeferredOperation.DeferredOperationAction.Refresh, -1, null ) );
+      }
 
       m_dispatcher = dispatcher;
     }
@@ -49,7 +53,7 @@ namespace Xceed.Wpf.DataGrid
       {
         lock( this )
         {
-          return ( m_pendingFlags.Data != 0 ) || ( m_deferredOperations != null );
+          return ( m_pendingFlags.Data != 0 ) || ( !m_isProcessingOperations && m_deferredOperations.Count > 0 );
         }
       }
     }
@@ -136,6 +140,32 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region DeferProcessOfInvalidatedGroupStats Property
+
+    internal bool DeferProcessOfInvalidatedGroupStats
+    {
+      private get
+      {
+        return m_deferProcessOfInvalidatedGroupStats;
+      }
+      set
+      {
+        lock( this )
+        {
+          //Make sure that stats calculation that have been defer are processed before defering again!
+          if( value && m_deferredOperationsToProcess > 0 )
+          {
+            m_forceProcessOfInvalidatedGroupStats = true;
+          }
+          m_deferProcessOfInvalidatedGroupStats = value;
+        }
+      }
+    }
+
+    private bool m_deferProcessOfInvalidatedGroupStats;
+
+    #endregion
+
     public void ClearInvalidatedGroups()
     {
       lock( this )
@@ -144,9 +174,11 @@ namespace Xceed.Wpf.DataGrid
         {
           m_dispatcherOperation.Abort();
           m_dispatcherOperation = null;
+          m_dispatcherOperationStartTime = DateTime.MinValue;
+          m_hasNewOperationsSinceStartTime = false;
         }
 
-        m_invalidatedGroups = null;
+        m_invalidatedGroups.Clear();
       }
     }
 
@@ -154,22 +186,21 @@ namespace Xceed.Wpf.DataGrid
     {
       lock( this )
       {
-        if( ( m_dispatcherOperation != null ) && ( m_invalidatedGroups == null ) )
+        if( ( m_dispatcherOperation != null ) && ( m_invalidatedGroups.Count == 0 ) )
         {
           m_dispatcherOperation.Abort();
           m_dispatcherOperation = null;
+          m_dispatcherOperationStartTime = DateTime.MinValue;
+          m_hasNewOperationsSinceStartTime = false;
         }
 
         m_pendingFlags[ -1 ] = false;
-        m_deferredOperations = null;
+        m_deferredOperations.Clear();
       }
     }
 
     public void PurgeAddWithRemoveOrReplace()
     {
-      if( m_deferredOperations == null )
-        return;
-
       if( m_deferredOperations.Count >= 2 )
       {
         DeferredOperation addOperation = m_deferredOperations[ 0 ];
@@ -205,7 +236,9 @@ namespace Xceed.Wpf.DataGrid
               lastIndexToRemove = i;
 
               if( removed )
+              {
                 firstIndexToRemove = 0;
+              }
             }
             else
             {
@@ -223,9 +256,7 @@ namespace Xceed.Wpf.DataGrid
 
         if( lastIndexToRemove > -1 )
         {
-          m_deferredOperations.RemoveRange(
-            firstIndexToRemove,
-            ( lastIndexToRemove - firstIndexToRemove ) + 1 );
+          m_deferredOperations.RemoveRange( firstIndexToRemove, ( lastIndexToRemove - firstIndexToRemove ) + 1 );
         }
       }
     }
@@ -242,7 +273,7 @@ namespace Xceed.Wpf.DataGrid
           case DeferredOperation.DeferredOperationAction.Refresh:
             {
               this.RefreshPending = true;
-              m_deferredOperations = null;
+              m_deferredOperations.Clear();
               break;
             }
 
@@ -274,22 +305,25 @@ namespace Xceed.Wpf.DataGrid
 
           default:
             {
-              if( m_deferredOperations == null )
-                m_deferredOperations = new List<DeferredOperation>();
-
               m_deferredOperations.Add( operation );
+              m_hasNewOperationsSinceStartTime = true;
+
+              if( this.DeferProcessOfInvalidatedGroupStats )
+              {
+                m_deferredOperationsToProcess++;
+              }
+
               break;
             }
         }
 
         if( ( m_dispatcher != null ) && ( m_dispatcherOperation == null ) )
         {
-          Debug.Assert( m_collectionViewToUpdate.Loaded );
+          Debug.Assert( m_collectionView.Loaded );
 
-          m_dispatcherOperation = m_dispatcher.BeginInvoke(
-            DispatcherPriority.DataBind,
-            new DispatcherOperationCallback( this.Dispatched_Process ),
-            null );
+          m_dispatcherOperation = m_dispatcher.BeginInvoke( DispatcherPriority.DataBind, new DispatcherOperationCallback( this.Dispatched_Process ), null );
+          m_dispatcherOperationStartTime = DateTime.UtcNow;
+          m_hasNewOperationsSinceStartTime = false;
         }
       }
     }
@@ -298,29 +332,23 @@ namespace Xceed.Wpf.DataGrid
     {
       lock( this )
       {
-        this.RefreshPending |= sourceDeferredOperationManager.RefreshPending;
-        this.RegroupPending |= sourceDeferredOperationManager.RegroupPending;
-        this.ResortPending |= sourceDeferredOperationManager.ResortPending;
-
-        this.RefreshDistincValuesPending |= sourceDeferredOperationManager.RefreshDistincValuesPending;
-
-        this.RefreshDistincValuesWithFilteredItemChangedPending |=
-          sourceDeferredOperationManager.RefreshDistincValuesWithFilteredItemChangedPending;
+        this.RefreshPending = this.RefreshPending || sourceDeferredOperationManager.RefreshPending;
+        this.RegroupPending = this.RegroupPending || sourceDeferredOperationManager.RegroupPending;
+        this.ResortPending = this.ResortPending || sourceDeferredOperationManager.ResortPending;
+        this.RefreshDistincValuesPending = this.RefreshDistincValuesPending || sourceDeferredOperationManager.RefreshDistincValuesPending;
+        this.RefreshDistincValuesWithFilteredItemChangedPending = this.RefreshDistincValuesWithFilteredItemChangedPending || sourceDeferredOperationManager.RefreshDistincValuesWithFilteredItemChangedPending;
 
         if( this.RefreshPending )
         {
-          m_deferredOperations = null;
+          m_deferredOperations.Clear();
           return;
         }
 
         List<DeferredOperation> sourceOperations = sourceDeferredOperationManager.m_deferredOperations;
 
-        if( ( sourceOperations == null ) || ( sourceOperations.Count == 0 ) )
+        if( sourceOperations.Count == 0 )
           return;
 
-        if( m_deferredOperations == null )
-          m_deferredOperations = new List<DeferredOperation>();
-
         m_deferredOperations.InsertRange( 0, sourceOperations );
       }
     }
@@ -330,7 +358,7 @@ namespace Xceed.Wpf.DataGrid
       this.Process( true );
     }
 
-    internal void InvalidateGroupStats( DataGridCollectionViewGroup group )
+    public void InvalidateGroupStats( DataGridCollectionViewGroup group, bool calculateAllStats = false )
     {
       if( group == null )
         return;
@@ -340,28 +368,31 @@ namespace Xceed.Wpf.DataGrid
         if( this.RefreshPending )
           return;
 
-        if( m_invalidatedGroups == null )
-          m_invalidatedGroups = new List<DataGridCollectionViewGroup>( 64 );
-
         DataGridCollectionViewGroup parent = group;
 
         while( parent != null )
         {
           if( !m_invalidatedGroups.Contains( parent ) )
           {
-            parent.ClearStatFunctionsResult();
             m_invalidatedGroups.Add( parent );
           }
 
+          parent.ClearStatFunctionsResult();
+          parent.CalculateAllStats = calculateAllStats;
           parent = parent.Parent;
         }
 
-        if( ( m_dispatcherOperation == null ) && ( m_dispatcher != null ) )
+        if( m_dispatcher != null )
         {
-          m_dispatcherOperation = m_dispatcher.BeginInvoke(
-            DispatcherPriority.DataBind,
-            new DispatcherOperationCallback( this.Dispatched_Process ),
-            null );
+          if( m_dispatcherOperation == null )
+          {
+            m_dispatcherOperation = m_dispatcher.BeginInvoke( DispatcherPriority.DataBind, new DispatcherOperationCallback( this.Dispatched_Process ), null );
+            m_dispatcherOperationStartTime = DateTime.UtcNow;
+          }
+          else
+          {
+            m_hasNewOperationsSinceStartTime = true;
+          }
         }
       }
     }
@@ -371,7 +402,7 @@ namespace Xceed.Wpf.DataGrid
       if( item == null )
         throw new ArgumentNullException( "item" );
 
-      if( m_deferredOperations == null )
+      if( m_deferredOperations.Count == 0 )
         return false;
 
       int deferredOperationsCount = m_deferredOperations.Count;
@@ -388,7 +419,7 @@ namespace Xceed.Wpf.DataGrid
           {
             object oldItem = deferredOperation.OldItems[ j ];
 
-            if( Object.Equals( oldItem, item ) )
+            if( object.Equals( oldItem, item ) )
               return true;
           }
         }
@@ -406,14 +437,29 @@ namespace Xceed.Wpf.DataGrid
     private void Process( bool processAll )
     {
       //This method will be called again when Dispose() is called on the DeferRefreshHelper of the CollectionView.
-      if( m_collectionViewToUpdate.InDeferRefresh )
+      if( m_collectionView.InDeferRefresh )
         return;
 
-      bool refreshForced = false;
+      if( !processAll )
+      {
+        lock( this )
+        {
+          if( ( m_hasNewOperationsSinceStartTime )
+            && ( m_dispatcherOperation != null )
+            && ( DateTime.UtcNow.Subtract( m_dispatcherOperationStartTime ) < DeferredOperationManager.MaxQueueDuration ) )
+          {
+            Debug.Assert( m_dispatcher != null );
+            m_dispatcherOperation = m_dispatcher.BeginInvoke( m_dispatcherOperation.Priority, new DispatcherOperationCallback( this.Dispatched_Process ), null );
+            m_hasNewOperationsSinceStartTime = false;
+
+            return;
+          }
+        }
+      }
 
       // We lock here since it is possible that a DataTable Column's value array is being redimensioned 
       // while we are trying to process the DeferredOperation.
-      lock( m_collectionViewToUpdate.SyncRoot )
+      lock( m_collectionView.SyncRoot )
       {
         lock( this )
         {
@@ -422,18 +468,13 @@ namespace Xceed.Wpf.DataGrid
           {
             m_dispatcherOperation.Abort();
             m_dispatcherOperation = null;
+            m_dispatcherOperationStartTime = DateTime.MinValue;
+            m_hasNewOperationsSinceStartTime = false;
           }
 
-          int operationIndex = 0;
-
-          long startTicks = DateTime.Now.Ticks;
-
-          // The fact of processing a deferredOperations can cause other DeferRefresh on the CollectionView
-          // that will finaly call this Process() again even if not yet completed.
-          // So we must cache all the flags and deferredOperations in local variable to prevent
-          // double execution of the operation.
-          List<DeferredOperation> deferredOperations = m_deferredOperations;
-          m_deferredOperations = null;
+          // The fact of processing a deferredOperations can cause other DeferRefresh on the CollectionView that will finaly call this Process() again even if not yet completed.
+          // So we must cache all the flags in local variable to prevent double execution of the operation, except for m_deferredOperation which has its own flag is set.
+          m_isProcessingOperations = true;
           bool refreshDistincValuesWithFilteredItemChangedPending = this.RefreshDistincValuesWithFilteredItemChangedPending;
           this.RefreshDistincValuesWithFilteredItemChangedPending = false;
           bool refreshDistincValuesPending = this.RefreshDistincValuesPending;
@@ -444,85 +485,86 @@ namespace Xceed.Wpf.DataGrid
           this.RegroupPending = false;
           bool resortPending = this.ResortPending;
           this.ResortPending = false;
-          List<DataGridCollectionViewGroup> invalidatedGroups = m_invalidatedGroups;
-          m_invalidatedGroups = null;
-          bool ensureGroupPosition = true;
+          bool refreshForced = false;
+
+          m_collectionView.RaisePreBatchCollectionChanged();
+
+          DateTime startTime = DateTime.UtcNow;
 
           if( refreshPending )
           {
-            Debug.Assert( deferredOperations == null );
-
-            m_collectionViewToUpdate.ExecuteSourceItemOperation( new DeferredOperation(
-              DeferredOperation.DeferredOperationAction.Refresh, -1, null ), out refreshForced );
+            m_collectionView.ExecuteSourceItemOperation( new DeferredOperation( DeferredOperation.DeferredOperationAction.Refresh, -1, null ), out refreshForced );
           }
           else if( regroupPending )
           {
-            ensureGroupPosition = false;
-
-            // Regrouping also do resorting
-            m_collectionViewToUpdate.ExecuteSourceItemOperation( new DeferredOperation(
-              DeferredOperation.DeferredOperationAction.Regroup, -1, null ), out refreshForced );
+            m_collectionView.ExecuteSourceItemOperation( new DeferredOperation( DeferredOperation.DeferredOperationAction.Regroup, -1, null ), out refreshForced );
           }
           else if( resortPending )
           {
-            ensureGroupPosition = false;
-
-            m_collectionViewToUpdate.ExecuteSourceItemOperation( new DeferredOperation(
-              DeferredOperation.DeferredOperationAction.Resort, -1, null ), out refreshForced );
+            m_collectionView.ExecuteSourceItemOperation( new DeferredOperation( DeferredOperation.DeferredOperationAction.Resort, -1, null ), out refreshForced );
           }
 
-          if( ( deferredOperations != null ) && ( !refreshForced ) )
+          if( ( m_deferredOperations.Count > 0 ) && ( !refreshForced ) )
           {
-            int count = deferredOperations.Count;
+            int count = m_deferredOperations.Count;
+            int operationIndex = 0;
 
-            while( ( operationIndex < count ) && ( ( processAll ) || ( DateTime.Now.Ticks - startTicks ) < 1000000 ) && ( !refreshForced ) )
+            while( ( operationIndex < count ) && ( !refreshForced ) && ( processAll || ( DateTime.UtcNow.Subtract( startTime ) < DeferredOperationManager.MaxProcessDuration ) ) )
             {
-              m_collectionViewToUpdate.ExecuteSourceItemOperation( deferredOperations[ operationIndex ], out refreshForced );
+              m_collectionView.ExecuteSourceItemOperation( m_deferredOperations[ operationIndex ], out refreshForced );
               operationIndex++;
             }
 
             if( ( operationIndex < count ) && ( !refreshForced ) )
             {
-              deferredOperations.RemoveRange( 0, operationIndex );
-
-              if( m_deferredOperations == null )
-              {
-                m_deferredOperations = deferredOperations;
-              }
-              else
-              {
-                Debug.Assert( false, "Should never get there." );
-                m_deferredOperations.InsertRange( 0, deferredOperations );
-              }
+              m_deferredOperations.RemoveRange( 0, operationIndex );
+              m_deferredOperationsToProcess -= operationIndex;
+            }
+            else
+            {
+              m_deferredOperations.Clear();
+              m_deferredOperationsToProcess = 0;
             }
           }
 
+          m_isProcessingOperations = false;
+
           // The recalculation of the StatFunctions is performed last.
-          if( invalidatedGroups != null )
-            m_collectionViewToUpdate.ProcessInvalidatedGroupStats( invalidatedGroups, ensureGroupPosition );
+          if( ( m_deferredOperationsToProcess <= 0 || m_forceProcessOfInvalidatedGroupStats ) && ( m_invalidatedGroups.Count != 0 ) )
+          {
+            m_collectionView.ProcessInvalidatedGroupStats( m_invalidatedGroups );
+            m_invalidatedGroups.Clear();
+            m_forceProcessOfInvalidatedGroupStats = false;
+          }
 
           // Since a refresh has been forced, we don't want to process anything else.
           if( !refreshForced )
           {
-            if( ( ( processAll ) || ( DateTime.Now.Ticks - startTicks ) < 1000000 ) )
+            if( processAll || ( DateTime.UtcNow.Subtract( startTime ) < DeferredOperationManager.MaxProcessDuration ) )
             {
               if( refreshDistincValuesWithFilteredItemChangedPending || refreshDistincValuesPending )
               {
-                m_collectionViewToUpdate.ExecuteSourceItemOperation( new DeferredOperation(
-                  DeferredOperation.DeferredOperationAction.RefreshDistincValues, refreshDistincValuesWithFilteredItemChangedPending ), out refreshForced );
+                m_collectionView.ExecuteSourceItemOperation( new DeferredOperation( DeferredOperation.DeferredOperationAction.RefreshDistincValues,
+                                                                                    refreshDistincValuesWithFilteredItemChangedPending ), out refreshForced );
               }
             }
             else
             {
               if( refreshDistincValuesWithFilteredItemChangedPending )
+              {
                 this.RefreshDistincValuesWithFilteredItemChangedPending = true;
+              }
 
               if( refreshDistincValuesPending )
+              {
                 this.RefreshDistincValuesPending = true;
+              }
             }
           }
 
-          if( this.HasPendingOperations )
+          m_collectionView.RaisePostBatchCollectionChanged();
+
+          if( this.HasPendingOperations || m_invalidatedGroups.Count != 0 )
           {
             Debug.Assert( !processAll );
             Debug.Assert( m_dispatcher != null );
@@ -532,29 +574,33 @@ namespace Xceed.Wpf.DataGrid
             {
               if( m_dispatcher != null )
               {
-                m_dispatcherOperation = m_dispatcher.BeginInvoke(
-                  DispatcherPriority.Input,
-                  new DispatcherOperationCallback( this.Dispatched_Process ),
-                  null );
+                m_dispatcherOperation = m_dispatcher.BeginInvoke( DispatcherPriority.Input, new DispatcherOperationCallback( this.Dispatched_Process ), null );
+                m_dispatcherOperationStartTime = DateTime.UtcNow;
+                m_hasNewOperationsSinceStartTime = false;
               }
             }
             else
             {
               m_dispatcherOperation.Priority = DispatcherPriority.Input;
+              m_dispatcherOperationStartTime = DateTime.UtcNow;
             }
           }
         }
       }
     }
 
-    private DataGridCollectionViewBase m_collectionViewToUpdate;
+    private readonly DataGridCollectionViewBase m_collectionView;
     private List<DeferredOperation> m_deferredOperations;
+    private HashSet<DataGridCollectionViewGroup> m_invalidatedGroups;
+    private int m_deferredOperationsToProcess;
     private BitVector32 m_pendingFlags;
+    private bool m_isProcessingOperations;
+    private bool m_forceProcessOfInvalidatedGroupStats;
 
-    private Dispatcher m_dispatcher;
+    private readonly Dispatcher m_dispatcher;
     private DispatcherOperation m_dispatcherOperation;
-
-    private List<DataGridCollectionViewGroup> m_invalidatedGroups;
+    private DateTime m_dispatcherOperationStartTime;
+    private bool m_hasNewOperationsSinceStartTime;
 
     [Flags]
     private enum DeferredOperationManagerPendingFlags
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesDictionary.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesDictionary.cs
index 872e762b..a71e2d08 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesDictionary.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesDictionary.cs
@@ -14,12 +14,8 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Xceed.Utils.Collections;
 using System.Diagnostics;
-using System.Collections;
+using Xceed.Utils.Collections;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -28,7 +24,7 @@ namespace Xceed.Wpf.DataGrid
     public DistinctValuesDictionary( DataGridCollectionViewBase dataGridCollectionViewBase )
     {
       if( dataGridCollectionViewBase == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "dataGridCollectionView is null." );
 
       m_dataGridCollectionViewBase = dataGridCollectionViewBase;
     }
@@ -66,7 +62,7 @@ namespace Xceed.Wpf.DataGrid
       {
         value = new ReadOnlyObservableHashList();
         this.InternalAdd( key, value );
-        m_dataGridCollectionViewBase.ForceRefreshDistinctValuesForFieldName( key, value.InnerObservableHashList );
+        m_dataGridCollectionViewBase.ForceRefreshDistinctValuesForFieldName( key );
       }
 
       Debug.Assert( value != null );
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesRefreshNeededEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesRefreshNeededEventManager.cs
new file mode 100644
index 00000000..983f7c35
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/DistinctValuesRefreshNeededEventManager.cs
@@ -0,0 +1,87 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DistinctValuesRefreshNeededEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private DistinctValuesRefreshNeededEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static DistinctValuesRefreshNeededEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( DistinctValuesRefreshNeededEventManager );
+        var currentManager = ( DistinctValuesRefreshNeededEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new DistinctValuesRefreshNeededEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.DistinctValuesRefreshNeeded += new EventHandler( this.DeliverEvent );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.DistinctValuesRefreshNeeded -= new EventHandler( this.DeliverEvent );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/GroupSortComparer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/GroupSortComparer.cs
index 9bb36147..0232f6ed 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/GroupSortComparer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/GroupSortComparer.cs
@@ -56,11 +56,10 @@ namespace Xceed.Wpf.DataGrid
 
       ListSortDirection sortDirection = ListSortDirection.Ascending;
       int result;
-      int sortInfoCount = m_sortInfos.Count;
 
-      for( int i = 0; i < sortInfoCount; i++ )
+      foreach( SortInfo sortInfo in m_sortInfos )
+      //for( int i = 0; i < sortInfoCount; i++ )
       {
-        SortInfo sortInfo = m_sortInfos[ i ];
         string statResultPropertyName = sortInfo.StatResultPropertyName;
         IComparer sortComparer = sortInfo.SortComparer;
         sortDirection = sortInfo.SortDirection;
@@ -97,12 +96,12 @@ namespace Xceed.Wpf.DataGrid
 
     public class SortInfo
     {
-      public SortInfo( string name, ListSortDirection sortDirection, IComparer sortComparer )
+      public SortInfo( string statResultPropertyName, ListSortDirection sortDirection, IComparer sortComparer )
       {
         if( sortComparer == null )
           throw new ArgumentNullException( "sortComparer" );
 
-        this.StatResultPropertyName = name;
+        this.StatResultPropertyName = statResultPropertyName;
         this.SortDirection = sortDirection;
         this.SortComparer = sortComparer;
       }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ItemPropertyGroupSortStatNameChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ItemPropertyGroupSortStatNameChangedEventManager.cs
new file mode 100644
index 00000000..8ea99cf1
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ItemPropertyGroupSortStatNameChangedEventManager.cs
@@ -0,0 +1,92 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ItemPropertyGroupSortStatNameChangedEventManager : WeakEventManager
+  {
+    private ItemPropertyGroupSortStatNameChangedEventManager()
+    {
+    }
+
+    #region CurrentManager Private Property
+
+    private static ItemPropertyGroupSortStatNameChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ItemPropertyGroupSortStatNameChangedEventManager );
+        var currentManager = WeakEventManager.GetCurrentManager( managerType ) as ItemPropertyGroupSortStatNameChangedEventManager;
+
+        if( currentManager == null )
+        {
+          currentManager = new ItemPropertyGroupSortStatNameChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridItemPropertyCollection source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridItemPropertyCollection source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = source as DataGridItemPropertyCollection;
+      //target.ItemPropertyGroupSortStatNameChanged += new EventHandler( this.DeliverEvent );
+      target.ItemPropertyGroupSortStatNameChanged += target_ItemPropertyGroupSortStatNameChanged;
+    }
+
+    void target_ItemPropertyGroupSortStatNameChanged( object sender, EventArgs e )
+    {
+      this.DeliverEvent( sender, e );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = source as DataGridItemPropertyCollection;
+      target.ItemPropertyGroupSortStatNameChanged -= new EventHandler( this.DeliverEvent );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PostBatchCollectionChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PostBatchCollectionChangedEventManager.cs
new file mode 100644
index 00000000..d3426f16
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PostBatchCollectionChangedEventManager.cs
@@ -0,0 +1,78 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class PostBatchCollectionChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private PostBatchCollectionChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Static Property
+
+    private static PostBatchCollectionChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( PostBatchCollectionChangedEventManager );
+        var currentManager = ( PostBatchCollectionChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new PostBatchCollectionChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      PostBatchCollectionChangedEventManager.CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      PostBatchCollectionChangedEventManager.CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      ( ( DataGridCollectionViewBase )source ).PostBatchCollectionChanged += new EventHandler( this.OnEventRaised );
+    }
+
+    protected override void StopListening( object source )
+    {
+      ( ( DataGridCollectionViewBase )source ).PostBatchCollectionChanged -= new EventHandler( this.OnEventRaised );
+    }
+
+    private void OnEventRaised( object sender, EventArgs e )
+    {
+      this.DeliverEvent( sender, e );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PreBatchCollectionChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PreBatchCollectionChangedEventManager.cs
new file mode 100644
index 00000000..573a752d
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PreBatchCollectionChangedEventManager.cs
@@ -0,0 +1,78 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class PreBatchCollectionChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private PreBatchCollectionChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Static Property
+
+    private static PreBatchCollectionChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( PreBatchCollectionChangedEventManager );
+        var currentManager = ( PreBatchCollectionChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new PreBatchCollectionChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      PreBatchCollectionChangedEventManager.CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      PreBatchCollectionChangedEventManager.CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      ( ( DataGridCollectionViewBase )source ).PreBatchCollectionChanged += new EventHandler( this.OnEventRaised );
+    }
+
+    protected override void StopListening( object source )
+    {
+      ( ( DataGridCollectionViewBase )source ).PreBatchCollectionChanged -= new EventHandler( this.OnEventRaised );
+    }
+
+    private void OnEventRaised( object sender, EventArgs e )
+    {
+      this.DeliverEvent( sender, e );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PropertyDetailDescription.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PropertyDetailDescription.cs
index d1bdae7f..11f4171c 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PropertyDetailDescription.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/PropertyDetailDescription.cs
@@ -128,87 +128,54 @@ namespace Xceed.Wpf.DataGrid
       throw new InvalidOperationException( "An attempt was made to initialize a PropertyDetailDescription whose data source does not contain a property that corresponds to the specified relation name." );
     }
 
-    private PropertyDescriptor GetPropertyDescriptorFromITypedList( ITypedList iTypedList )
+    private PropertyDescriptor GetPropertyDescriptorFromITypedList( ITypedList typedList )
     {
-      if( string.IsNullOrEmpty( this.RelationName ) == true )
+      if( string.IsNullOrEmpty( this.RelationName ) || ( typedList == null ) )
         return null;
 
-      Type objectType = null;
-      ICustomTypeDescriptor customTypeDescriptor = null;
-      PropertyDescriptorCollection properties = null;
-      PropertyDescriptor relationDescriptor = null;
-      TypeDescriptionProvider typeDescriptionProvider = null;
+      PropertyDescriptorCollection properties;
 
-      if( iTypedList != null )
-      {
-        properties = iTypedList.GetItemProperties( null );
+      properties = typedList.GetItemProperties( null );
+      if( ( properties != null ) && ( properties.Count > 0 ) )
+        return properties[ this.RelationName ];
 
-        if( ( properties != null ) && ( properties.Count > 0 ) )
-        {
-          relationDescriptor = properties[ this.RelationName ];
-        }
-        else
-        {
-          string listName = iTypedList.GetListName( null );
+      var listName = typedList.GetListName( null );
+      if( string.IsNullOrEmpty( listName ) )
+        return null;
 
-          if( string.IsNullOrEmpty( listName ) == false )
-          {
-            objectType = Type.GetType( listName, false, false );
+      var itemType = Type.GetType( listName, false, false );
+      if( itemType == null )
+        return null;
 
-            if( objectType != null )
-            {
-              typeDescriptionProvider = TypeDescriptor.GetProvider( objectType );
-              if( typeDescriptionProvider != null )
-              {
-                customTypeDescriptor = typeDescriptionProvider.GetTypeDescriptor( objectType );
-
-                if( customTypeDescriptor != null )
-                {
-                  properties = customTypeDescriptor.GetProperties();
-
-                  if( ( properties != null ) && ( properties.Count > 0 ) )
-                    relationDescriptor = properties[ this.RelationName ];
-                }
-              }
-            }
-          }
-        }
-      }
+      var descriptionProvider = TypeDescriptor.GetProvider( itemType );
+      if( descriptionProvider == null )
+        return null;
 
-      return relationDescriptor;
+      var descriptor = descriptionProvider.GetTypeDescriptor( itemType );
+      if( descriptor == null )
+        return null;
+
+      properties = descriptor.GetProperties();
+      if( ( properties != null ) && ( properties.Count > 0 ) )
+        return properties[ this.RelationName ];
+
+      return null;
     }
 
     private PropertyDescriptor GetPropertyDescriptorFromFirstItem( object firstItem )
     {
-      if( string.IsNullOrEmpty( this.RelationName ) == true )
+      if( string.IsNullOrEmpty( this.RelationName ) || ( firstItem == null ) )
         return null;
 
-      Type objectType = null;
-      ICustomTypeDescriptor customTypeDescriptor = null;
-      PropertyDescriptorCollection properties = null;
-      PropertyDescriptor relationDescriptor = null;
-      TypeDescriptionProvider typeDescriptionProvider = null;
-
-      objectType = firstItem.GetType();
-
-      if( objectType != null )
-      {
-        typeDescriptionProvider = TypeDescriptor.GetProvider( objectType );
-        if( typeDescriptionProvider != null )
-        {
-          customTypeDescriptor = typeDescriptionProvider.GetTypeDescriptor( objectType, firstItem );
-
-          if( customTypeDescriptor != null )
-          {
-            properties = customTypeDescriptor.GetProperties();
+      var descriptor = ItemsSourceHelper.GetCustomTypeDescriptor( firstItem, firstItem.GetType() );
+      if( descriptor == null )
+        return null;
 
-            if( ( properties != null ) && ( properties.Count > 0 ) )
-              relationDescriptor = properties[ this.RelationName ];
-          }
-        }
-      }
+      var properties = descriptor.GetProperties();
+      if( ( properties != null ) && ( properties.Count > 0 ) )
+        return properties[ this.RelationName ];
 
-      return relationDescriptor;
+      return null;
     }
 
     protected internal override IEnumerable GetDetailsForParentItem( DataGridCollectionViewBase parentCollectionView, object parentItem )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyApplyingFilterCriteriasEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyApplyingFilterCriteriasEventManager.cs
new file mode 100644
index 00000000..c0e4e805
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyApplyingFilterCriteriasEventManager.cs
@@ -0,0 +1,87 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ProxyApplyingFilterCriteriasEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private ProxyApplyingFilterCriteriasEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static ProxyApplyingFilterCriteriasEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ProxyApplyingFilterCriteriasEventManager );
+        var currentManager = ( ProxyApplyingFilterCriteriasEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ProxyApplyingFilterCriteriasEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyApplyingFilterCriterias += new EventHandler( this.DeliverEvent );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyApplyingFilterCriterias -= new EventHandler( this.DeliverEvent );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyAutoFilterValuesChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyAutoFilterValuesChangedEventManager.cs
new file mode 100644
index 00000000..2e6760a8
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyAutoFilterValuesChangedEventManager.cs
@@ -0,0 +1,93 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Specialized;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ProxyAutoFilterValuesChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private ProxyAutoFilterValuesChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static ProxyAutoFilterValuesChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ProxyAutoFilterValuesChangedEventManager );
+        var currentManager = ( ProxyAutoFilterValuesChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ProxyAutoFilterValuesChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyAutoFilterValuesChanged += new NotifyCollectionChangedEventHandler( this.OnEventRaised );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyAutoFilterValuesChanged -= new NotifyCollectionChangedEventHandler( this.OnEventRaised );
+    }
+
+    private void OnEventRaised( object sender, NotifyCollectionChangedEventArgs e )
+    {
+      this.DeliverEvent( sender, e );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyCollectionRefreshEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyCollectionRefreshEventManager.cs
new file mode 100644
index 00000000..6610e084
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyCollectionRefreshEventManager.cs
@@ -0,0 +1,87 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ProxyCollectionRefreshEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private ProxyCollectionRefreshEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static ProxyCollectionRefreshEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ProxyCollectionRefreshEventManager );
+        var currentManager = ( ProxyCollectionRefreshEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ProxyCollectionRefreshEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyCollectionRefresh += new EventHandler( this.DeliverEvent );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyCollectionRefresh -= new EventHandler( this.DeliverEvent );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyGroupDescriptionsChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyGroupDescriptionsChangedEventManager.cs
new file mode 100644
index 00000000..95c6aa3d
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxyGroupDescriptionsChangedEventManager.cs
@@ -0,0 +1,93 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Specialized;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ProxyGroupDescriptionsChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private ProxyGroupDescriptionsChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static ProxyGroupDescriptionsChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ProxyGroupDescriptionsChangedEventManager );
+        var currentManager = ( ProxyGroupDescriptionsChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ProxyGroupDescriptionsChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyGroupDescriptionsChanged += new NotifyCollectionChangedEventHandler( this.OnEventRaised );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxyGroupDescriptionsChanged -= new NotifyCollectionChangedEventHandler( this.OnEventRaised );
+    }
+
+    private void OnEventRaised( object sender, NotifyCollectionChangedEventArgs e )
+    {
+      this.DeliverEvent( sender, e );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxySortDescriptionsChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxySortDescriptionsChangedEventManager.cs
new file mode 100644
index 00000000..7c62a0cd
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/ProxySortDescriptionsChangedEventManager.cs
@@ -0,0 +1,93 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Specialized;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ProxySortDescriptionsChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private ProxySortDescriptionsChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static ProxySortDescriptionsChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( ProxySortDescriptionsChangedEventManager );
+        var currentManager = ( ProxySortDescriptionsChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ProxySortDescriptionsChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionViewBase source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxySortDescriptionsChanged += new NotifyCollectionChangedEventHandler( this.OnEventRaised );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridCollectionViewBase )source;
+      target.ProxySortDescriptionsChanged -= new NotifyCollectionChangedEventHandler( this.OnEventRaised );
+    }
+
+    private void OnEventRaised( object sender, NotifyCollectionChangedEventArgs e )
+    {
+      this.DeliverEvent( sender, e );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/QueryableExtensions.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/QueryableExtensions.cs
index d9ec92db..ee7d4f72 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/QueryableExtensions.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/QueryableExtensions.cs
@@ -16,12 +16,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Linq;
-using System.Text;
 using System.Linq.Expressions;
 using System.Reflection;
-using System.ComponentModel;
-using System.Diagnostics;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -482,9 +481,9 @@ namespace Xceed.Wpf.DataGrid
         typeof( Queryable ), "Count",
         new Type[] { queryableElementType }, expressionToCount );
 
-      Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization,"Beginning Provider Execute for total count." );
+      Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization, "Beginning Provider Execute for total count." );
       int count = ( int )queryable.Provider.Execute( countExpression );
-      Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization,"Ended Provider Execute for total count." );
+      Debug.WriteLineIf( VirtualPageManager.DebugDataVirtualization, "Ended Provider Execute for total count." );
       return count;
     }
 
@@ -531,7 +530,7 @@ namespace Xceed.Wpf.DataGrid
       MemberInfo member = QueryableExtensions.GetMemberInfo( typeExpression.Type, name );
 
       if( member == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "MemberInfo is null." );
 
       if( member is PropertyInfo )
       {
@@ -651,9 +650,20 @@ namespace Xceed.Wpf.DataGrid
 
     internal interface IQueryableGroupNameCountPair
     {
-      object GroupName { get; }
-      Type GroupNameType { get; }
-      int Count { get; }
+      object GroupName
+      {
+        get;
+      }
+
+      Type GroupNameType
+      {
+        get;
+      }
+
+      int Count
+      {
+        get;
+      }
     }
 
     #endregion INTERNAL NESTED CLASSES
@@ -668,24 +678,42 @@ namespace Xceed.Wpf.DataGrid
         this.Count = count;
       }
 
-      public T GroupName { get; set; }
-      public int Count { get; set;  }
+      public T GroupName
+      {
+        get;
+        set;
+      }
+
+      public int Count
+      {
+        get;
+        set;
+      }
 
       #region QueryableGroupNameCountPair Members
 
       object IQueryableGroupNameCountPair.GroupName
       {
-        get { return this.GroupName; }
+        get
+        {
+          return this.GroupName;
+        }
       }
 
       public Type GroupNameType
       {
-        get { return typeof( T ); }
+        get
+        {
+          return typeof( T );
+        }
       }
 
       int IQueryableGroupNameCountPair.Count
       {
-        get { return this.Count; }
+        get
+        {
+          return this.Count;
+        }
       }
 
       #endregion
@@ -729,10 +757,29 @@ namespace Xceed.Wpf.DataGrid
 
     private struct QueryableGroupNameCountPairInfo
     {
-      public Type Type { get; set; }
-      public ConstructorInfo ConstructorInfo { get; set; }
-      public PropertyInfo KeyPropertyInfo { get; set; }
-      public PropertyInfo CountPropertyInfo { get; set; }
+      public Type Type
+      {
+        get;
+        set;
+      }
+
+      public ConstructorInfo ConstructorInfo
+      {
+        get;
+        set;
+      }
+
+      public PropertyInfo KeyPropertyInfo
+      {
+        get;
+        set;
+      }
+
+      public PropertyInfo CountPropertyInfo
+      {
+        get;
+        set;
+      }
     }
 
     #endregion PRIVATE NESTED CLASSES
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RawItemMap.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RawItemMap.cs
new file mode 100644
index 00000000..01bef4eb
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RawItemMap.cs
@@ -0,0 +1,145 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class RawItemMap
+  {
+    #region [] Property
+
+    internal RawItem this[ object dataItem ]
+    {
+      get
+      {
+        Debug.Assert( dataItem != null );
+
+        RawItem value;
+        if( m_singleMap.TryGetValue( dataItem, out value ) )
+          return value;
+
+        RawItem[] values;
+        if( m_multiMap.TryGetValue( dataItem, out values ) )
+          return values[ 0 ];
+
+        return null;
+      }
+    }
+
+    #endregion
+
+    internal void Add( object dataItem, RawItem rawItem )
+    {
+      Debug.Assert( dataItem != null );
+      Debug.Assert( rawItem != null );
+      Debug.Assert( dataItem == rawItem.DataItem );
+
+      RawItem single;
+      RawItem[] multiple;
+
+      if( m_singleMap.TryGetValue( dataItem, out single ) )
+      {
+        Debug.Assert( rawItem != single, "It's not normal to be called twice for the same RawItem." );
+
+        m_multiMap.Add( dataItem, new RawItem[] { single, rawItem } );
+        m_singleMap.Remove( dataItem );
+      }
+      else if( m_multiMap.TryGetValue( dataItem, out multiple ) )
+      {
+        Debug.Assert( !multiple.Contains( rawItem ), "It's not normal to be called twice for the same RawItem." );
+
+        var length = multiple.Length;
+
+        Array.Resize<RawItem>( ref multiple, length + 1 );
+        multiple[ length ] = rawItem;
+
+        m_multiMap[ dataItem ] = multiple;
+      }
+      else
+      {
+        m_singleMap.Add( dataItem, rawItem );
+      }
+    }
+
+    internal void Remove( object dataItem, RawItem rawItem )
+    {
+      Debug.Assert( dataItem != null );
+      Debug.Assert( rawItem != null );
+      Debug.Assert( dataItem == rawItem.DataItem );
+
+      if( m_singleMap.Remove( dataItem ) )
+        return;
+
+      RawItem[] multiple;
+      if( !m_multiMap.TryGetValue( dataItem, out multiple ) )
+        return;
+
+      var length = multiple.Length;
+      if( length == 2 )
+      {
+        if( multiple[ 0 ] == rawItem )
+        {
+          m_singleMap.Add( dataItem, multiple[ 1 ] );
+          m_multiMap.Remove( dataItem );
+        }
+        else if( multiple[ 1 ] == rawItem )
+        {
+          m_singleMap.Add( dataItem, multiple[ 0 ] );
+          m_multiMap.Remove( dataItem );
+        }
+      }
+      else
+      {
+        Debug.Assert( length > 2 );
+
+        var index = Array.IndexOf( multiple, rawItem );
+        if( index < 0 )
+          return;
+
+        RawItem[] copy = new RawItem[ length - 1 ];
+
+        if( index > 0 )
+        {
+          Array.Copy( multiple, 0, copy, 0, index );
+        }
+
+        if( index < length - 1 )
+        {
+          Array.Copy( multiple, index + 1, copy, index, length - index - 1 );
+        }
+
+        m_multiMap[ dataItem ] = copy;
+      }
+    }
+
+    internal void Clear()
+    {
+      m_singleMap.Clear();
+      m_multiMap.Clear();
+    }
+
+    #region Private Fields
+
+    private readonly Dictionary<object, RawItem> m_singleMap = new Dictionary<object, RawItem>( 128 );
+    private readonly Dictionary<object, RawItem[]> m_multiMap = new Dictionary<object, RawItem[]>( 0 );
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RootGroupChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RootGroupChangedEventManager.cs
new file mode 100644
index 00000000..48f4843f
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(CollectionView)/RootGroupChangedEventManager.cs
@@ -0,0 +1,87 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class RootGroupChangedEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private RootGroupChangedEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Private Property
+
+    private static RootGroupChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( RootGroupChangedEventManager );
+        var currentManager = ( RootGroupChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new RootGroupChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( DataGridCollectionView source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( DataGridCollectionView source, IWeakEventListener listener )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      if( listener == null )
+        throw new ArgumentNullException( "listener" );
+
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var target = ( DataGridCollectionView )source;
+      target.RootGroupChanged += new EventHandler( this.DeliverEvent );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var target = ( DataGridCollectionView )source;
+      target.RootGroupChanged -= new EventHandler( this.DeliverEvent );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyConfiguration.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyConfiguration.cs
index 1ee00cbc..883c6dfb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyConfiguration.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyConfiguration.cs
@@ -15,25 +15,21 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Data;
+using System.Globalization;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
-using System.Diagnostics;
-using System.ComponentModel;
-using System.Collections;
-using System.Globalization;
-using System.Collections.Specialized;
-using System.Data;
+using Xceed.Utils.Collections;
 
 namespace Xceed.Wpf.DataGrid
 {
-  public class ForeignKeyConfiguration : DependencyObject
+  public class ForeignKeyConfiguration : DependencyObject, IWeakEventListener
   {
-    #region Constructors
-
     static ForeignKeyConfiguration()
     {
       ForeignKeyConfiguration.DefaultDistinctValueItemContentTemplateProperty = ForeignKeyConfiguration.DefaultDistinctValueItemContentTemplatePropertyKey.DependencyProperty;
@@ -45,30 +41,25 @@ namespace Xceed.Wpf.DataGrid
 
     public ForeignKeyConfiguration()
     {
-      this.SetDefaultDistinctValueItemContentTemplate( Column.GenericContentTemplateSelector.ForeignKeyDistinctValueItemContentTemplate );
-      this.SetDefaultCellContentTemplate( Column.GenericContentTemplateSelector.ForeignKeyCellContentTemplate );
-      this.SetDefaultGroupValueTemplate( Column.GenericContentTemplateSelector.ForeignKeyGroupValueTemplate );
-      this.SetDefaultScrollTipContentTemplate( Column.GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate );
+      this.SetDefaultCellContentTemplate( GenericContentTemplateSelector.ForeignKeyCellContentTemplate );
+      this.SetDefaultGroupValueTemplate( GenericContentTemplateSelector.ForeignKeyGroupValueTemplate );
+      this.SetDefaultScrollTipContentTemplate( GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate );
       this.SetDefaultCellEditor( DefaultCellEditorSelector.ForeignKeyCellEditor );
     }
 
-    #endregion
-
     #region ValuePath Property
 
     public static readonly DependencyProperty ValuePathProperty = DependencyProperty.Register(
       "ValuePath",
       typeof( string ),
       typeof( ForeignKeyConfiguration ),
-      new FrameworkPropertyMetadata(
-        null,
-        new PropertyChangedCallback( ForeignKeyConfiguration.OnSelectedValuePathChanged ) ) );
+      new FrameworkPropertyMetadata( null ) );
 
     public string ValuePath
     {
       get
       {
-        return m_ValuePath;
+        return ( string )this.GetValue( ForeignKeyConfiguration.ValuePathProperty );
       }
       set
       {
@@ -76,18 +67,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private string m_ValuePath; // = null;
-
-    private static void OnSelectedValuePathChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ForeignKeyConfiguration foreignKeyConfiguration = sender as ForeignKeyConfiguration;
-
-      if( foreignKeyConfiguration != null )
-      {
-        foreignKeyConfiguration.m_ValuePath = e.NewValue as string;
-      }
-    }
-
     #endregion
 
     #region DisplayMemberPath Property
@@ -96,15 +75,13 @@ namespace Xceed.Wpf.DataGrid
       "DisplayMemberPath",
       typeof( string ),
       typeof( ForeignKeyConfiguration ),
-      new FrameworkPropertyMetadata(
-        null,
-        new PropertyChangedCallback( ForeignKeyConfiguration.OnDisplayMemberPathChanged ) ) );
+      new FrameworkPropertyMetadata( null ) );
 
     public string DisplayMemberPath
     {
       get
       {
-        return m_displayMemberPath;
+        return ( string )this.GetValue( ForeignKeyConfiguration.DisplayMemberPathProperty );
       }
       set
       {
@@ -112,18 +89,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private string m_displayMemberPath; // = null;
-
-    private static void OnDisplayMemberPathChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ForeignKeyConfiguration foreignKeyConfiguration = sender as ForeignKeyConfiguration;
-
-      if( foreignKeyConfiguration != null )
-      {
-        foreignKeyConfiguration.m_displayMemberPath = e.NewValue as string;
-      }
-    }
-
     #endregion
 
     #region ItemContainerStyle Property
@@ -132,15 +97,13 @@ namespace Xceed.Wpf.DataGrid
       "ItemContainerStyle",
       typeof( Style ),
       typeof( ForeignKeyConfiguration ),
-      new FrameworkPropertyMetadata(
-        null,
-        new PropertyChangedCallback( ForeignKeyConfiguration.OnItemContainerStyleChanged ) ) );
+      new FrameworkPropertyMetadata( null ) );
 
     public Style ItemContainerStyle
     {
       get
       {
-        return m_itemContainerStyle;
+        return ( Style )this.GetValue( ForeignKeyConfiguration.ItemContainerStyleProperty );
       }
       set
       {
@@ -148,16 +111,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private Style m_itemContainerStyle; // = null;
-
-    private static void OnItemContainerStyleChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ForeignKeyConfiguration foreignKeyConfiguration = sender as ForeignKeyConfiguration;
-
-      if( foreignKeyConfiguration != null )
-        foreignKeyConfiguration.m_itemContainerStyle = e.NewValue as Style;
-    }
-
     #endregion
 
     #region ItemContainerStyleSelector Property
@@ -166,15 +119,13 @@ namespace Xceed.Wpf.DataGrid
       "ItemContainerStyleSelector",
       typeof( StyleSelector ),
       typeof( ForeignKeyConfiguration ),
-      new FrameworkPropertyMetadata(
-        null,
-        new PropertyChangedCallback( ForeignKeyConfiguration.OnItemContainerStyleSelectorChanged ) ) );
+      new FrameworkPropertyMetadata( null ) );
 
     public StyleSelector ItemContainerStyleSelector
     {
       get
       {
-        return m_itemContainerStyleSelector;
+        return ( StyleSelector )this.GetValue( ForeignKeyConfiguration.ItemContainerStyleSelectorProperty );
       }
       set
       {
@@ -182,18 +133,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private StyleSelector m_itemContainerStyleSelector; // = null;
-
-    private static void OnItemContainerStyleSelectorChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ForeignKeyConfiguration foreignKeyConfiguration = sender as ForeignKeyConfiguration;
-
-      if( foreignKeyConfiguration != null )
-      {
-        foreignKeyConfiguration.m_itemContainerStyleSelector = e.NewValue as StyleSelector;
-      }
-    }
-
     #endregion
 
     #region IsAutoCreated Property
@@ -220,8 +159,7 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_itemsSource;
-
+        return ( IEnumerable )this.GetValue( ForeignKeyConfiguration.ItemsSourceProperty );
       }
       set
       {
@@ -229,18 +167,65 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private IEnumerable m_itemsSource;
-
     private static void OnItemsSourceChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      ForeignKeyConfiguration foreignConfiguration = sender as ForeignKeyConfiguration;
-
+      var foreignConfiguration = sender as ForeignKeyConfiguration;
       if( foreignConfiguration != null )
       {
-        foreignConfiguration.m_itemsSource = e.NewValue as IEnumerable;
+        foreignConfiguration.OnItemsSourceChanged( ( IEnumerable )e.OldValue, ( IEnumerable )e.NewValue );
+      }
+    }
+
+    private void OnItemsSourceChanged( IEnumerable oldItemsSource, IEnumerable newItemsSource )
+    {
+      //Unsubscribe from the old list changed event, if any.
+      if( oldItemsSource != null )
+      {
+        var oldNotifyCollectionChanged = oldItemsSource as INotifyCollectionChanged;
+        if( oldNotifyCollectionChanged != null )
+        {
+          CollectionChangedEventManager.RemoveListener( oldNotifyCollectionChanged, this );
+        }
+        else
+        {
+          var oldBindingList = oldItemsSource as IBindingList;
+          if( oldBindingList != null && oldBindingList.SupportsChangeNotification )
+          {
+            ListChangedEventManager.RemoveListener( oldBindingList, this );
+          }
+        }
+      }
+
+      //Subscribe from to the new list changed event, if any.
+      if( newItemsSource != null )
+      {
+        var newNotifyCollectionChanged = newItemsSource as INotifyCollectionChanged;
+        if( newNotifyCollectionChanged != null )
+        {
+          CollectionChangedEventManager.AddListener( newNotifyCollectionChanged, this );
+        }
+        else
+        {
+          var newBindingList = newItemsSource as IBindingList;
+          if( newBindingList != null && newBindingList.SupportsChangeNotification )
+          {
+            ListChangedEventManager.AddListener( newBindingList, this );
+          }
+        }
       }
     }
 
+    private void OnNotifiyCollectionChanged()
+    {
+      var handler = this.NotifiyCollectionChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, EventArgs.Empty );
+    }
+
+    internal event EventHandler NotifiyCollectionChanged;
+
     #endregion
 
     #region ForeignKeyConverter Property
@@ -265,6 +250,126 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region ForeignKeyValueConverter Property
+
+    public static readonly DependencyProperty ForeignKeyValueConverterProperty = DependencyProperty.Register(
+      "ForeignKeyValueConverter",
+      typeof( IValueConverter ),
+      typeof( ForeignKeyConfiguration ),
+      new FrameworkPropertyMetadata( null ) );
+
+    public IValueConverter ForeignKeyValueConverter
+    {
+      get
+      {
+        return ( IValueConverter )this.GetValue( ForeignKeyConfiguration.ForeignKeyValueConverterProperty );
+      }
+      set
+      {
+        this.SetValue( ForeignKeyConfiguration.ForeignKeyValueConverterProperty, value );
+      }
+    }
+
+    #endregion
+
+    #region ForeignKeyValueConverterParameter Property
+
+    public static readonly DependencyProperty ForeignKeyValueConverterParameterProperty = DependencyProperty.Register(
+      "ForeignKeyValueConverterParameter",
+      typeof( object ),
+      typeof( ForeignKeyConfiguration ),
+      new FrameworkPropertyMetadata( null ) );
+
+    public object ForeignKeyValueConverterParameter
+    {
+      get
+      {
+        return ( object )this.GetValue( ForeignKeyConfiguration.ForeignKeyValueConverterParameterProperty );
+      }
+      set
+      {
+        this.SetValue( ForeignKeyConfiguration.ForeignKeyValueConverterParameterProperty, value );
+      }
+    }
+
+    #endregion
+
+    #region ForeignKeyValueConverterCulture Property
+
+    public static readonly DependencyProperty ForeignKeyValueConverterCultureProperty = DependencyProperty.Register(
+      "ForeignKeyValueConverterCulture",
+      typeof( CultureInfo ),
+      typeof( ForeignKeyConfiguration ),
+      new FrameworkPropertyMetadata( null ) );
+
+    public CultureInfo ForeignKeyValueConverterCulture
+    {
+      get
+      {
+        return ( CultureInfo )this.GetValue( ForeignKeyConfiguration.ForeignKeyValueConverterCultureProperty );
+      }
+      set
+      {
+        this.SetValue( ForeignKeyConfiguration.ForeignKeyValueConverterCultureProperty, value );
+      }
+    }
+
+    #endregion
+
+    #region UseDefaultFilterCriterion Property
+
+    public static readonly DependencyProperty UseDefaultFilterCriterionProperty = DependencyProperty.Register(
+      "UseDefaultFilterCriterion",
+      typeof( bool ),
+      typeof( ForeignKeyConfiguration ),
+      new FrameworkPropertyMetadata( true ) );
+
+    public bool UseDefaultFilterCriterion
+    {
+      get
+      {
+        return ( bool )this.GetValue( ForeignKeyConfiguration.UseDefaultFilterCriterionProperty );
+      }
+      set
+      {
+        this.SetValue( ForeignKeyConfiguration.UseDefaultFilterCriterionProperty, value );
+      }
+    }
+
+    #endregion
+
+    #region UseDisplayedValueWhenExporting Property
+
+    public static readonly DependencyProperty UseDisplayedValueWhenExportingProperty = DependencyProperty.Register(
+      "UseDisplayedValueWhenExporting",
+      typeof( bool ),
+      typeof( ForeignKeyConfiguration ),
+      new FrameworkPropertyMetadata( true ) );
+
+    public bool UseDisplayedValueWhenExporting
+    {
+      get
+      {
+        return ( bool )this.GetValue( ForeignKeyConfiguration.UseDisplayedValueWhenExportingProperty );
+      }
+      set
+      {
+        this.SetValue( ForeignKeyConfiguration.UseDisplayedValueWhenExportingProperty, value );
+      }
+    }
+
+    #endregion
+
+    #region ValuePathDataType Property
+
+    internal Type ValuePathDataType
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
     #region DefaultDistinctValueItemContentTemplate Property
 
     private static readonly DependencyPropertyKey DefaultDistinctValueItemContentTemplatePropertyKey = DependencyProperty.RegisterReadOnly(
@@ -396,7 +501,6 @@ namespace Xceed.Wpf.DataGrid
 
     internal static readonly DependencyProperty DefaultCellEditorProperty;
 
-
     internal CellEditor DefaultCellEditor
     {
       get
@@ -417,42 +521,72 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region Static Methods
+    internal object GetDisplayMemberValue( object fieldValue )
+    {
+      try
+      {
+        var valuePath = this.ValuePath;
+        var displayMemberPath = this.DisplayMemberPath;
+
+        if( ( valuePath == null ) || ( displayMemberPath == null ) )
+          return fieldValue;
 
-    internal static void UpdateColumnsForeignKeyConfigurations(
-      Dictionary<string,ColumnBase> columns,
-      IEnumerable itemsSourceCollection,
-      Dictionary<string, ItemsSourceHelper.FieldDescriptor> fieldDescriptors,
-      bool autoCreateForeignKeyConfigurations )
+        var itemsSource = this.ItemsSource;
+
+        //Convert the value from the ValuePath value to the DisplayMemberPath value, using a DataRowView or reflection.
+        if( ( itemsSource is DataView ) || ( itemsSource is DataTable ) )
+        {
+          foreach( object item in itemsSource )
+          {
+            DataRowView dataRowView = item as DataRowView;
+            if( dataRowView != null )
+            {
+              var value = dataRowView[ valuePath ];
+
+              if( fieldValue.Equals( value ) )
+                return dataRowView[ displayMemberPath ];
+            }
+          }
+        }
+        else
+        {
+          foreach( object item in itemsSource )
+          {
+            var value = item.GetType().GetProperty( valuePath ).GetValue( item, null );
+
+            if( fieldValue.Equals( value ) )
+              return item.GetType().GetProperty( displayMemberPath ).GetValue( item, null );
+          }
+        }
+      }
+      catch
+      {
+        //Swallow the exception, no need to terminate the application, since the original value will be exported.
+      }
+
+      return fieldValue;
+    }
+
+    internal static void UpdateColumnsForeignKeyConfigurations( Dictionary<string, ColumnBase> columns, IEnumerable itemsSourceCollection,
+                                                                Dictionary<string, ItemsSourceHelper.FieldDescriptor> fieldDescriptors, bool autoCreateForeignKeyConfigurations )
     {
-      DataGridCollectionViewBase collectionViewBase =
-        itemsSourceCollection as DataGridCollectionViewBase;
+      DataGridCollectionViewBase collectionViewBase = itemsSourceCollection as DataGridCollectionViewBase;
 
       if( collectionViewBase != null )
       {
-        ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView(
-          columns,
-          collectionViewBase.ItemProperties,
-          autoCreateForeignKeyConfigurations );
+        ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView( columns, collectionViewBase.ItemProperties, autoCreateForeignKeyConfigurations );
       }
       else
       {
-        ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromFieldDescriptors(
-          columns,
-          fieldDescriptors,
-          autoCreateForeignKeyConfigurations );
+        ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromFieldDescriptors( columns, fieldDescriptors, autoCreateForeignKeyConfigurations );
       }
     }
 
-    // If a DataGridCollectionViewBase is used, get the ItemProperties it defines
-    // to be able to retreive DataGridForeignKeyDescription for each of them
+    // If a DataGridCollectionViewBase is used, get the ItemProperties it defines to be able to retreive DataGridForeignKeyDescription for each of them
     // to get the auto-detected ForeignKey ItemsSource (if any).
-    // If a DataGridCollectionViewBase is not used, the ItemsSource must be 
-    // manually specified on each Column in order to correctly display/edit the Data
-    internal static void UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView(
-      Dictionary<string,ColumnBase> columns,
-      DataGridItemPropertyCollection itemProperties,
-      bool autoCreateForeignKeyConfigurations )
+    // If a DataGridCollectionViewBase is not used, the ItemsSource must be manually specified on each Column in order to correctly display/edit the Data
+    internal static void UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView( Dictionary<string, ColumnBase> columns, DataGridItemPropertyCollection itemProperties,
+                                                                                          bool autoCreateForeignKeyConfigurations )
     {
       if( itemProperties == null )
         return;
@@ -467,17 +601,13 @@ namespace Xceed.Wpf.DataGrid
         ColumnBase column;
         columns.TryGetValue( itemProperty.Name, out column );
 
-        ForeignKeyConfiguration.SynchronizeForeignKeyConfigurationFromForeignKeyDescription(
-          column as Column,
-          description,
-          autoCreateForeignKeyConfigurations );
+        ForeignKeyConfiguration.SynchronizeForeignKeyConfigurationFromForeignKeyDescription( column as Column, description, autoCreateForeignKeyConfigurations );
       }
     }
 
-    private static void UpdateColumnsForeignKeyConfigurationsFromFieldDescriptors(
-      Dictionary<string, ColumnBase> columns,
-      Dictionary<string, ItemsSourceHelper.FieldDescriptor> fieldDescriptors,
-      bool autoCreateForeignKeyConfigurations )
+    private static void UpdateColumnsForeignKeyConfigurationsFromFieldDescriptors( Dictionary<string, ColumnBase> columns,
+                                                                                   Dictionary<string, ItemsSourceHelper.FieldDescriptor> fieldDescriptors,
+                                                                                   bool autoCreateForeignKeyConfigurations )
     {
       if( columns == null )
         return;
@@ -495,17 +625,12 @@ namespace Xceed.Wpf.DataGrid
         ColumnBase column;
         columns.TryGetValue( fieldDescriptor.Name, out column );
 
-        ForeignKeyConfiguration.SynchronizeForeignKeyConfigurationFromForeignKeyDescription(
-          column as Column,
-          description,
-          autoCreateForeignKeyConfigurations );
+        ForeignKeyConfiguration.SynchronizeForeignKeyConfigurationFromForeignKeyDescription( column as Column, description, autoCreateForeignKeyConfigurations );
       }
     }
 
-    internal static void SynchronizeForeignKeyConfigurationFromForeignKeyDescription(
-      Column column,
-      DataGridForeignKeyDescription description,
-      bool autoCreateForeignKeyConfigurations )
+    internal static void SynchronizeForeignKeyConfigurationFromForeignKeyDescription( Column column, DataGridForeignKeyDescription description,
+                                                                                      bool autoCreateForeignKeyConfigurations )
     {
       if( ( description == null ) || ( column == null ) )
         return;
@@ -522,21 +647,22 @@ namespace Xceed.Wpf.DataGrid
         column.ForeignKeyConfiguration = configuration;
       }
 
-      // ValuePath will be affected to the FieldName when the 
-      // configuration is auto-created to be able to modify 
-      // local source using foreign key value
+      // ValuePath will be affected to the FieldName when the configuration is auto-created to be able to modify local source using foreign key value
       if( configuration.IsAutoCreated )
       {
         if( string.IsNullOrEmpty( configuration.ValuePath ) )
         {
           configuration.ValuePath = description.ValuePath;
         }
+
+        if( string.IsNullOrEmpty( configuration.DisplayMemberPath ) )
+        {
+          configuration.DisplayMemberPath = description.DisplayMemberPath;
+        }
       }
 
-      // Affect the ItemsSource on the configuration if it is not
-      // already set
-      if( ( configuration.ItemsSource == null )
-        && ( description.ItemsSource != null ) )
+      // Affect the ItemsSource on the configuration if it is not already set
+      if( ( configuration.ItemsSource == null ) && ( description.ItemsSource != null ) )
       {
         configuration.ItemsSource = description.ItemsSource;
       }
@@ -548,6 +674,19 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    #region IWeakEventListener Members
+
+    bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      if( ( managerType == typeof( CollectionChangedEventManager ) ) || ( managerType == typeof( ListChangedEventManager ) ) )
+      {
+        this.OnNotifiyCollectionChanged();
+        return true;
+      }
+
+      return false;
+    }
+
     #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyContentControl.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyContentControl.cs
index 15038bda..54bfb21b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyContentControl.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(ForeignKeys)/ForeignKeyContentControl.cs
@@ -28,14 +28,8 @@ namespace Xceed.Wpf.DataGrid
 {
   internal class ForeignKeyContentControl : ContentControl
   {
-    #region Static Members
-
     private static readonly Binding BindingToValue;
 
-    #endregion
-
-    #region Constructors
-
     static ForeignKeyContentControl()
     {
       ForeignKeyContentControl.BindingToValue = new Binding();
@@ -56,8 +50,6 @@ namespace Xceed.Wpf.DataGrid
       this.Focusable = false;
     }
 
-    #endregion
-
     #region ForeignKeyConfiguration Property
 
     public static readonly DependencyProperty ForeignKeyConfigurationProperty = DependencyProperty.Register(
@@ -154,14 +146,12 @@ namespace Xceed.Wpf.DataGrid
 
       if( contentControl != null )
       {
-        contentControl.NotifyKeyChanged();
+        contentControl.NotifyValueChanged();
       }
     }
 
     #endregion
 
-    #region Protected Methods
-
     protected void NotifyKeyChanged()
     {
       if( m_isBeingModified )
@@ -196,10 +186,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion
-
-    #region Private Methods
-
     private void OnKeyChanged()
     {
       ForeignKeyConfiguration configuration = this.ForeignKeyConfiguration;
@@ -220,7 +206,7 @@ namespace Xceed.Wpf.DataGrid
 
       if( ( configuration != null ) && ( configuration.ForeignKeyConverter != null ) )
       {
-        this.Key = configuration.ForeignKeyConverter.GetValueFromKey( this.Value, configuration );
+        this.Key = configuration.ForeignKeyConverter.GetKeyFromValue( this.Value, configuration );
       }
       else
       {
@@ -228,12 +214,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion
-
-    #region Private Fields
-
     private bool m_isBeingModified; // = false;
-
-    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/CustomItemContainerGenerator.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/CustomItemContainerGenerator.cs
index 1203ff67..5b41a61a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/CustomItemContainerGenerator.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/CustomItemContainerGenerator.cs
@@ -19,17 +19,18 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using System.Windows.Data;
-using Xceed.Wpf.DataGrid.Views;
-using System.ComponentModel;
-using Xceed.Wpf.DataGrid.Automation;
-using System.Windows.Media;
+using Xceed.Utils.Collections;
 using Xceed.Utils.Wpf;
-using System.Text;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -40,70 +41,92 @@ namespace Xceed.Wpf.DataGrid
     INotifyPropertyChanged,
     IDataGridContextVisitable
   {
-    internal static CustomItemContainerGenerator CreateGenerator( DataGridControl parentGridControl, CollectionView collectionView, DataGridContext dataGridContext )
-    {
-      CustomItemContainerGenerator newGenerator = new CustomItemContainerGenerator( collectionView, dataGridContext, parentGridControl );
-      dataGridContext.SetGenerator( newGenerator );
+    #region Static Fields
 
-      return newGenerator;
-    }
+    private const int GlobalItemsResetThreshold = 10000;
 
-    private CustomItemContainerGenerator( CollectionView collectionView, DataGridContext dataGridContext, DataGridControl gridControl )
+    #endregion
+
+    internal static CustomItemContainerGenerator CreateGenerator( DataGridControl dataGridControl, CollectionView collectionView, DataGridContext dataGridContext )
     {
+      if( dataGridControl == null )
+        throw new ArgumentNullException( "dataGridControl" );
+
       if( collectionView == null )
-      {
-        throw new ArgumentNullException( "collectionView" );
-      }
+        DataGridException.ThrowSystemException( "collectionView", typeof( ArgumentNullException ), dataGridControl.Name );
 
       if( dataGridContext == null )
-      {
-        throw new ArgumentNullException( "dataGridContext" );
-      }
+        DataGridException.ThrowSystemException( "dataGridContext", typeof( ArgumentNullException ), dataGridControl.Name );
 
-      if( gridControl == null )
-      {
-        throw new ArgumentNullException( "gridControl" );
-      }
+      var log = new Log();
+      log.StartUp();
 
-      m_dataGridControl = gridControl;
-      m_dataGridContext = dataGridContext;
-      m_collectionView = collectionView;
+      var handleGlobalItemsResetFlag = new InheritAutoResetFlag();
+      var deferDetailsRemapFlag = new LeveledAutoResetFlag();
+      var generator = new CustomItemContainerGenerator( dataGridControl, collectionView, dataGridContext, log, handleGlobalItemsResetFlag, deferDetailsRemapFlag );
 
-      IList listInterface = m_collectionView as IList;
-      if( listInterface == null )
-      {
-        listInterface = m_collectionView.SourceCollection as IList;
-      }
-      m_listInterface = listInterface;
+      dataGridContext.SetGenerator( generator );
 
-      //initialize explicitly (set a local value) to the DataItem attached property (for nested DataGridControls)
-      CustomItemContainerGenerator.SetDataItemProperty( m_dataGridControl, CustomItemContainerGenerator.NotSet );
+      return generator;
+    }
 
-      //Notify to the ItemCollection CollectionChanged event.
-      CollectionChangedEventManager.AddListener( m_collectionView, this );
+    private static CustomItemContainerGenerator CreateGenerator( DataGridControl dataGridControl, CollectionView collectionView, DataGridContext dataGridContext, CustomItemContainerGenerator masterGenerator )
+    {
+      if( dataGridControl == null )
+        throw new ArgumentNullException( "dataGridControl" );
 
-      //Notify to the DataGridControl's or DetailConfiguration GroupConfigurationSelector Changed event.
-      GroupConfigurationSelectorChangedEventManager.AddListener( m_dataGridContext, this );
+      if( collectionView == null )
+        DataGridException.ThrowSystemException( "collectionView", typeof( ArgumentNullException ), dataGridControl.Name );
 
-      CollectionChangedEventManager.AddListener( m_dataGridContext.DetailConfigurations, this );
+      if( dataGridContext == null )
+        DataGridException.ThrowSystemException( "dataGridContext", typeof( ArgumentNullException ), dataGridControl.Name );
 
-      // It would have been neat to create a DependencyPropertyChangedEventManager but the 
-      // WeakEventManager was not made to work with DependencyPropertyDescriptor.AddValueChanged.
+      if( masterGenerator == null )
+        DataGridException.ThrowSystemException( "masterGenerator", typeof( ArgumentNullException ), dataGridControl.Name );
 
-      //identifies a Master generator
-      if( m_dataGridContext.SourceDetailConfiguration == null )
-      {
-        ItemsSourceChangeCompletedEventManager.AddListener( m_dataGridControl, this );
-        ViewChangedEventManager.AddListener( m_dataGridControl, this );
-        ThemeChangedEventManager.AddListener( m_dataGridControl, this );
+      var log = masterGenerator.m_log;
+      var handleGlobalItemsResetFlag = new InheritAutoResetFlag( masterGenerator.m_handleGlobalItemsReset );
+      var deferDetailsRemapFlag = masterGenerator.m_deferDetailsRemap.GetChild();
+      var generator = new CustomItemContainerGenerator( dataGridControl, collectionView, dataGridContext, log, handleGlobalItemsResetFlag, deferDetailsRemapFlag );
 
-      }
+      dataGridContext.SetGenerator( generator );
+
+      return generator;
+    }
+
+    private CustomItemContainerGenerator(
+      DataGridControl dataGridControl,
+      CollectionView collectionView,
+      DataGridContext dataGridContext,
+      Log log,
+      InheritAutoResetFlag handleGlobalItemResetFlag,
+      LeveledAutoResetFlag deferDetailsRemapFlag )
+    {
+      Debug.Assert( dataGridControl != null );
+      Debug.Assert( collectionView != null );
+      Debug.Assert( dataGridContext != null );
+      Debug.Assert( log != null );
+      Debug.Assert( handleGlobalItemResetFlag != null );
+      Debug.Assert( deferDetailsRemapFlag != null );
+
+      m_dataGridControl = dataGridControl;
+      m_dataGridContext = dataGridContext;
+      m_collectionView = collectionView;
+      m_log = log;
+      m_handleGlobalItemsReset = handleGlobalItemResetFlag;
+      m_deferDetailsRemap = deferDetailsRemapFlag;
+
+      //initialize explicitly (set a local value) to the DataItem attached property (for nested DataGridControls)
+      CustomItemContainerGenerator.SetDataItemProperty( m_dataGridControl, EmptyDataItemDataProvider.Instance );
+
+      this.RegisterEvents();
 
       m_nodeFactory = new GeneratorNodeFactory( this.OnGeneratorNodeItemsCollectionChanged,
                                                 this.OnGeneratorNodeGroupsCollectionChanged,
                                                 this.OnGeneratorNodeExpansionStateChanged,
                                                 this.OnGroupGeneratorNodeIsExpandedChanging,
-                                                this.OnGroupGeneratorNodeIsExpandedChanged );
+                                                this.OnGroupGeneratorNodeIsExpandedChanged,
+                                                dataGridControl );
 
       m_headerFooterDataContextBinding = new Binding();
       m_headerFooterDataContextBinding.Source = m_dataGridControl;
@@ -114,14 +137,7 @@ namespace Xceed.Wpf.DataGrid
       this.IncrementCurrentGenerationCount();
     }
 
-    internal event CustomGeneratorChangedEventHandler ItemsChanged;
-    internal event ContainersRemovedEventHandler ContainersRemoved;
-
-    public event EventHandler DetailsChanged;
-
-    internal static readonly object NotSet = new object();
-
-    #region CurrentGeneratorContentGeneration Property
+    #region CurrentGeneratorContentGeneration Internal Property
 
     internal int CurrentGeneratorContentGeneration
     {
@@ -131,27 +147,31 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion CurrentGeneratorContentGeneration Property
+    private int m_currentGeneratorContentGeneration; //0
+
+    #endregion
 
-    #region DataItemProperty Attached Property
+    #region DataItemProperty Attached Internal Property
 
     internal static readonly DependencyProperty DataItemPropertyProperty = DependencyProperty.RegisterAttached(
-      "DataItemProperty", typeof( object ), typeof( CustomItemContainerGenerator ),
-      new FrameworkPropertyMetadata( CustomItemContainerGenerator.NotSet, FrameworkPropertyMetadataOptions.Inherits ) );
+      "DataItemProperty",
+      typeof( DataItemDataProviderBase ),
+      typeof( CustomItemContainerGenerator ),
+      new FrameworkPropertyMetadata( EmptyDataItemDataProvider.Instance, FrameworkPropertyMetadataOptions.Inherits ) );
 
-    private static object GetDataItemProperty( DependencyObject obj )
+    internal static DataItemDataProviderBase GetDataItemProperty( DependencyObject obj )
     {
-      return obj.GetValue( CustomItemContainerGenerator.DataItemPropertyProperty );
+      return ( DataItemDataProviderBase )obj.GetValue( CustomItemContainerGenerator.DataItemPropertyProperty );
     }
 
-    private static void SetDataItemProperty( DependencyObject obj, object value )
+    private static void SetDataItemProperty( DependencyObject obj, DataItemDataProviderBase value )
     {
       obj.SetValue( CustomItemContainerGenerator.DataItemPropertyProperty, value );
     }
 
-    #endregion DataItemProperty Attached Property
+    #endregion
 
-    #region IsInUse Property
+    #region IsInUse Internal Property
 
     internal bool IsInUse
     {
@@ -175,7 +195,7 @@ namespace Xceed.Wpf.DataGrid
       this.IsInUse = true;
     }
 
-    #endregion IsInUse Property
+    #endregion
 
     #region Header Property
 
@@ -187,7 +207,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion Header Property
+    private HeadersFootersGeneratorNode m_firstHeader;
+
+    #endregion
 
     #region Footer Property
 
@@ -199,7 +221,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion Footer Property
+    private HeadersFootersGeneratorNode m_firstFooter;
+
+    #endregion
 
     #region RealizedContainers Property
 
@@ -211,7 +235,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion RealizedContainers
+    #endregion
 
     #region RealizedItems Property
 
@@ -223,751 +247,1103 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion RealizedItems
+    #endregion
 
-    #region IsHandlingItemsRecreation Private Property
+    #region Status Property
 
-    private bool IsHandlingItemsRecreation
+    public GeneratorStatus Status
     {
       get
       {
-        return m_flags[ ( int )CustomItemContainerGeneratorFlags.IsHandlingItemsRecreation ];
-      }
-      set
-      {
-        m_flags[ ( int )CustomItemContainerGeneratorFlags.IsHandlingItemsRecreation ] = value;
+        return m_generatorStatus;
       }
     }
 
+    private GeneratorStatus m_generatorStatus = GeneratorStatus.NotStarted;
+
     #endregion
 
-    #region IsEnsuringNodeTreeCreated Private Property
+    #region NodeFactory Private Property
 
-    private bool IsEnsuringNodeTreeCreated
+    private GeneratorNodeFactory NodeFactory
     {
       get
       {
-        return m_flags[ ( int )CustomItemContainerGeneratorFlags.IsEnsuringNodeTreeCreated ];
-      }
-      set
-      {
-        m_flags[ ( int )CustomItemContainerGeneratorFlags.IsEnsuringNodeTreeCreated ] = value;
+        return m_nodeFactory;
       }
     }
 
+    private readonly GeneratorNodeFactory m_nodeFactory;
+
     #endregion
 
-    private GeneratorNodeFactory NodeFactory
+    #region IsDetailsRemapDeferred Private Property
+
+    private bool IsDetailsRemapDeferred
     {
       get
       {
-        return m_nodeFactory;
+        return m_deferDetailsRemap.IsSet;
       }
     }
 
-    public GeneratorStatus Status
+    private IDisposable DeferDetailsRemap()
+    {
+      return m_deferDetailsRemap.Set();
+    }
+
+    private readonly LeveledAutoResetFlag m_deferDetailsRemap;
+
+    #endregion
+
+    #region IsEnsuringNodeTreeCreated Private Property
+
+    private bool IsEnsuringNodeTreeCreated
     {
       get
       {
-        return m_generatorStatus;
+        return m_ensureNodeTreeCreated.IsSet;
       }
     }
 
-    public static FrameworkElement FindContainerFromChildOrRowSelectorOrSelf( DataGridControl dataGridControl, DependencyObject originalChildOrSelf )
+    private IDisposable SetIsEnsuringNodeTreeCreated()
     {
-      if( ( dataGridControl == null ) || ( originalChildOrSelf == null ) )
-        return null;
-
-      DependencyObject childOrSelf = originalChildOrSelf;
-
-      var containerDataGridContext = DataGridControl.GetDataGridContext( childOrSelf );
-      var containerDataGridControl = ( containerDataGridContext == null ) ? null : containerDataGridContext.DataGridControl;
-      var container = childOrSelf as IDataGridItemContainer;
+      return m_ensureNodeTreeCreated.Set();
+    }
 
-      while( ( childOrSelf != null ) &&
-        ( ( container == null ) || ( dataGridControl != containerDataGridControl ) ) )
-      {
-        childOrSelf = TreeHelper.GetParent( childOrSelf );
+    private readonly AutoResetFlag m_ensureNodeTreeCreated = AutoResetFlagFactory.Create();
 
-        container = childOrSelf as IDataGridItemContainer;
+    #endregion
 
-        if( container != null )
-        {
-          // Let's check if the container's parent DataGridControl is itself inside a container.
-          containerDataGridContext = DataGridControl.GetDataGridContext( childOrSelf );
-          containerDataGridControl = ( containerDataGridContext == null ) ? null : containerDataGridContext.DataGridControl;
-        }
-      }
+    #region IsHandlingGlobalItemsReset Private Property
 
-      //This will happen in the case of a RowSelector, this is the way to retreive the row from the selector.
-      if( container == null )
+    private bool IsHandlingGlobalItemsReset
+    {
+      get
       {
-        container = DataGridControl.GetContainer( originalChildOrSelf ) as IDataGridItemContainer;
+        return m_handleGlobalItemsReset.IsSet;
       }
-
-      Debug.Assert( ( container == null ) || ( container is FrameworkElement ), "( container == null ) || ( container is FrameworkElement )" );
-#if LOG
-      Log.Assert( null, ( container == null ) || ( container is FrameworkElement ), "( container == null ) || ( container is FrameworkElement )" );
-#endif
-
-      return container as FrameworkElement;
     }
 
-    public void ResetGeneratorContent()
+    private bool IsHandlingGlobalItemsResetLocally
     {
-      this.CleanupGenerator( false );
-      this.EnsureNodeTreeCreated();
+      get
+      {
+        return m_handleGlobalItemsReset.IsSetLocal;
+      }
     }
 
-    public DependencyObject ContainerFromIndex( int itemIndex )
+    private IDisposable SetIsHandlingGlobalItemsResetLocally()
     {
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
-        return null;
+      m_log.Assert( this, ( m_containersRemovedDeferCount != 0 ) || ( m_deferredContainersRemoved.Count == 0 ), "( m_containersRemovedDeferCount != 0 ) || ( m_deferredContainersRemoved.Count == 0 )" );
 
-      DependencyObject retval = null;
+      return m_handleGlobalItemsReset.SetLocal();
+    }
 
-      this.EnsureNodeTreeCreated();
+    private readonly InheritAutoResetFlag m_handleGlobalItemsReset;
 
-      //retrieve the genenerator index for the index specified
-      int genPos = m_genPosToIndex.IndexOf( itemIndex );
+    #endregion
 
-      //if the generator index is -1, then the item is not realized
-      if( genPos != -1 )
-      {
-        DetailGeneratorNode detailNode = m_genPosToNode[ genPos ] as DetailGeneratorNode;
+    #region DetailsChanged Event
 
-        if( detailNode == null )
-        {
-          //remap the generator index on the container list.
-          retval = m_genPosToContainer[ genPos ];
-        }
-      }
+    public event EventHandler DetailsChanged;
 
-      return retval;
-    }
+    #endregion
 
-    internal DependencyObject ContainerFromItem( object item )
-    {
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
-        return null;
+    #region ItemsChanged Internal Event
 
-      DependencyObject retval = null;
+    internal event CustomGeneratorChangedEventHandler ItemsChanged;
 
-      //retrieve the genenerator index for the item specified
-      int genPos = this.FindFirstGeneratedIndexForLocalItem( item );
+    private void SendRemoveEvent( GeneratorPosition remPos, int oldIndex, int remCount, int generatedRemCount, IList<DependencyObject> removedContainers )
+    {
+      var handler = this.ItemsChanged;
+      if( handler == null )
+        return;
 
-      //if the generator index is -1, then the item is not realized
-      if( genPos != -1 )
+      using( this.DeferDetailsRemap() )
       {
-        retval = m_genPosToContainer[ genPos ];
+        handler.Invoke( this, new CustomGeneratorChangedEventArgs( NotifyCollectionChangedAction.Remove, remPos, oldIndex, remPos, oldIndex, remCount, generatedRemCount, removedContainers ) );
       }
-
-      return retval;
     }
 
-    internal List<object> GetRealizedDataItemsForGroup( GroupGeneratorNode group )
+    private void SendAddEvent( GeneratorPosition genPos, int index, int addCount )
     {
-      int count = m_genPosToNode.Count;
-      List<object> items = new List<object>( count );
+      var handler = this.ItemsChanged;
+      if( handler == null )
+        return;
 
-      for( int i = 0; i < count; i++ )
+      using( this.DeferDetailsRemap() )
       {
-        ItemsGeneratorNode node = m_genPosToNode[ i ] as ItemsGeneratorNode;
-
-        if( ( node != null ) && ( node.Parent == group ) )
-        {
-          items.Add( m_genPosToItem[ i ] );
-        }
+        handler.Invoke( this, new CustomGeneratorChangedEventArgs( NotifyCollectionChangedAction.Add, genPos, index, addCount, 0 ) );
       }
-
-      return items;
     }
 
-    internal List<object> GetRealizedDataItems()
+    private void SendResetEvent()
     {
-      int count = m_genPosToNode.Count;
-      List<object> items = new List<object>( count );
+      var handler = this.ItemsChanged;
+      if( handler == null )
+        return;
 
-      for( int i = 0; i < count; i++ )
+      using( this.DeferDetailsRemap() )
       {
-        ItemsGeneratorNode node = m_genPosToNode[ i ] as ItemsGeneratorNode;
-
-        if( node != null )
-        {
-          items.Add( m_genPosToItem[ i ] );
-        }
+        handler.Invoke( this, new CustomGeneratorChangedEventArgs( NotifyCollectionChangedAction.Reset, new GeneratorPosition(), 0, 0, 0 ) );
       }
-
-      return items;
     }
 
-    [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1822:MarkMembersAsStatic" )]
-    internal object ItemFromContainer( DependencyObject container )
-    {
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
-        return null;
-
-      object retval = null;
+    #endregion
 
-      retval = CustomItemContainerGenerator.GetDataItemProperty( container );
+    #region ContainersRemoved Internal Event
 
-      if( retval == CustomItemContainerGenerator.NotSet )
-        return null;
+    internal event ContainersRemovedEventHandler ContainersRemoved;
 
-      int genPosIndex = m_genPosToContainer.IndexOf( container );
-      if( genPosIndex != -1 )
+    private void NotifyContainersRemoved( IList<DependencyObject> removedContainers )
+    {
+      if( m_containersRemovedDeferCount > 0 )
       {
-        DetailGeneratorNode detailNode = m_genPosToNode[ genPosIndex ] as DetailGeneratorNode;
-        if( detailNode != null )
-          return null;
+        m_deferredContainersRemoved.AddRange( removedContainers );
+      }
+      else if( removedContainers.Count > 0 )
+      {
+        this.NotifyContainersRemoved( new ContainersRemovedEventArgs( removedContainers ) );
       }
-
-      return retval;
     }
 
-    public int IndexFromItem( object item )
+    private void NotifyContainersRemoved( ContainersRemovedEventArgs e )
     {
-      int retval = -1;
-
-      if( item != null )
-      {
-        this.EnsureNodeTreeCreated();
+      if( !this.IsRecyclingEnabled )
+        return;
 
-        if( m_startNode != null )
-        {
-          //if item is generated
-          int generatedIndex = this.FindFirstGeneratedIndexForLocalItem( item );
-          if( generatedIndex != -1 )
-          {
-            retval = m_genPosToIndex[ generatedIndex ];
-          }
-          //if the item is not generated
-          else
-          {
-            GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-            //Note: Under that specific case, I do not want to search through collapsed group nodes... Effectivelly, an item "below" a collapsed group node 
-            // Have no index as per the "item to index" interface of the generator. 
-            retval = nodeHelper.FindItem( item );
-          }
-        }
-      }
+      var handler = this.ContainersRemoved;
+      if( handler == null )
+        return;
 
-      return retval;
+      handler.Invoke( this, e );
     }
 
-    public object ItemFromIndex( int index )
-    {
-      object retval = null;
+    #endregion
 
-      this.EnsureNodeTreeCreated();
+    #region Logging Methods
 
-      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+    [Conditional( "CUSTOMLOG" )]
+    internal void ResetLog( string gridUniqueName )
+    {
+      m_log.StartUp( gridUniqueName );
+    }
 
-      retval = nodeHelper.FindIndex( index );
+    [Conditional( "LOG" )]
+    private void LogState()
+    {
+      StringBuilder sb = new StringBuilder( 1024 );
+      this.LogState( sb );
 
-      return retval;
+      m_log.WriteLine( this, sb.ToString() );
     }
 
-    public int GetGroupIndex( Group group )
+    [Conditional( "LOG" )]
+    private void LogState( StringBuilder sb )
     {
-      if( group == null )
-        throw new ArgumentNullException( "group" );
+      var parent = m_dataGridContext.ParentDataGridContext;
+      if( parent != null )
+      {
+        parent.CustomItemContainerGenerator.LogState( sb );
+      }
 
-      this.EnsureNodeTreeCreated();
+      sb.Append( "Generator state : " );
+      if( parent == null )
+      {
+        sb.AppendLine( "MASTER" );
+      }
+      else
+      {
+        sb.AppendLine( CustomItemContainerGenerator.FormatObjectId( "DETAIL - D", m_dataGridContext.ParentItem ) );
+      }
 
-      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-
-      if( nodeHelper.FindGroup( group.CollectionViewGroup ) )
-        return nodeHelper.Index;
-
-      //the item was not found in this generator's content... check all the detail generators
-      foreach( KeyValuePair<object, List<DetailGeneratorNode>> itemToDetails in m_masterToDetails )
+      sb.AppendLine( string.Empty );
+      sb.AppendLine( " m_genPosToContainer :" );
+      for( int i = 0; i < m_genPosToContainer.Count; i++ )
       {
-        foreach( DetailGeneratorNode detailNode in itemToDetails.Value )
-        {
-          int groupIndex = detailNode.DetailGenerator.GetGroupIndex( group );
+        object value = m_genPosToContainer[ i ];
 
-          if( groupIndex > -1 )
-            return groupIndex + this.FindGlobalIndexForDetailNode( detailNode );
+        if( value == null )
+        {
+          sb.AppendLine( "  [ " + i.ToString() + " ] - null" );
+        }
+        else
+        {
+          sb.AppendLine( "  [ " + i.ToString() + " ] - " + value.GetHashCode() );
         }
       }
 
-      return -1;
-    }
-
-    public Group GetGroupFromItem( object item )
-    {
-      Group retval = null;
-
-      GeneratorNode nodeForItem = null;
+      sb.AppendLine( " m_genPosToIndex :" );
+      for( int i = 0; i < m_genPosToIndex.Count; i++ )
+      {
+        object value = m_genPosToIndex[ i ];
 
-      this.EnsureNodeTreeCreated();
+        if( value == null )
+        {
+          sb.AppendLine( "  [ " + i.ToString() + " ] - null" );
+        }
+        else
+        {
+          sb.AppendLine( "  [ " + i.ToString() + " ] - " + value.ToString() );
+        }
+      }
 
-      //item might be in the "generated" list... much quicker to find-out if it is!
-      int itemGenPosIndex = this.FindFirstGeneratedIndexForLocalItem( item );
-      if( itemGenPosIndex != -1 )
+      sb.AppendLine( " m_genPosToItem :" );
+      for( int i = 0; i < m_genPosToItem.Count; i++ )
       {
-        //item is generated...
-        nodeForItem = m_genPosToNode[ itemGenPosIndex ];
+        object value = m_genPosToItem[ i ];
+
+        if( value == null )
+        {
+          sb.AppendLine( "  [ " + i.ToString() + " ] - null" );
+        }
+        else
+        {
+          sb.AppendLine( "  [ " + i.ToString() + " ] - D" + value.GetHashCode() );
+        }
       }
-      else
+
+      sb.AppendLine( " m_genPosToNode :" );
+      for( int i = 0; i < m_genPosToNode.Count; i++ )
       {
-        //only try to find the item is the generator has some content...
-        if( m_startNode != null )
+        object value = m_genPosToNode[ i ];
+
+        if( value == null )
         {
-          GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-          if( nodeHelper.Contains( item ) ) //NOTE: this will only return items directly contained in this generator (not from details )
+          sb.AppendLine( "  [ " + i.ToString() + " ] - null" );
+        }
+        else
+        {
+          string prefix;
+
+          if( value is DetailGeneratorNode )
           {
-            //if the nodeHelper was able to locate the content, use the nodeHelper's CurrentNode as the node for the item.
-            nodeForItem = nodeHelper.CurrentNode;
+            prefix = "DN";
+          }
+          else if( value is ItemsGeneratorNode )
+          {
+            prefix = "IN";
+          }
+          else if( value is CollectionGeneratorNode )
+          {
+            prefix = "CN";
           }
           else
           {
-            throw new InvalidOperationException( "An attempt was made to retrieve the group of an item that does not belong to the generator." );
+            prefix = "?N";
           }
+
+          int itemCount = ( value is GeneratorNode ) ? ( ( GeneratorNode )value ).ItemCount : 0;
+
+          sb.AppendLine( "  [ " + i.ToString() + " ] - " + prefix + value.GetHashCode() + " - ItemCount : " + itemCount );
         }
       }
 
-      if( nodeForItem != null )
+      sb.AppendLine( " m_generatorDirection :" + m_generatorDirection.ToString() );
+      sb.AppendLine( CustomItemContainerGenerator.FormatObjectId( " m_generatorCurrentDetail : DN", m_generatorCurrentDetail ) );
+      sb.AppendLine( " m_generatorCurrentDetailIndex : " + m_generatorCurrentDetailIndex.ToString() );
+      sb.AppendLine( " m_generatorCurrentDetailNodeIndex : " + m_generatorCurrentDetailNodeIndex.ToString() );
+      sb.AppendLine( " m_generatorCurrentGlobalIndex : " + m_generatorCurrentGlobalIndex.ToString() );
+      sb.AppendLine( " m_generatorCurrentOffset : " + m_generatorCurrentOffset.ToString() );
+      sb.AppendLine( " m_generatorStatus : " + m_generatorStatus.ToString() );
+      sb.AppendLine( " m_genPosToIndexUpdateInhibitCount : " + m_genPosToIndexUpdateInhibitCount.ToString() );
+      sb.AppendLine( " IsEnsuringNodeTreeCreated : " + this.IsEnsuringNodeTreeCreated.ToString() );
+      sb.AppendLine( " IsHandlingGlobalItemsReset : " + this.IsHandlingGlobalItemsReset.ToString() );
+      sb.AppendLine( " IsDetailsRemapDeferred : " + this.IsDetailsRemapDeferred.ToString() );
+
+      int newItemCount = m_cachedItemCount;
+      if( m_lastValidItemCountGeneration != m_currentGeneratorContentGeneration )
       {
-        GroupGeneratorNode parentGroup = nodeForItem.Parent as GroupGeneratorNode;
-        if( parentGroup != null )
+        if( m_startNode != null )
         {
-          retval = parentGroup.UIGroup;
+          int chainLength;
+          GeneratorNodeHelper.EvaluateChain( m_startNode, out newItemCount, out chainLength );
+        }
+        else
+        {
+          newItemCount = 0;
         }
       }
 
-      return retval;
-    }
+      sb.Append( " m_cachedItemCount : " + m_cachedItemCount.ToString() );
+      if( newItemCount != m_cachedItemCount )
+      {
+        sb.Append( " (needs refresh) - ItemCount : " + newItemCount.ToString() );
+      }
+      sb.AppendLine( string.Empty );
 
-    public Group GetGroupFromCollectionViewGroup( CollectionViewGroup collectionViewGroup )
-    {
-      return this.GetGroupFromCollectionViewGroup( null, collectionViewGroup );
+      sb.AppendLine( string.Empty );
     }
 
-    public Group GetGroupFromCollectionViewGroup( Group parentUIGroup, CollectionViewGroup collectionViewGroup )
+    [Conditional( "LOG" )]
+    private void ValidateIndexOrder( string message )
     {
-      this.EnsureNodeTreeCreated();
-      GroupGeneratorNode groupGeneratorNode = null;
+      int count = m_genPosToIndex.Count;
+      int previousIndex = -1;
 
-      if( m_groupNodeMappingCache.TryGetValue( collectionViewGroup, out groupGeneratorNode ) )
-        return groupGeneratorNode.UIGroup;
+      for( int i = 0; i < count; i++ )
+      {
+        int tempIndex = m_genPosToIndex[ i ];
 
-      return null;
-    }
+        if( tempIndex <= previousIndex )
+        {
+          this.LogState();
 
-    public CollectionViewGroup GetParentGroupFromItem( object item, bool recurseDetails )
-    {
-      if( item == null )
-        throw new ArgumentNullException( "item" );
+          if( string.IsNullOrEmpty( message ) )
+          {
+            m_log.Fail( this, "### none sequential index detected." );
+          }
+          else
+          {
+            m_log.Fail( this, "### none sequential index detected. " + message );
+          }
 
-      CollectionViewGroup collectionViewGroup = null;
+          break;
+        }
 
-      if( !this.TryGetParentGroupFromItem( item, recurseDetails, out collectionViewGroup ) )
-      {
-        throw new InvalidOperationException( "An attempt was made to retrieve the parent group of an item that does not belong to the generator." );
+        previousIndex = tempIndex;
       }
-
-      return collectionViewGroup;
     }
 
-    public bool TryGetParentGroupFromItem( object item, bool recurseDetails, out CollectionViewGroup collectionViewGroup )
+    [Conditional( "DEBUG" ), Conditional( "LOG" )]
+    private void CheckMasterItem( object dataItem )
     {
-      collectionViewGroup = null;
+      if( m_masterToDetails.ContainsKey( dataItem ) )
+        return;
 
-      if( item == null )
-        return false;
+      m_log.Fail( this, "m_masterToDetails do not contains the item from m_floatingDetails." );
+    }
 
-      this.EnsureNodeTreeCreated();
+    private static string FormatObjectId( string message, object item )
+    {
+      string id = ( item == null ) ? "null" : item.GetHashCode().ToString();
 
-      if( m_startNode == null )
-        throw new DataGridInternalException();
+      if( string.IsNullOrEmpty( message ) )
+        return id;
 
-      //Invoke the helper that will check for the parent group within the local generator.
-      if( this.TryGetParentGroupFromItemHelper( item, out collectionViewGroup ) )
-      {
-        //if the item was found within the local generator, then return.
-        return true;
-      }
-      //If the item was not in the local generator, continue with method.
+      return message + id;
+    }
 
-      if( recurseDetails )
-      {
-        //the item was not found in this generator's content... check all the detail generators
-        foreach( KeyValuePair<object, List<DetailGeneratorNode>> itemToDetails in m_masterToDetails )
-        {
-          foreach( DetailGeneratorNode detail in itemToDetails.Value )
-          {
-            if( detail.DetailGenerator.TryGetParentGroupFromItem( item, recurseDetails, out collectionViewGroup ) )
-            {
-              return true;
-            }
-          }
-        }
-      }
+    private readonly Log m_log;
 
-      return false;
-    }
+    #endregion
 
-    private bool TryGetParentGroupFromItemHelper( object item, out CollectionViewGroup collectionViewGroup )
+    public static T FindContainerFromChild<T>( DataGridControl dataGridControl, DependencyObject element ) where T : DependencyObject, IDataGridItemContainer
     {
-      //This helper method is used to simplify previous code flow of the TryGetParentGroupFromItem method.
-      collectionViewGroup = null;
+      if( ( dataGridControl == null ) || ( element == null ) )
+        return null;
 
-      //-----------------------------------------------
-      //1 - First check is to see of the item is a CVG.
-      //-----------------------------------------------
-      CollectionViewGroup groupItem = item as CollectionViewGroup;
-      if( groupItem != null )
+      T container = null;
+
+      while( element != null )
       {
-        Group group = this.GetGroupFromCollectionViewGroup( groupItem );
-        if( group != null )
+        var currentDataGridContext = DataGridControl.GetDataGridContext( element );
+        var currentDataGridControl = ( currentDataGridContext == null ) ? null : currentDataGridContext.DataGridControl;
+
+        // We are only interested in containers that are part of the same grid.
+        if( currentDataGridControl == dataGridControl )
         {
-          GroupGeneratorNode groupGeneratorNode = group.GeneratorNode;
-          if( groupGeneratorNode.Parent == null )
-          {
-            //no parent for speficied item.
-            return true;
-          }
-          //if the nodeHelper was able to locate the content, use the nodeHelper's CurrentNode as the node for the item.
-          collectionViewGroup = ( ( GroupGeneratorNode )groupGeneratorNode.Parent ).CollectionViewGroup;
-          return true;
+          container = element as T;
+
+          // We have found the container;
+          if( container != null )
+            break;
         }
 
-        //item is a CVG, but is not present in the generator!
-        return false;
+        // Since the element is the grid itself, we already know we will not find a suitable container beyond this point.
+        if( element == dataGridControl )
+          break;
+
+        element = TreeHelper.GetParent( element );
       }
 
-      //-----------------------------------------------
-      //2 - Second check is to see if the item is already in the generated list
-      //-----------------------------------------------
+      return container;
+    }
 
-      //item might be in the "generated" list... much quicker to find-out if it is!
-      //note: if the item belongs to a detail, then it will be excluded from the "fast" algo.
-      int itemGenPosIndex = this.FindFirstGeneratedIndexForLocalItem( item );
-      if( itemGenPosIndex != -1 )
-      {
-        //item was generated and was not from a DetailGeneratorNode
-        if( m_genPosToNode[ itemGenPosIndex ].Parent == null )
-        {
-          //no parent for speficied item.
-          return true;
-        }
-        collectionViewGroup = ( ( GroupGeneratorNode )m_genPosToNode[ itemGenPosIndex ].Parent ).CollectionViewGroup;
-        return true;
-      }
+    public static FrameworkElement FindContainerFromChildOrRowSelectorOrSelf( DataGridControl dataGridControl, DependencyObject originalChildOrSelf )
+    {
+      if( ( dataGridControl == null ) || ( originalChildOrSelf == null ) )
+        return null;
 
-      //-----------------------------------------------
-      //3 - Third check is to check of the item is a GroupHeaderFooterItem
-      //-----------------------------------------------
-      if( item.GetType() == typeof( GroupHeaderFooterItem ) )
+      DependencyObject childOrSelf = originalChildOrSelf;
+      IDataGridItemContainer container = null;
+
+      while( childOrSelf != null )
       {
-        GroupHeaderFooterItem groupHeaderFooterItem = ( GroupHeaderFooterItem )item;
-        CollectionViewGroup parentGroup = groupHeaderFooterItem.Group;
+        var currentDataGridContext = DataGridControl.GetDataGridContext( childOrSelf );
+        var currentDataGridControl = ( currentDataGridContext == null ) ? null : currentDataGridContext.DataGridControl;
 
-        if( this.GetGroupFromCollectionViewGroup( parentGroup ) != null )
+        // We are only interested in containers that are part of the same grid.
+        if( currentDataGridControl == dataGridControl )
         {
-          //since the goal is the find the parentGroup from the item passed (which is a GroupHeader or GroupFooter), then the Group
-          //is what I am looking for.
-          collectionViewGroup = parentGroup;
+          container = childOrSelf as IDataGridItemContainer;
 
-          return true;
+          // We have found the container;
+          if( container != null )
+            break;
         }
 
-        //Item was a GroupHeaderFooterItem but was not part of the genreator!
-        return false;
-      }
+        // Since the element is the grid itself, we already know we will not find a suitable container beyond this point.
+        if( childOrSelf == dataGridControl )
+          break;
 
-      //-----------------------------------------------
-      //4 - Final Check
-      //-----------------------------------------------
+        childOrSelf = TreeHelper.GetParent( childOrSelf );
+      }
 
-      //if the item was not generated, then try to find the item as is within the generator's content  
-      GeneratorNodeHelper finalNodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-      if( finalNodeHelper.AbsoluteFindItem( item ) )
+      // RowSelector are handled differently.
+      if( container == null )
       {
-        //item was not generated but was part of this generator
-        if( finalNodeHelper.CurrentNode.Parent == null )
+        var target = DataGridControl.GetContainer( originalChildOrSelf );
+
+        if( TreeHelper.IsDescendantOf( target, dataGridControl ) )
         {
-          //no parent for speficied item.
-          return true;
+          container = target as IDataGridItemContainer;
         }
-        collectionViewGroup = ( ( GroupGeneratorNode )finalNodeHelper.CurrentNode.Parent ).CollectionViewGroup;
-        return true;
-      }
-      else
-      {
-        return false;
       }
 
-      //Default function behavior, if nobody else returned, then the function did not work as intended... as each "block" is supposed to return a value...
-      throw new DataGridInternalException();
+      dataGridControl.CustomItemContainerGenerator.m_log.Assert( ( container == null ) || ( container is FrameworkElement ),
+                                                                "( container == null ) || ( container is FrameworkElement )" );
+
+      return container as FrameworkElement;
     }
 
-    public bool ExpandGroup( CollectionViewGroup group )
+    public void ResetGeneratorContent()
     {
-      bool groupExpanded = this.ExpandGroupCore( group, false );
-
-      if( !groupExpanded )
-        throw new InvalidOperationException( "An attempt was made to expand a group that does not exist." );
-
-      return groupExpanded;
+      this.CleanupGenerator();
+      this.EnsureNodeTreeCreated();
     }
 
-    internal bool ExpandGroupCore( CollectionViewGroup group, bool recurseDetails )
+    public DependencyObject ContainerFromIndex( int itemIndex )
     {
-      if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "An attempt was made to expand a group while the generator is busy generating items." );
-      }
+      if( this.IsHandlingGlobalItemsReset )
+        return null;
 
-      if( group == null )
-        throw new ArgumentNullException( "group" );
+      DependencyObject retval = null;
 
       this.EnsureNodeTreeCreated();
 
-      if( m_firstItem == null )
-        throw new DataGridInternalException();
+      //retrieve the genenerator index for the index specified
+      int genPos = m_genPosToIndex.IndexOf( itemIndex );
 
-      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
-      if( uiGroup != null )
+      //if the generator index is -1, then the item is not realized
+      if( genPos != -1 )
       {
-        uiGroup.GeneratorNode.IsExpanded = true;
-        return true;
-      }
+        DetailGeneratorNode detailNode = m_genPosToNode[ genPos ] as DetailGeneratorNode;
 
-      if( recurseDetails )
-      {
-        //the item was not found in this generator's content... check all the detail generators
-        foreach( KeyValuePair<object, List<DetailGeneratorNode>> itemToDetails in m_masterToDetails )
+        if( detailNode == null )
         {
-          foreach( DetailGeneratorNode detail in itemToDetails.Value )
-          {
-            // If the item is not found in the detail generator, it will return false;
-            // The "public" function call will throw if item is never found in itself or its details.
-            if( detail.DetailGenerator.ExpandGroupCore( group, recurseDetails ) )
-              return true;
-          }
+          //remap the generator index on the container list.
+          retval = m_genPosToContainer[ genPos ];
         }
       }
 
-      return false;
+      return retval;
     }
 
-    public bool CollapseGroup( CollectionViewGroup group )
+    internal DependencyObject ContainerFromItem( object item )
     {
-      bool groupCollapsed = this.CollapseGroupCore( group, false );
+      if( this.IsHandlingGlobalItemsReset )
+        return null;
 
-      if( !groupCollapsed )
-        throw new InvalidOperationException( "An attempt was made to collapse a group that does not exist." );
+      DependencyObject retval = null;
 
-      return groupCollapsed;
-    }
+      //retrieve the genenerator index for the item specified
+      int genPos = this.FindFirstGeneratedIndexForLocalItem( item );
 
-    internal bool CollapseGroupCore( CollectionViewGroup group, bool recurseDetails )
-    {
-      if( this.Status == GeneratorStatus.GeneratingContainers )
+      //if the generator index is -1, then the item is not realized
+      if( genPos != -1 )
       {
-        throw new InvalidOperationException( "An attempt was made to collapse a group while the generator is busy generating items." );
+        retval = m_genPosToContainer[ genPos ];
       }
 
-      if( group == null )
-        throw new ArgumentNullException( "group" );
-
-      this.EnsureNodeTreeCreated();
+      return retval;
+    }
 
-      if( m_firstItem == null )
-        throw new DataGridInternalException();
+    internal List<object> GetRealizedDataItemsForGroup( GroupGeneratorNode group )
+    {
+      int count = m_genPosToNode.Count;
+      List<object> items = new List<object>( count );
 
-      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
-      if( uiGroup != null )
+      for( int i = 0; i < count; i++ )
       {
-        uiGroup.GeneratorNode.IsExpanded = false;
-        return true;
-      }
+        ItemsGeneratorNode node = m_genPosToNode[ i ] as ItemsGeneratorNode;
 
-      if( recurseDetails )
-      {
-        //the item was not found in this generator's content... check all the detail generators
-        foreach( KeyValuePair<object, List<DetailGeneratorNode>> itemToDetails in m_masterToDetails )
+        if( ( node != null ) && ( node.Parent == group ) )
         {
-          foreach( DetailGeneratorNode detail in itemToDetails.Value )
-          {
-            // If the item is not found in the detail generator, it will return false;
-            // The "public" function call will throw if item is never found in itself or its details.
-            if( detail.DetailGenerator.CollapseGroupCore( group, recurseDetails ) )
-              return true;
-          }
+          items.Add( m_genPosToItem[ i ] );
         }
       }
 
-      return false;
+      return items;
     }
 
-    public bool ToggleGroupExpansion( CollectionViewGroup group )
+    internal List<object> GetRealizedDataItems()
     {
-      bool groupToggled = this.ToggleGroupExpansionCore( group, false );
+      int count = m_genPosToNode.Count;
+      List<object> items = new List<object>( count );
 
-      if( !groupToggled )
-        throw new InvalidOperationException( "An attempt was made to toggle a group that does not exist." );
+      for( int i = 0; i < count; i++ )
+      {
+        ItemsGeneratorNode node = m_genPosToNode[ i ] as ItemsGeneratorNode;
 
-      return groupToggled;
+        if( node != null )
+        {
+          items.Add( m_genPosToItem[ i ] );
+        }
+      }
+
+      return items;
     }
 
-    internal bool ToggleGroupExpansionCore( CollectionViewGroup group, bool recurseDetails )
+    [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1822:MarkMembersAsStatic" )]
+    internal object ItemFromContainer( DependencyObject container )
     {
-      if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "An attempt was made to a toggle a group's expansion while the generator is busy generating items." );
-      }
-
-      if( group == null )
-        throw new ArgumentNullException( "group" );
+      if( this.IsHandlingGlobalItemsReset )
+        return null;
 
-      this.EnsureNodeTreeCreated();
+      var dataItemStore = CustomItemContainerGenerator.GetDataItemProperty( container );
+      if( ( dataItemStore == null ) || dataItemStore.IsEmpty )
+        return null;
 
-      if( m_firstItem == null )
-        throw new DataGridInternalException();
+      var dataItem = dataItemStore.Data;
+      var genPosIndex = m_genPosToContainer.IndexOf( container );
 
-      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
-      if( uiGroup != null )
+      if( genPosIndex != -1 )
       {
-        GroupGeneratorNode groupNode = uiGroup.GeneratorNode;
-        groupNode.IsExpanded = !groupNode.IsExpanded;
-        return true;
+        DetailGeneratorNode detailNode = m_genPosToNode[ genPosIndex ] as DetailGeneratorNode;
+        if( detailNode != null )
+          return null;
       }
 
-      if( recurseDetails )
+      return dataItem;
+    }
+
+    public int IndexFromItem( object item )
+    {
+      int retval = -1;
+
+      if( item != null )
       {
-        //the item was not found in this generator's content... check all the detail generators
-        foreach( KeyValuePair<object, List<DetailGeneratorNode>> itemToDetails in m_masterToDetails )
+        this.EnsureNodeTreeCreated();
+
+        if( m_startNode != null )
         {
-          foreach( DetailGeneratorNode detail in itemToDetails.Value )
+          //if item is generated
+          int generatedIndex = this.FindFirstGeneratedIndexForLocalItem( item );
+          if( generatedIndex != -1 )
           {
-            try
-            {
-              return detail.DetailGenerator.ToggleGroupExpansionCore( group, recurseDetails );
-            }
-            catch( InvalidOperationException )
-            {
-              //if the item is not found in the detail generator, it will throw 
-              //an invalid operation exception. If it doesn't throw, then it is 
-              //safe to return the return value of the function.
-
-              //otherwise, suppress this exception as ultimately, the "root" function call will 
-              //throw if item is never found in itself or its details.
-            }
+            retval = m_genPosToIndex[ generatedIndex ];
+          }
+          //if the item is not generated
+          else
+          {
+            GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+            //Note: Under that specific case, I do not want to search through collapsed group nodes... Effectivelly, an item "below" a collapsed group node 
+            // Have no index as per the "item to index" interface of the generator. 
+            retval = nodeHelper.FindItem( item );
           }
         }
       }
 
-      return false;
+      return retval;
     }
 
-    public bool IsGroupExpanded( CollectionViewGroup group )
+    public object ItemFromIndex( int index )
     {
-      return this.IsGroupExpandedCore( group, false );
+      object retval = null;
+
+      this.EnsureNodeTreeCreated();
+
+      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+
+      retval = nodeHelper.FindIndex( index );
+
+      return retval;
     }
 
-    internal bool IsGroupExpandedCore( CollectionViewGroup group, bool recurseDetails )
+    public int GetGroupIndex( Group group )
     {
       if( group == null )
-        throw new ArgumentNullException( "group" );
+        DataGridException.ThrowSystemException( "group", typeof( ArgumentNullException ), m_dataGridControl.Name );
 
       this.EnsureNodeTreeCreated();
 
-      if( m_firstItem == null )
-        throw new DataGridInternalException();
+      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
 
-      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
-      if( uiGroup != null )
+      if( nodeHelper.FindGroup( group.CollectionViewGroup ) )
+        return nodeHelper.Index;
+
+      //the item was not found in this generator's content... check all the detail generators
+      foreach( var detailNode in this.GetDetailGeneratorNodes() )
       {
-        return uiGroup.GeneratorNode.IsExpanded;
+        int groupIndex = detailNode.DetailGenerator.GetGroupIndex( group );
+
+        if( groupIndex > -1 )
+          return groupIndex + this.FindGlobalIndexForDetailNode( detailNode );
       }
 
-      if( recurseDetails )
+      return -1;
+    }
+
+    public Group GetGroupFromItem( object item )
+    {
+      Group retval = null;
+
+      GeneratorNode nodeForItem = null;
+
+      this.EnsureNodeTreeCreated();
+
+      //item might be in the "generated" list... much quicker to find-out if it is!
+      int itemGenPosIndex = this.FindFirstGeneratedIndexForLocalItem( item );
+      if( itemGenPosIndex != -1 )
       {
-        //the group was not found in this generator, check in all the child generators for the group.
-        foreach( KeyValuePair<object, List<DetailGeneratorNode>> itemToDetails in m_masterToDetails )
+        //item is generated...
+        nodeForItem = m_genPosToNode[ itemGenPosIndex ];
+      }
+      else
+      {
+        //only try to find the item is the generator has some content...
+        if( m_startNode != null )
         {
-          foreach( DetailGeneratorNode detail in itemToDetails.Value )
+          GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+          if( nodeHelper.Contains( item ) ) //NOTE: this will only return items directly contained in this generator (not from details )
           {
-            try
-            {
-              return detail.DetailGenerator.IsGroupExpandedCore( group, recurseDetails );
-            }
-            catch( InvalidOperationException )
-            {
-              //if the item is not found in the detail generator, it will throw 
-              //an invalid operation exception. If it doesn't throw, then it is 
-              //safe to return the return value of the function.
-
-              //otherwise, suppress this exception as ultimately, the "root" function call will 
-              //throw if item is never found in itself or its details.
-            }
+            //if the nodeHelper was able to locate the content, use the nodeHelper's CurrentNode as the node for the item.
+            nodeForItem = nodeHelper.CurrentNode;
+          }
+          else
+          {
+            DataGridException.ThrowSystemException( "An attempt was made to retrieve the group of an item that does not belong to the generator.",
+                                                    typeof( InvalidOperationException ), m_dataGridControl.Name );
           }
         }
       }
 
-      throw new InvalidOperationException( "An attempt was made to consult the expansion state of a group that does not exist." );
-    }
+      if( nodeForItem != null )
+      {
+        GroupGeneratorNode parentGroup = nodeForItem.Parent as GroupGeneratorNode;
+        if( parentGroup != null )
+        {
+          retval = parentGroup.UIGroup;
+        }
+      }
 
-    internal void ExpandDetails( object dataItem )
-    {
+      return retval;
     }
 
-    internal void CollapseDetails( object dataItem )
+    public Group GetGroupFromCollectionViewGroup( CollectionViewGroup collectionViewGroup )
     {
+      return this.GetGroupFromCollectionViewGroup( null, collectionViewGroup );
     }
 
-    internal void ToggleDetails( object dataItem )
+    public Group GetGroupFromCollectionViewGroup( Group parentUIGroup, CollectionViewGroup collectionViewGroup )
     {
-    }
+      this.EnsureNodeTreeCreated();
+      GroupGeneratorNode groupGeneratorNode = null;
 
-    internal bool AreDetailsExpanded( object dataItem )
-    {
-      if( dataItem == null )
-        throw new ArgumentNullException( "dataItem" );
+      if( m_groupNodeMappingCache.TryGetValue( collectionViewGroup, out groupGeneratorNode ) )
+        return groupGeneratorNode.UIGroup;
 
-      return m_masterToDetails.ContainsKey( dataItem );
+      return null;
     }
 
-    public void RemoveAllAndNotify()
+    public CollectionViewGroup GetParentGroupFromItem( object item, bool recurseDetails )
     {
-      if( m_startNode == null )
-        return; //nothing to do, the generator is already in a "clean" state.
-
-      //this message is issued by the DataGridContext when the VisibleColumns collection changes (re-ordering or changes to its content).
-      IList<DependencyObject> removedContainers = new List<DependencyObject>();
-      this.RemoveGeneratedItems( int.MinValue, int.MaxValue, removedContainers );
-
-      this.SendResetEvent();
+      if( item == null )
+        DataGridException.ThrowSystemException( "item", typeof( ArgumentNullException ), m_dataGridControl.Name );
 
-      removedContainers.Clear();
-      removedContainers = null;
+      CollectionViewGroup collectionViewGroup = null;
 
-      removedContainers = m_dataGridContext.RecyclingManager.Clear();
+      if( !this.TryGetParentGroupFromItem( item, recurseDetails, out collectionViewGroup ) )
+        DataGridException.ThrowSystemException( "An attempt was made to retrieve the parent group of an item that does not belong to the generator.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
-      if( removedContainers.Count > 0 )
-      {
-        this.NotifyContainersRemoved( removedContainers );
-      }
+      return collectionViewGroup;
     }
 
-    internal int FindIndexForItem( object item, DataGridContext dataGridContext )
+    public bool TryGetParentGroupFromItem( object item, bool recurseDetails, out CollectionViewGroup collectionViewGroup )
     {
-      int retval = -1;
-      bool recurse = false;
+      collectionViewGroup = null;
+
+      if( item == null )
+        return false;
 
       this.EnsureNodeTreeCreated();
 
-      // If the seeked DataGridContext is this generator's context, the item should be here.
-      // When the seeked DataGridContext is null, search for the first item match no matter the generator's context.
-      if( ( m_dataGridContext == dataGridContext ) || ( dataGridContext == null ) )
-      {
-        retval = this.IndexFromItem( item );
+      if( m_startNode == null )
+        throw new DataGridInternalException( "Start node is null for the CollectionViewGroup.", m_dataGridControl );
 
-        // If the item wasn't found in this generator's context and that we don't have a precise target context, recurse.
+      //Invoke the helper that will check for the parent group within the local generator.
+      if( this.TryGetParentGroupFromItemHelper( item, out collectionViewGroup ) )
+      {
+        //if the item was found within the local generator, then return.
+        return true;
+      }
+      //If the item was not in the local generator, continue with method.
+
+      if( recurseDetails )
+      {
+        //the item was not found in this generator's content... check all the detail generators
+        foreach( var generator in this.GetDetailGenerators() )
+        {
+          if( generator.TryGetParentGroupFromItem( item, recurseDetails, out collectionViewGroup ) )
+            return true;
+        }
+      }
+
+      return false;
+    }
+
+    private bool TryGetParentGroupFromItemHelper( object item, out CollectionViewGroup collectionViewGroup )
+    {
+      //This helper method is used to simplify previous code flow of the TryGetParentGroupFromItem method.
+      collectionViewGroup = null;
+
+      //-----------------------------------------------
+      //1 - First check is to see of the item is a CVG.
+      //-----------------------------------------------
+      CollectionViewGroup groupItem = item as CollectionViewGroup;
+      if( groupItem != null )
+      {
+        Group group = this.GetGroupFromCollectionViewGroup( groupItem );
+        if( group != null )
+        {
+          GroupGeneratorNode groupGeneratorNode = group.GeneratorNode;
+          if( groupGeneratorNode.Parent == null )
+          {
+            //no parent for speficied item.
+            return true;
+          }
+          //if the nodeHelper was able to locate the content, use the nodeHelper's CurrentNode as the node for the item.
+          collectionViewGroup = ( ( GroupGeneratorNode )groupGeneratorNode.Parent ).CollectionViewGroup;
+          return true;
+        }
+
+        //item is a CVG, but is not present in the generator!
+        return false;
+      }
+
+      //-----------------------------------------------
+      //2 - Second check is to see if the item is already in the generated list
+      //-----------------------------------------------
+
+      //item might be in the "generated" list... much quicker to find-out if it is!
+      //note: if the item belongs to a detail, then it will be excluded from the "fast" algo.
+      int itemGenPosIndex = this.FindFirstGeneratedIndexForLocalItem( item );
+      if( itemGenPosIndex != -1 )
+      {
+        //item was generated and was not from a DetailGeneratorNode
+        if( m_genPosToNode[ itemGenPosIndex ].Parent == null )
+        {
+          //no parent for speficied item.
+          return true;
+        }
+        collectionViewGroup = ( ( GroupGeneratorNode )m_genPosToNode[ itemGenPosIndex ].Parent ).CollectionViewGroup;
+        return true;
+      }
+
+      //-----------------------------------------------
+      //3 - Third check is to check of the item is a GroupHeaderFooterItem
+      //-----------------------------------------------
+      if( item.GetType() == typeof( GroupHeaderFooterItem ) )
+      {
+        GroupHeaderFooterItem groupHeaderFooterItem = ( GroupHeaderFooterItem )item;
+        CollectionViewGroup parentGroup = groupHeaderFooterItem.Group;
+
+        if( this.GetGroupFromCollectionViewGroup( parentGroup ) != null )
+        {
+          //since the goal is the find the parentGroup from the item passed (which is a GroupHeader or GroupFooter), then the Group
+          //is what I am looking for.
+          collectionViewGroup = parentGroup;
+
+          return true;
+        }
+
+        //Item was a GroupHeaderFooterItem but was not part of the genreator!
+        return false;
+      }
+
+      //-----------------------------------------------
+      //4 - Final Check
+      //-----------------------------------------------
+
+      //if the item was not generated, then try to find the item as is within the generator's content  
+      GeneratorNodeHelper finalNodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+      if( finalNodeHelper.AbsoluteFindItem( item ) )
+      {
+        //item was not generated but was part of this generator
+        if( finalNodeHelper.CurrentNode.Parent == null )
+        {
+          //no parent for speficied item.
+          return true;
+        }
+        collectionViewGroup = ( ( GroupGeneratorNode )finalNodeHelper.CurrentNode.Parent ).CollectionViewGroup;
+        return true;
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+    public bool ExpandGroup( CollectionViewGroup group )
+    {
+      bool groupExpanded = this.ExpandGroupCore( group, false );
+
+      if( !groupExpanded )
+        DataGridException.ThrowSystemException( "An attempt was made to expand a group that does not exist.", typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      return groupExpanded;
+    }
+
+    internal bool ExpandGroupCore( CollectionViewGroup group, bool recurseDetails )
+    {
+      if( this.Status == GeneratorStatus.GeneratingContainers )
+        DataGridException.ThrowSystemException( "An attempt was made to expand a group while the generator is busy generating items.",
+                                                 typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      if( group == null )
+        DataGridException.ThrowSystemException( "group", typeof( ArgumentNullException ), m_dataGridControl.Name );
+
+      this.EnsureNodeTreeCreated();
+
+      if( m_firstItem == null )
+        throw new DataGridInternalException( "No GeneratorNode found for the group.", m_dataGridControl );
+
+      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
+      if( uiGroup != null )
+      {
+        uiGroup.GeneratorNode.IsExpanded = true;
+        return true;
+      }
+
+      if( recurseDetails )
+      {
+        //the item was not found in this generator's content... check all the detail generators
+        foreach( var generator in this.GetDetailGenerators() )
+        {
+          // If the item is not found in the detail generator, it will return false;
+          // The "public" function call will throw if item is never found in itself or its details.
+          if( generator.ExpandGroupCore( group, recurseDetails ) )
+            return true;
+        }
+      }
+
+      return false;
+    }
+
+    public bool CollapseGroup( CollectionViewGroup group )
+    {
+      bool groupCollapsed = this.CollapseGroupCore( group, false );
+
+      if( !groupCollapsed )
+        DataGridException.ThrowSystemException( "An attempt was made to collapse a group that does not exist.", typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      return groupCollapsed;
+    }
+
+    internal bool CollapseGroupCore( CollectionViewGroup group, bool recurseDetails )
+    {
+      if( this.Status == GeneratorStatus.GeneratingContainers )
+        DataGridException.ThrowSystemException( "An attempt was made to collapse a group while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      if( group == null )
+        DataGridException.ThrowSystemException( "group", typeof( ArgumentNullException ), m_dataGridControl.Name );
+
+      this.EnsureNodeTreeCreated();
+
+      if( m_firstItem == null )
+        throw new DataGridInternalException( "No GeneratorNode found for the group.", m_dataGridControl );
+
+      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
+      if( uiGroup != null )
+      {
+        uiGroup.GeneratorNode.IsExpanded = false;
+        return true;
+      }
+
+      if( recurseDetails )
+      {
+        //the item was not found in this generator's content... check all the detail generators
+        foreach( var generator in this.GetDetailGenerators() )
+        {
+          // If the item is not found in the detail generator, it will return false;
+          // The "public" function call will throw if item is never found in itself or its details.
+          if( generator.CollapseGroupCore( group, recurseDetails ) )
+            return true;
+        }
+      }
+
+      return false;
+    }
+
+    public bool ToggleGroupExpansion( CollectionViewGroup group )
+    {
+      bool groupToggled = this.ToggleGroupExpansionCore( group, false );
+
+      if( !groupToggled )
+        DataGridException.ThrowSystemException( "An attempt was made to toggle a group that does not exist.", typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      return groupToggled;
+    }
+
+    internal bool ToggleGroupExpansionCore( CollectionViewGroup group, bool recurseDetails )
+    {
+      if( this.Status == GeneratorStatus.GeneratingContainers )
+        DataGridException.ThrowSystemException( "An attempt was made to a toggle a group's expansion while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      if( group == null )
+        DataGridException.ThrowSystemException( "group", typeof( ArgumentNullException ), m_dataGridControl.Name );
+
+      this.EnsureNodeTreeCreated();
+
+      if( m_firstItem == null )
+        throw new DataGridInternalException( "No GeneratorNode found for the group.", m_dataGridControl );
+
+      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
+      if( uiGroup != null )
+      {
+        GroupGeneratorNode groupNode = uiGroup.GeneratorNode;
+        groupNode.IsExpanded = !groupNode.IsExpanded;
+        return true;
+      }
+
+      if( recurseDetails )
+      {
+        //the item was not found in this generator's content... check all the detail generators
+        foreach( var generator in this.GetDetailGenerators() )
+        {
+          try
+          {
+            return generator.ToggleGroupExpansionCore( group, recurseDetails );
+          }
+          catch( InvalidOperationException )
+          {
+            //if the item is not found in the detail generator, it will throw 
+            //an invalid operation exception. If it doesn't throw, then it is 
+            //safe to return the return value of the function.
+
+            //otherwise, suppress this exception as ultimately, the "root" function call will 
+            //throw if item is never found in itself or its details.
+          }
+        }
+      }
+
+      return false;
+    }
+
+    public bool IsGroupExpanded( CollectionViewGroup group )
+    {
+      return this.IsGroupExpandedCore( group, false );
+    }
+
+    internal bool IsGroupExpandedCore( CollectionViewGroup group, bool recurseDetails )
+    {
+      if( group == null )
+      {
+        DataGridException.ThrowSystemException( "group", typeof( ArgumentNullException ), m_dataGridControl.Name );
+        //Simply there to remove compile error.
+        return false;
+      }
+
+      this.EnsureNodeTreeCreated();
+
+      if( m_firstItem == null )
+        throw new DataGridInternalException( "No GeneratorNode found for the group.", m_dataGridControl );
+
+      Group uiGroup = this.GetGroupFromCollectionViewGroup( group );
+      if( uiGroup != null )
+      {
+        return uiGroup.GeneratorNode.IsExpanded;
+      }
+
+      if( recurseDetails )
+      {
+        //the group was not found in this generator, check in all the child generators for the group.
+        foreach( var generator in this.GetDetailGenerators() )
+        {
+          try
+          {
+            return generator.IsGroupExpandedCore( group, recurseDetails );
+          }
+          catch( InvalidOperationException )
+          {
+            //if the item is not found in the detail generator, it will throw 
+            //an invalid operation exception. If it doesn't throw, then it is 
+            //safe to return the return value of the function.
+
+            //otherwise, suppress this exception as ultimately, the "root" function call will 
+            //throw if item is never found in itself or its details.
+          }
+        }
+      }
+
+      DataGridException.ThrowSystemException( "An attempt was made to consult the expansion state of a group that does not exist.",
+                                              typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      //Simply there to remove compile error.
+      return false;
+    }
+
+    internal void ExpandDetails( object dataItem )
+    {
+    }
+
+    internal void CollapseDetails( object dataItem )
+    {
+    }
+
+    internal void ToggleDetails( object dataItem )
+    {
+    }
+
+    internal bool AreDetailsExpanded( object dataItem )
+    {
+      if( dataItem == null )
+        DataGridException.ThrowSystemException( "dataItem", typeof( ArgumentNullException ), m_dataGridControl.Name );
+
+      return m_masterToDetails.ContainsKey( dataItem );
+    }
+
+    public void RemoveAllAndNotify()
+    {
+      if( m_startNode == null )
+        return; //nothing to do, the generator is already in a "clean" state.
+
+      //this message is issued by the DataGridContext when the VisibleColumns collection changes (re-ordering or changes to its content).
+      IList<DependencyObject> removedContainers = new List<DependencyObject>();
+      this.RemoveGeneratedItems( int.MinValue, int.MaxValue, removedContainers );
+
+      this.SendResetEvent();
+
+      removedContainers.Clear();
+      removedContainers = null;
+
+      removedContainers = m_dataGridContext.RecyclingManager.Clear();
+
+      if( removedContainers.Count > 0 )
+      {
+        this.NotifyContainersRemoved( removedContainers );
+      }
+    }
+
+    internal int FindIndexForItem( object item, DataGridContext dataGridContext )
+    {
+      int retval = -1;
+      bool recurse = false;
+
+      this.EnsureNodeTreeCreated();
+
+      // If the seeked DataGridContext is this generator's context, the item should be here.
+      // When the seeked DataGridContext is null, search for the first item match no matter the generator's context.
+      if( ( m_dataGridContext == dataGridContext ) || ( dataGridContext == null ) )
+      {
+        retval = this.IndexFromItem( item );
+
+        // If the item wasn't found in this generator's context and that we don't have a precise target context, recurse.
         if( ( retval == -1 ) && ( dataGridContext == null ) )
           recurse = true;
       }
@@ -989,14 +1365,12 @@ namespace Xceed.Wpf.DataGrid
             {
               int masterIndex = this.IndexFromItem( masterToDetails.Key );
 
-              Debug.Assert( masterIndex != -1, "masterIndex != -1" );
-#if LOG
-              Log.Assert( this, masterIndex != -1, "masterIndex != -1" );
-#endif
+              m_log.Assert( this, masterIndex != -1, "masterIndex != -1" );
 
               retval = masterIndex + 1 + detailsTotalCount + itemIndex;
               break;
             }
+
             detailsTotalCount += detailNode.ItemCount;
           }
         }
@@ -1014,10 +1388,10 @@ namespace Xceed.Wpf.DataGrid
       GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
 
       if( !nodeHelper.FindNodeForIndex( index ) )
-        throw new ArgumentException( "The specified index does not correspond to an item in the generator.", "index" );
+        DataGridException.ThrowSystemException( "The specified index does not correspond to an item in the generator.",
+                                                typeof( ArgumentException ), m_dataGridControl.Name, "index" );
 
       int indexIndex = m_genPosToIndex.IndexOf( index );
-
       if( indexIndex == -1 )
         return null;
 
@@ -1027,7 +1401,6 @@ namespace Xceed.Wpf.DataGrid
     public int GetRealizedIndexForContainer( DependencyObject container )
     {
       int containerIndex = m_genPosToContainer.IndexOf( container );
-
       if( containerIndex == -1 )
         return -1;
 
@@ -1042,14 +1415,13 @@ namespace Xceed.Wpf.DataGrid
       {
         int itemIndex = m_collectionView.IndexOf( dataItem );
 
-        Debug.Assert( itemIndex != -1, "itemIndex != -1" );
-#if LOG
-        Log.Assert( this, itemIndex != -1, "itemIndex != -1" );
-#endif
+        m_log.Assert( this, itemIndex != -1, "itemIndex != -1" );
 
         masterIndexes.Add( itemIndex );
       }
+
       masterIndexes.Sort();
+
       return masterIndexes;
     }
 
@@ -1072,7 +1444,7 @@ namespace Xceed.Wpf.DataGrid
     public DataGridContext GetChildContext( object parentItem, string relationName )
     {
       if( parentItem == null )
-        throw new ArgumentNullException( "parentItem" );
+        DataGridException.ThrowSystemException( "parentItem", typeof( ArgumentNullException ), m_dataGridControl.Name );
 
       this.EnsureNodeTreeCreated();
 
@@ -1100,13 +1472,12 @@ namespace Xceed.Wpf.DataGrid
     {
       this.EnsureNodeTreeCreated();
 
-      foreach( List<DetailGeneratorNode> details in m_masterToDetails.Values )
-      {
-        foreach( DetailGeneratorNode detailNode in details )
-        {
-          yield return detailNode.DetailContext;
-        }
-      }
+      return this.GetChildContextsCore();
+    }
+
+    internal IEnumerable<DataGridContext> GetChildContextsCore()
+    {
+      return this.GetDetailContexts();
     }
 
     public bool Contains( object item )
@@ -1200,7 +1571,7 @@ namespace Xceed.Wpf.DataGrid
           }
 
           if( containerRealizedIndex == -1 )
-            throw new DataGridInternalException();
+            throw new DataGridInternalException( "The index of a sticky header container is out of bound.", m_dataGridControl );
 
           generatedStickyContainers.AddRange(
             this.GenerateStickyHeadersForDetail( container,
@@ -1312,7 +1683,7 @@ namespace Xceed.Wpf.DataGrid
           int insertionIndex = this.FindInsertionPoint( detailItemIndex );
 
           m_genPosToIndex.Insert( insertionIndex, detailItemIndex );
-          m_genPosToItem.Insert( insertionIndex, CustomItemContainerGenerator.GetDataItemProperty( stickyContainer.StickyContainer ) );
+          m_genPosToItem.Insert( insertionIndex, CustomItemContainerGenerator.GetDataItemProperty( stickyContainer.StickyContainer ).Data );
           m_genPosToContainer.Insert( insertionIndex, stickyContainer.StickyContainer );
           m_genPosToNode.Insert( insertionIndex, detailNode );
         }
@@ -1599,7 +1970,7 @@ namespace Xceed.Wpf.DataGrid
           }
 
           if( containerRealizedIndex == -1 )
-            throw new DataGridInternalException();
+            throw new DataGridInternalException( "The index of a sticky footer container is out of bound.", m_dataGridControl );
 
           generatedStickyContainers.AddRange(
             this.GenerateStickyFootersForDetail( container, detailNode, areFootersSticky, areGroupFootersSticky ) );
@@ -1686,7 +2057,7 @@ namespace Xceed.Wpf.DataGrid
           int insertionIndex = this.FindInsertionPoint( detailItemIndex );
 
           m_genPosToIndex.Insert( insertionIndex, detailItemIndex );
-          m_genPosToItem.Insert( insertionIndex, CustomItemContainerGenerator.GetDataItemProperty( stickyContainer.StickyContainer ) );
+          m_genPosToItem.Insert( insertionIndex, CustomItemContainerGenerator.GetDataItemProperty( stickyContainer.StickyContainer ).Data );
           m_genPosToContainer.Insert( insertionIndex, stickyContainer.StickyContainer );
           m_genPosToNode.Insert( insertionIndex, detailNode );
         }
@@ -1821,10 +2192,7 @@ namespace Xceed.Wpf.DataGrid
           int detailFirstRealizedIndex = this.FindGlobalIndexForDetailNode( detailNode );
           int correctedIndex = index - detailFirstRealizedIndex;
 
-          Debug.Assert( correctedIndex >= 0, "correctedIndex >= 0 .. 1" );
-#if LOG
-          Log.Assert( this, correctedIndex >= 0, "correctedIndex >= 0 .. 1" );
-#endif
+          m_log.Assert( this, correctedIndex >= 0, "correctedIndex >= 0 .. 1" );
 
           stickyHeadersCount +=
             detailNode.DetailGenerator.GetStickyHeaderCountForIndex( correctedIndex,
@@ -1945,10 +2313,7 @@ namespace Xceed.Wpf.DataGrid
           int detailFirstRealizedIndex = this.FindGlobalIndexForDetailNode( detailNode );
           int correctedIndex = index - detailFirstRealizedIndex;
 
-          Debug.Assert( correctedIndex >= 0, "correctedIndex >= 0 .. 2" );
-#if LOG
-          Log.Assert( this, correctedIndex >= 0, "correctedIndex >= 0 .. 2" );
-#endif
+          m_log.Assert( this, correctedIndex >= 0, "correctedIndex >= 0 .. 2" );
 
           stickyFooterCount +=
             detailNode.DetailGenerator.GetStickyFooterCountForIndex( correctedIndex,
@@ -2042,32 +2407,28 @@ namespace Xceed.Wpf.DataGrid
     DependencyObject IItemContainerGenerator.GenerateNext( out bool isNewlyRealized )
     {
       if( this.Status != GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "The Generator is not active: StartAt() was not called prior calling GenerateNext() or the returned IDisposable was already disposed of." );
-      }
+        DataGridException.ThrowSystemException( "The Generator is not active: StartAt() was not called prior calling GenerateNext() or the returned IDisposable was already disposed of.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       DependencyObject container = null;
       isNewlyRealized = false;
 
-      //case 117460: the GeneratorNodeHelper will not be created if there are no items in the generator when started.
       if( m_generatorNodeHelper == null ) //the m_generatorNodeHelper will be turned to null when we reach the end of the list ot items.
         return null;
 
-      Debug.Assert( !( m_generatorNodeHelper.CurrentNode is GroupGeneratorNode ), "Algorithm should not allow the Generator's m_generatorNodeHelper to be on a GroupGeneratorNode" );
-#if LOG
-      Log.Assert( this, !( m_generatorNodeHelper.CurrentNode is GroupGeneratorNode ), "Algorithm should not allow the Generator's m_generatorNodeHelper to be on a GroupGeneratorNode" );
-#endif
+      m_log.Assert( this, !( m_generatorNodeHelper.CurrentNode is GroupGeneratorNode ), "Algorithm should not allow the Generator's m_generatorNodeHelper to be on a GroupGeneratorNode" );
 
       GeneratorNode node = m_generatorNodeHelper.CurrentNode;
 
-      if( ( node == null ) || ( !( node is CollectionGeneratorNode ) ) )
-        throw new DataGridInternalException();
+      if( node == null )
+        throw new DataGridInternalException( "CurrentNode is null.", m_dataGridControl );
 
+      if( !( node is CollectionGeneratorNode ) )
+        throw new DataGridInternalException( "CurrentNode is not a CollectionGeneratorNode.", m_dataGridControl );
 
       //if a detail generator is currently "started", then rely on it for the generation of items
       if( m_generatorCurrentDetail != null )
       {
-
         //if the detail generator was not yet started
         if( m_generatorCurrentDetailDisposable == null )
         {
@@ -2097,31 +2458,11 @@ namespace Xceed.Wpf.DataGrid
         Debug.Unindent();
 
         m_genPosToIndex.Insert( insertionIndex, m_generatorCurrentGlobalIndex );
-        m_genPosToItem.Insert( insertionIndex, CustomItemContainerGenerator.GetDataItemProperty( container ) );
+        m_genPosToItem.Insert( insertionIndex, CustomItemContainerGenerator.GetDataItemProperty( container ).Data );
         m_genPosToContainer.Insert( insertionIndex, container );
         m_genPosToNode.Insert( insertionIndex, node );
 
-#if LOG
-        int count = m_genPosToIndex.Count;
-        int previousIndex = -1;
-
-        for( int i = 0; i < count; i++ )
-        {
-          int tempIndex = m_genPosToIndex[ i ];
-
-          if( tempIndex >= previousIndex )
-          {
-            previousIndex = tempIndex;
-          }
-          else
-          {
-            Debug.Assert( false, "### none sequential index detected (GenerateNext - genpos" + insertionIndex.ToString() + ", globalIndex" + m_generatorCurrentGlobalIndex.ToString() + ")" );
-            Log.Assert( this, false, "### none sequential index detected (GenerateNext - genpos" + insertionIndex.ToString() + ", globalIndex" + m_generatorCurrentGlobalIndex.ToString() + ")" );
-            this.WriteStateInLog();
-            break;
-          }
-        }
-#endif
+        this.ValidateIndexOrder( "genpos" + insertionIndex.ToString() + ", globalIndex" + m_generatorCurrentGlobalIndex.ToString() + ")" );
       }
 
       if( m_generatorDirection == GeneratorDirection.Forward )
@@ -2180,6 +2521,14 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private GeneratorPosition GetSafeGeneratorPositionFromIndex( int itemIndex )
+    {
+      using( this.DeferDetailsRemap() )
+      {
+        return this.GeneratorPositionFromIndex( itemIndex );
+      }
+    }
+
     ItemContainerGenerator IItemContainerGenerator.GetItemContainerGeneratorForPanel( Panel panel )
     {
       return ( ( IItemContainerGenerator )( ( ItemsControl )m_dataGridControl ).ItemContainerGenerator ).GetItemContainerGeneratorForPanel( panel );
@@ -2219,33 +2568,31 @@ namespace Xceed.Wpf.DataGrid
     void IItemContainerGenerator.PrepareItemContainer( DependencyObject container )
     {
       if( this.Status != GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "The Generator is not active: StartAt() was not called prior calling PrepareItemContainer() or the returned IDisposable was already disposed of." );
-      }
+        DataGridException.ThrowSystemException( "The Generator is not active: StartAt() was not called prior calling PrepareItemContainer() or the returned IDisposable was already disposed of.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
-      object dataItem = CustomItemContainerGenerator.GetDataItemProperty( container );
-      if( dataItem != null )
-      {
-        m_dataGridControl.PrepareItemContainer( container, dataItem );
-      }
+      var dataItemStore = CustomItemContainerGenerator.GetDataItemProperty( container );
+      if( ( dataItemStore == null ) || dataItemStore.IsEmpty )
+        return;
+
+      var dataItem = dataItemStore.Data;
+      if( dataItem == null )
+        return;
 
+      m_dataGridControl.PrepareItemContainer( container, dataItem );
     }
 
     void IItemContainerGenerator.Remove( GeneratorPosition position, int count )
     {
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
+
       if( position.Offset != 0 )
-      {
+        DataGridException.ThrowSystemException( "The GeneratorPosition to remove cannot map to a non-realized item.", typeof( InvalidOperationException ), m_dataGridControl.Name );
 
-        throw new InvalidOperationException( "The GeneratorPosition to remove cannot map to a non-realized item." );
-      }
       if( position.Index == -1 )
-      {
-        throw new InvalidOperationException( "The GeneratorPosition to remove cannot map to a non-realized item." );
-      }
+        DataGridException.ThrowSystemException( "he GeneratorPosition to remove cannot map to a non-realized item.", typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       //if the index passed is within the array!
       if( position.Index < m_genPosToIndex.Count )
@@ -2254,10 +2601,8 @@ namespace Xceed.Wpf.DataGrid
         for( int i = 0; i < count; i++ )
         {
           if( this.RemoveGeneratedItem( position.Index, null ) == 0 )
-          {
             //This case deserves a more solid approach... We do not want to allow removal from the user panel of an item that somehow is not present.
-            throw new DataGridInternalException();
-          }
+            throw new DataGridInternalException( "Trying to remove an item at an out-of-bound GenratorPosition index.", m_dataGridControl );
         }
 
         //No need to update the Generator current generation, since the content of the generator items did not change (only the list of realized items).
@@ -2265,7 +2610,7 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "Trying to remove an item at an out-of-bound GenratorPosition index", m_dataGridControl );
       }
 
     }
@@ -2273,17 +2618,16 @@ namespace Xceed.Wpf.DataGrid
     void IItemContainerGenerator.RemoveAll()
     {
       if( this.Status == GeneratorStatus.GeneratingContainers )
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+      using( this.SetIsHandlingGlobalItemsResetLocally() )
       {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
+        //Call to remove all shall not request container recycling panels to remove their containers. Therefore, I am not collecting the remove containers.
+        this.RemoveAllGeneratedItems();
       }
 
-      //Call to remove all shall not request container recycling panels to remove their containers. Tehrefore, I am not collecting the remove 
-      //containers.
-      this.RemoveAllGeneratedItems();
-
       //No need to update the Generator current generation, since the content of the generator items did not change (only the list of realized items).
-      //m_currentGeneratorContentGeneration++;
-
     }
 
     IDisposable IItemContainerGenerator.StartAt( GeneratorPosition position, GeneratorDirection direction, bool allowStartAtRealizedItem )
@@ -2291,9 +2635,8 @@ namespace Xceed.Wpf.DataGrid
       this.SetIsInUse();
 
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       this.EnsureNodeTreeCreated();
 
@@ -2369,7 +2712,11 @@ namespace Xceed.Wpf.DataGrid
         }
 
         m_flags[ ( int )CustomItemContainerGeneratorFlags.RecyclingEnabled ] = value;
-        this.SetIsRecyclingEnabledOnDetails( value );
+
+        foreach( var generator in this.GetDetailGenerators() )
+        {
+          generator.IsRecyclingEnabled = value;
+        }
       }
     }
 
@@ -2397,7 +2744,8 @@ namespace Xceed.Wpf.DataGrid
       object newCurrentItem = nodeHelper.FindIndex( newCurrentIndex );
 
       if( newCurrentItem == null )
-        throw new InvalidOperationException( "An attempt was made to access an item at an index that does not correspond to an item." );
+        DataGridException.ThrowSystemException( "An attempt was made to access an item at an index that does not correspond to an item.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       //Then, if the item is within an ItemsNode, check if it belongs to a detail
       ItemsGeneratorNode itemsNode = nodeHelper.CurrentNode as ItemsGeneratorNode;
@@ -2421,7 +2769,7 @@ namespace Xceed.Wpf.DataGrid
 
       //If the item is not within an ItemsNode or not within a detail
       //then set it current within its context.
-      m_dataGridContext.SetCurrentItemCore( newCurrentItem, false, false );
+      m_dataGridContext.SetCurrentItemCore( newCurrentItem, false, false, AutoScrollCurrentItemSourceTriggers.Navigation );
     }
 
     int ICustomItemContainerGenerator.GetCurrentIndex()
@@ -2438,24 +2786,14 @@ namespace Xceed.Wpf.DataGrid
     void ICustomItemContainerGenerator.RestoreFocus( DependencyObject container )
     {
       if( !m_genPosToContainer.Contains( container ) )
-        throw new ArgumentException( "The specified container is not part of the generator's content." );
+        DataGridException.ThrowSystemException( "The specified container is not part of the generator's content.",
+                                                typeof( ArgumentException ), m_dataGridControl.Name, "container" );
 
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( container );
       ColumnBase column = ( dataGridContext == null ) ? null : dataGridContext.CurrentColumn;
       m_dataGridControl.SetFocusHelper( container as UIElement, column, false, true );
     }
 
-    private void SetIsRecyclingEnabledOnDetails( bool value )
-    {
-      foreach( List<DetailGeneratorNode> details in m_masterToDetails.Values )
-      {
-        foreach( DetailGeneratorNode detail in details )
-        {
-          detail.DetailGenerator.IsRecyclingEnabled = value;
-        }
-      }
-    }
-
     #endregion
 
     private DependencyObject GenerateNextLocalContainer( out bool isNewlyRealized )
@@ -2464,10 +2802,7 @@ namespace Xceed.Wpf.DataGrid
       object dataItem;
       CollectionGeneratorNode node = m_generatorNodeHelper.CurrentNode as CollectionGeneratorNode;
 
-      Debug.Assert( node != null, "CustomItemContainerGenerator.GenerateNextLocalContainer: node is null." );
-#if LOG
-      Log.Assert( this, node != null, "CustomItemContainerGenerator.GenerateNextLocalContainer: node is null." );
-#endif
+      m_log.Assert( this, node != null, "CustomItemContainerGenerator.GenerateNextLocalContainer: node is null." );
 
       ItemsGeneratorNode itemsNode = node as ItemsGeneratorNode;
 
@@ -2484,44 +2819,17 @@ namespace Xceed.Wpf.DataGrid
 
         if( tempNode == null )
         {
-#if LOG
-          Debug.Assert( false, "CustomItemContainerGenerator.GenerateNextLocalContainer: ### cached Node is null ( at " + genPosIndex.ToString() + " )" );
-          Log.Assert( this, false, "CustomItemContainerGenerator.GenerateNextLocalContainer: ### cached Node is null ( at " + genPosIndex.ToString() + " )" );
-          Log.WriteLine( this, "### Possible crash - ResetGeneratorContent dispatched" );
-          this.WriteStateInLog();
+          this.LogState();
+          m_log.Fail( this, "CustomItemContainerGenerator.GenerateNextLocalContainer: ### cached Node is null ( at " + genPosIndex.ToString() + " )" );
 
-          m_dataGridControl.Dispatcher.BeginInvoke( ( Action )( () =>
-          {
-            this.ResetGeneratorContent();
-
-            if( m_dataGridControl.ItemsHost != null )
-              m_dataGridControl.ItemsHost.InvalidateMeasure();
-          } ), System.Windows.Threading.DispatcherPriority.Background );
-#else
-          throw new DataGridInternalException( "CustomItemContainerGenerator.GenerateNextLocalContainer: cached Node is null" );
-#endif
+          throw new DataGridInternalException( "CustomItemContainerGenerator.GenerateNextLocalContainer: cached Node is null", m_dataGridControl );
         }
-        else
+        else if( node != m_generatorNodeHelper.CurrentNode )
         {
-          if( node != m_generatorNodeHelper.CurrentNode )
-          {
-#if LOG
-            Debug.Assert( false, "CustomItemContainerGenerator.GenerateNextLocalContainer: # testNode is not the current one. ( " + m_genPosToNode[ genPosIndex ].GetType().ToString() + " ) ( at " + genPosIndex.ToString() + " )" );
-            Log.Assert( this, false, "CustomItemContainerGenerator.GenerateNextLocalContainer: # testNode is not the current one. ( " + m_genPosToNode[ genPosIndex ].GetType().ToString() + " ) ( at " + genPosIndex.ToString() + " )" );
-            Log.WriteLine( this, "### Possible crash - ResetGeneratorContent dispatched" );
-            this.WriteStateInLog();
+          this.LogState();
+          m_log.Fail( this, "CustomItemContainerGenerator.GenerateNextLocalContainer: # testNode is not the current one. ( " + m_genPosToNode[ genPosIndex ].GetType().ToString() + " ) ( at " + genPosIndex.ToString() + " )" );
 
-            m_dataGridControl.Dispatcher.BeginInvoke( ( Action )( () =>
-            {
-              this.ResetGeneratorContent();
-
-              if( m_dataGridControl.ItemsHost != null )
-                m_dataGridControl.ItemsHost.InvalidateMeasure();
-            } ), System.Windows.Threading.DispatcherPriority.Background );
-#else
-            throw new DataGridInternalException( "CustomItemContainerGenerator.GenerateNextLocalContainer: Node is not the current one." );
-#endif
-          }
+          throw new DataGridInternalException( "CustomItemContainerGenerator.GenerateNextLocalContainer: Node is not the current one.", m_dataGridControl );
         }
 
         isNewlyRealized = false;
@@ -2596,21 +2904,8 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        Debug.Assert( false, "CustomItemContainerGenerator.GenerateNextLocalContainer: node is null ( at " + genPosIndex.ToString() + " )" );
-#if LOG
-        Log.Assert( this, false, "CustomItemContainerGenerator.GenerateNextLocalContainer: node is null ( at " + genPosIndex.ToString() + " )" );
-        this.WriteStateInLog();
-
-        Log.WriteLine( this, "### Possible crash - ResetGeneratorContent dispatched" );
-
-        m_dataGridControl.Dispatcher.BeginInvoke( ( Action )( () =>
-          {
-            this.ResetGeneratorContent();
-
-            if( m_dataGridControl.ItemsHost != null )
-              m_dataGridControl.ItemsHost.InvalidateMeasure();
-          } ), System.Windows.Threading.DispatcherPriority.Background );
-#endif
+        this.LogState();
+        m_log.Fail( this, "CustomItemContainerGenerator.GenerateNextLocalContainer: node is null ( at " + genPosIndex.ToString() + " )" );
       }
 
       return container;
@@ -2668,12 +2963,8 @@ namespace Xceed.Wpf.DataGrid
       //if I was generating from a detail generator
       if( m_generatorCurrentDetail != null )
       {
-        Debug.Assert( currentMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorForward: currentMasterNode is not null." );
-        Debug.Assert( currentMasterNode.Details != null, "CustomItemContainerGenerator.MoveGeneratorForward: currentMasterNode.Details is not null." );
-#if LOG
-        Log.Assert( this, currentMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorForward: currentMasterNode is not null." );
-        Log.Assert( this, currentMasterNode.Details != null, "CustomItemContainerGenerator.MoveGeneratorForward: currentMasterNode.Details is not null." );
-#endif
+        m_log.Assert( this, currentMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorForward: currentMasterNode is not null." );
+        m_log.Assert( this, currentMasterNode.Details != null, "CustomItemContainerGenerator.MoveGeneratorForward: currentMasterNode.Details is not null." );
 
         //incremment the running counter for the item index generated in the detail generator
         m_generatorCurrentDetailIndex++;
@@ -2692,10 +2983,7 @@ namespace Xceed.Wpf.DataGrid
           List<DetailGeneratorNode> detailsforMasterNode;
           currentMasterNode.Details.TryGetValue( m_generatorCurrentOffset, out detailsforMasterNode );
 
-          Debug.Assert( detailsforMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorForward: detailsforMasterNode is not null." );
-#if LOG
-          Log.Assert( this, detailsforMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorForward: detailsforMasterNode is not null." );
-#endif
+          m_log.Assert( this, detailsforMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorForward: detailsforMasterNode is not null." );
 
           while( ( m_generatorCurrentDetailNodeIndex < detailsforMasterNode.Count ) && ( m_generatorCurrentDetailIndex == -1 ) )
           {
@@ -2786,12 +3074,8 @@ namespace Xceed.Wpf.DataGrid
       //if I was generating from a detail generator
       if( m_generatorCurrentDetail != null )
       {
-        Debug.Assert( currentMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorBackward: currentMasterNode is not null." );
-        Debug.Assert( currentMasterNode.Details != null, "CustomItemContainerGenerator.MoveGeneratorBackward: currentMasterNode.Details is not null." );
-#if LOG
-        Log.Assert( this, currentMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorBackward: currentMasterNode is not null." );
-        Log.Assert( this, currentMasterNode.Details != null, "CustomItemContainerGenerator.MoveGeneratorBackward: currentMasterNode.Details is not null." );
-#endif
+        m_log.Assert( this, currentMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorBackward: currentMasterNode is not null." );
+        m_log.Assert( this, currentMasterNode.Details != null, "CustomItemContainerGenerator.MoveGeneratorBackward: currentMasterNode.Details is not null." );
 
         //decrement the running counter for the item index generated in the detail generator
         m_generatorCurrentDetailIndex--;
@@ -2812,10 +3096,7 @@ namespace Xceed.Wpf.DataGrid
             List<DetailGeneratorNode> detailsforMasterNode;
             currentMasterNode.Details.TryGetValue( m_generatorCurrentOffset, out detailsforMasterNode );
 
-            Debug.Assert( detailsforMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorBackward: detailsforMasterNode is not null." );
-#if LOG
-            Log.Assert( this, detailsforMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorBackward: detailsforMasterNode is not null." );
-#endif
+            m_log.Assert( this, detailsforMasterNode != null, "CustomItemContainerGenerator.MoveGeneratorBackward: detailsforMasterNode is not null." );
 
             while( ( m_generatorCurrentDetailNodeIndex >= 0 ) && ( m_generatorCurrentDetailIndex == -1 ) )
             {
@@ -2909,7 +3190,8 @@ namespace Xceed.Wpf.DataGrid
     private bool ShouldDrawBottomLine()
     {
       if( m_generatorStatus != GeneratorStatus.GeneratingContainers )
-        throw new InvalidOperationException( "An attempt was made to call the CustomItemContainerGenerator.ShouldDrawBottomLine method while containers are not being generated." );
+        DataGridException.ThrowSystemException( "An attempt was made to call the CustomItemContainerGenerator.ShouldDrawBottomLine method while containers are not being generated.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       return ( m_generatorCurrentGlobalIndex == ( this.ItemCount - 1 ) );
     }
@@ -2917,47 +3199,36 @@ namespace Xceed.Wpf.DataGrid
     private bool ItemHasExpandedDetails()
     {
       if( m_generatorStatus != GeneratorStatus.GeneratingContainers )
-        throw new InvalidOperationException( "An attempt was made to call the CustomItemContainerGenerator.ItemHasExpandedDetails method while containers are not being generated." );
+        DataGridException.ThrowSystemException( "An attempt was made to call the CustomItemContainerGenerator.ItemHasExpandedDetails method while containers are not being generated.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       ItemsGeneratorNode itemsNode = m_generatorNodeHelper.CurrentNode as ItemsGeneratorNode;
-
-      if( itemsNode == null )
+      if( ( itemsNode == null ) || ( itemsNode.Details == null ) )
         return false;
 
-      if( itemsNode.Details == null )
-      {
-        return false;
-      }
-      else if( itemsNode.Details.ContainsKey( m_generatorCurrentOffset ) )
-        return true;
+      return itemsNode.Details.ContainsKey( m_generatorCurrentOffset );
+    }
 
-      return false;
+    internal void CleanupGenerator()
+    {
+      this.CleanupGenerator( false );
     }
 
     internal void CleanupGenerator( bool isNestedCall )
     {
-      Debug.Assert( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount == 0, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
-#if LOG
-      Log.Start( this, "CleanupGenerator" );
-
-      Log.Assert( this, m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount == 0, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
-#endif
+      m_log.Assert( this, !this.IsHandlingGlobalItemsResetLocally, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
 
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
-      {
-#if LOG
-        Log.End( this, "CleanupGenerator - Ignored" );
-#endif
+      if( this.IsHandlingGlobalItemsResetLocally )
         return;
-      }
 
-      using( new ProcessingGlobalItemsResetOrRemovingAllGeneratedItemsDisposable( this ) )
+      using( m_log.BeginBlock( this, null ) )
+      using( this.SetIsHandlingGlobalItemsResetLocally() )
       {
         this.RemoveAllGeneratedItems();
 
         IList<DependencyObject> removedContainers = null;
 
-        RecyclingManager recyclingManager = m_dataGridContext.RecyclingManager;
+        var recyclingManager = m_dataGridContext.RecyclingManager;
         recyclingManager.RemoveRef( this );
         if( recyclingManager.RefCount == 0 )
         {
@@ -2975,6 +3246,8 @@ namespace Xceed.Wpf.DataGrid
           this.NotifyContainersRemoved( removedContainers );
         }
 
+        this.ClearLateGroupLevelDescriptions();
+
         if( m_startNode != null )
         {
           //Note: this does not disconnects the "general" master/detail relationship established between an Item and its details,
@@ -2991,39 +3264,23 @@ namespace Xceed.Wpf.DataGrid
         //This absolutelly needs to be done after the node list is Cleaned!
         this.CleanupDetailRelations();
       }
-
-#if LOG
-      Log.End( this, "CleanupGenerator" );
-#endif
     }
 
     private void CleanupDetailRelations()
     {
-#if LOG
-      Log.Start( this, "CleanupDetailRelations" );
-#endif
-
-      //clean the remnants of the master/detail stuff
-      foreach( KeyValuePair<object, List<DetailGeneratorNode>> masterToDetails in m_masterToDetails )
+      using( m_log.BeginBlock( this, null ) )
       {
-        foreach( DetailGeneratorNode detailNode in masterToDetails.Value )
+        var detailNodes = this.GetDetailGeneratorNodes().ToList();
+
+        m_masterToDetails.Clear();
+
+        foreach( var detailNode in detailNodes )
         {
-          this.CleanDetailNode( detailNode );
+          this.ClearDetailGeneratorNode( detailNode );
         }
 
-        masterToDetails.Value.Clear();
+        m_floatingDetails.Clear();
       }
-
-#if LOG
-      Log.WriteLine( this, "masterToDetails.Clear" );
-#endif
-
-      m_masterToDetails.Clear();
-      m_floatingDetails.Clear();
-
-#if LOG
-      Log.End( this, "CleanupDetailRelations" );
-#endif
     }
 
     private void IncrementCurrentGenerationCount( bool updateGenPosList )
@@ -3055,13 +3312,10 @@ namespace Xceed.Wpf.DataGrid
     private void OnItemsSourceChanged( object sender, EventArgs e )
     {
       // Avoid re-entrance when processing a global reset
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
+      if( this.IsHandlingGlobalItemsReset )
         return;
 
-      //do a global reset when the items source changes on the DataGridControl.
-      this.HandleGlobalItemsReset( true );
-
-
+      this.CleanupGenerator();
     }
 
     private void OnDetailConfigurationsChanged( object sender, NotifyCollectionChangedEventArgs e )
@@ -3079,38 +3333,38 @@ namespace Xceed.Wpf.DataGrid
         case NotifyCollectionChangedAction.Reset:
         default:
           {
-#if LOG
-            Log.Start( this, "DetailConfiguration Changed" );
-#endif
-
-            // That ensure the RemapFloatingDetails() got called and the loop on m_masterToDetails.Keys will not contain invalid item.
-            this.EnsureNodeTreeCreated();
+            using( m_log.BeginBlock( this, "DetailConfiguration Changed" ) )
+            {
+              // That ensure the RemapFloatingDetails() got called and the loop on m_masterToDetails.Keys will not contain invalid item.
+              this.EnsureNodeTreeCreated();
+            }
 
-#if LOG
-            Log.End( this, "DetailConfiguration Changed" );
-#endif
             break;
           }
       }
     }
 
+    private void OnCollectionViewGroupsPropertyChanged()
+    {
+      this.HandleGlobalItemsReset();
+    }
+
     private void OnItemsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       // Avoid re-entrance when processing a global reset
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
+      if( this.IsHandlingGlobalItemsResetLocally )
         return;
 
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       switch( e.Action )
       {
         case NotifyCollectionChangedAction.Add:
           //do not handle the Items.CollectionChanged if groups are present or if there is already a items node.
           // (because the OnGeneratorNodeItemsCollectionChanged will handle things)
-          if( m_collectionView.Groups == null )
+          if( m_collectionView.GroupDescriptions.Count == 0 )
           {
             if( m_firstItem == null )
             {
@@ -3124,31 +3378,33 @@ namespace Xceed.Wpf.DataGrid
             }
           }
           break;
+
         case NotifyCollectionChangedAction.Move:
         case NotifyCollectionChangedAction.Remove:
         case NotifyCollectionChangedAction.Replace:
           //I voluntarilly do not handle these particular cases because the ItemsNode
           //handler will cover it. (OnGeneratorNodeItemsCollectionChanged)
           break;
+
         case NotifyCollectionChangedAction.Reset:
-          this.HandleGlobalItemsReset();
+          // If there are group descriptions, the PropertyChanged on Groups will handle it.
+          if( m_collectionView.GroupDescriptions.Count == 0 )
+          {
+            this.HandleGlobalItemsReset();
+          }
           break;
-        default:
-          throw new DataGridInternalException();
       }
-
     }
 
     private void OnGroupsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       // Avoid re-entrance when processing a global reset
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
+      if( this.IsHandlingGlobalItemsResetLocally )
         return;
 
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       //this fonction is only used to process the content of the DataGridControl.Items.Groups collection...
       // for the CollectionChanged event of branch groups ( IsBottomLevel = false ), refer to the 
@@ -3183,29 +3439,24 @@ namespace Xceed.Wpf.DataGrid
           this.SendAddEvent( genPos, addIndex, addCount );
 
           break;
+
         case NotifyCollectionChangedAction.Move:
           if( m_firstItem != null )
           {
             if( !( m_firstItem is GroupGeneratorNode ) )
-            {
-              throw new DataGridInternalException();
-            }
+              throw new DataGridInternalException( "Trying to move a GeneratorNode that is not a GroupGeneratorNode.", m_dataGridControl );
 
-            Debug.Assert( e.OldStartingIndex != e.NewStartingIndex, "An attempt was made to move a group to the same location." );
-#if LOG
-            Log.Assert( this, e.OldStartingIndex != e.NewStartingIndex, "An attempt was made to move a group to the same location." );
-#endif
+            m_log.Assert( this, e.OldStartingIndex != e.NewStartingIndex, "An attempt was made to move a group to the same location." );
 
             this.HandleSameLevelGroupMove( m_firstItem, e );
           }
           break;
+
         case NotifyCollectionChangedAction.Remove:
           if( m_firstItem != null )
           {
             if( !( m_firstItem is GroupGeneratorNode ) )
-            {
-              throw new DataGridInternalException();
-            }
+              throw new DataGridInternalException( "Trying to remove a GeneratorNode that is not a GroupGeneratorNode.", m_dataGridControl );
 
             int remCount;
             int generatedRemCount;
@@ -3221,15 +3472,24 @@ namespace Xceed.Wpf.DataGrid
           }
 
           break;
+
         case NotifyCollectionChangedAction.Replace:
-          throw new NotSupportedException( "Replace not supported at the moment on groups!!!" );
-        //break;
+          DataGridException.ThrowSystemException( "Replace not supported at the moment on groups.", typeof( NotSupportedException ), m_dataGridControl.Name );
+          break;
+
         case NotifyCollectionChangedAction.Reset:
-          //I'm forced to handle it specifically since the Panel will AUTOMATICALLY clear its children
-          this.HandleGlobalItemsReset();
+          if( m_firstItem != null )
+          {
+            if( !( m_firstItem is GroupGeneratorNode ) )
+              throw new DataGridInternalException( "Trying to reset a GeneratorNode that is not a GroupGeneratorNode.", m_dataGridControl );
+
+            this.HandleSameLevelGroupReset( m_firstItem );
+          }
+          else
+          {
+            this.HandleGlobalItemsReset();
+          }
           break;
-        default:
-          throw new DataGridInternalException();
       }
 
     }
@@ -3237,106 +3497,98 @@ namespace Xceed.Wpf.DataGrid
     private void OnGeneratorNodeItemsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       // Avoid re-entrance when processing a global reset
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
+      if( this.IsHandlingGlobalItemsResetLocally )
         return;
 
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
-      GeneratorNode node = sender as GeneratorNode;
-      ItemsGeneratorNode itemsNode = sender as ItemsGeneratorNode;
-      HeadersFootersGeneratorNode headersNode = sender as HeadersFootersGeneratorNode;
+      var node = sender as GeneratorNode;
+      if( node == null )
+        return;
 
-      if( node != null )
+      var itemsNode = sender as ItemsGeneratorNode;
+      var headersNode = sender as HeadersFootersGeneratorNode;
+
+      e = e.GetRangeActionOrSelf();
+
+      switch( e.Action )
       {
-        switch( e.Action )
-        {
-          case NotifyCollectionChangedAction.Add:
-            this.HandleItemAddition( node, e );
-            break;
-          case NotifyCollectionChangedAction.Remove:
+        case NotifyCollectionChangedAction.Add:
+          this.HandleItemAddition( node, e );
+          break;
 
-            if( itemsNode != null )
-            {
-              this.HandleItemRemoveMoveReplace( itemsNode, e );
-            }
-            else if( headersNode != null )
-            {
-              this.HandleHeaderFooterRemove( headersNode, e );
-            }
-            else
-            {
-              throw new DataGridInternalException();
-            }
+        case NotifyCollectionChangedAction.Remove:
+          if( itemsNode != null )
+          {
+            this.HandleItemRemoveMoveReplace( itemsNode, e );
+          }
+          else if( headersNode != null )
+          {
+            this.HandleHeaderFooterRemove( headersNode, e );
+          }
+          else
+          {
+            throw new DataGridInternalException( "Cannot remove the GeneratorNode as it is not of a valid type.", m_dataGridControl );
+          }
+          break;
 
-            break;
-          case NotifyCollectionChangedAction.Move:
-          case NotifyCollectionChangedAction.Replace:
-            if( itemsNode != null )
-            {
-              //detect the case where the replace is targeted at a single item, replaced with himself.
-              //This particular case is there to handle the particularities of the DGCV with regards to
-              //IBindingList.ListChanged.ChangeType == ItemChanged.
-              if( ( e.Action == NotifyCollectionChangedAction.Replace ) &&
-                  ( e.OldItems.Count == 1 ) && ( e.NewItems.Count == 1 ) &&
-                  ( e.NewItems[ 0 ] == e.OldItems[ 0 ] ) )
-              {
-                // Getting a replace with the same instance should just do nothing.
-                //
-                // Note : We know that will prevent a row from refreshing correctly if the item 
-                // are not implementing a mechanic of notification ( like INotifyPropertyChanged ).
-              }
-              else
-              {
-                //any other case, normal handling
-                this.HandleItemRemoveMoveReplace( itemsNode, e );
-              }
-            }
-            else if( headersNode != null )
+        case NotifyCollectionChangedAction.Move:
+        case NotifyCollectionChangedAction.Replace:
+          if( itemsNode != null )
+          {
+            //detect the case where the replace is targeted at a single item, replaced with himself.
+            //This particular case is there to handle the particularities of the DGCV with regards to
+            //IBindingList.ListChanged.ChangeType == ItemChanged.
+            if( ( e.Action == NotifyCollectionChangedAction.Replace ) &&
+                ( e.OldItems.Count == 1 ) && ( e.NewItems.Count == 1 ) &&
+                ( e.NewItems[ 0 ] == e.OldItems[ 0 ] ) )
             {
-              this.HandleHeaderFooterReplace( headersNode, e );
+              // Getting a replace with the same instance should just do nothing.
+              //
+              // Note : We know that will prevent a row from refreshing correctly if the item 
+              // are not implementing a mechanic of notification ( like INotifyPropertyChanged ).
             }
             else
             {
-              throw new DataGridInternalException();
+              //any other case, normal handling
+              this.HandleItemRemoveMoveReplace( itemsNode, e );
             }
-            break;
-          case NotifyCollectionChangedAction.Reset:
-            this.HandleItemReset( node );
-            break;
-          default:
-            throw new DataGridInternalException();
-        }
-      }
+          }
+          else if( headersNode != null )
+          {
+            this.HandleHeaderFooterReplace( headersNode, e );
+          }
+          else
+          {
+            throw new DataGridInternalException( "Cannot move or replace the GeneratorNode as it is not of a valid type.", m_dataGridControl );
+          }
+          break;
 
+        case NotifyCollectionChangedAction.Reset:
+          this.HandleItemReset( node );
+          break;
+      }
     }
 
     private void OnGeneratorNodeExpansionStateChanged( object sender, ExpansionStateChangedEventArgs e )
     {
       //throw an error is the Generator is actually busy generating!
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       GeneratorNode node = sender as GeneratorNode;
 
-      Debug.Assert( node != null, "node != null" );
-#if LOG
-      Log.Assert( this, node != null, "node != null" );
-#endif
+      m_log.Assert( this, node != null, "node != null" );
 
       if( node == null )
         return;
 
       GroupGeneratorNode changedNode = node.Parent as GroupGeneratorNode;
 
-      Debug.Assert( changedNode != null, "changedNode != null" ); //should never be null, as the "node" is supposed to be the child node of this one.
-#if LOG
-      Log.Assert( this, changedNode != null, "changedNode != null" ); //should never be null, as the "node" is supposed to be the child node of this one.
-#endif
+      m_log.Assert( this, changedNode != null, "changedNode != null" ); //should never be null, as the "node" is supposed to be the child node of this one.
 
       //Determine if the changedNode is "below" a collapsed group (because if so, I don't need any sort of notification or removal ).
       GroupGeneratorNode parentGroupNode = changedNode.Parent as GroupGeneratorNode;
@@ -3383,14 +3635,10 @@ namespace Xceed.Wpf.DataGrid
     {
       //throw an error is the Generator is actually busy generating!
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
-      Debug.Assert( m_currentGenPosToIndexInhibiterDisposable == null, "m_currentGenPosToIndexInhibiterDisposable == null" );
-#if LOG
-      Log.Assert( this, m_currentGenPosToIndexInhibiterDisposable == null, "m_currentGenPosToIndexInhibiterDisposable == null" );
-#endif
+      m_log.Assert( this, m_currentGenPosToIndexInhibiterDisposable == null, "m_currentGenPosToIndexInhibiterDisposable == null" );
 
       m_currentGenPosToIndexInhibiterDisposable = this.InhibitParentGenPosToIndexUpdate();
 
@@ -3414,9 +3662,8 @@ namespace Xceed.Wpf.DataGrid
     {
       //throw an error is the Generator is actually busy generating!
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       GroupGeneratorNode node = sender as GroupGeneratorNode;
       if( node != null )
@@ -3434,9 +3681,8 @@ namespace Xceed.Wpf.DataGrid
     private void OnGeneratorNodeGroupsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       GroupGeneratorNode node = sender as GroupGeneratorNode;
 
@@ -3445,43 +3691,40 @@ namespace Xceed.Wpf.DataGrid
         switch( e.Action )
         {
           case NotifyCollectionChangedAction.Add:
-            int addCount;
-            GeneratorNode addNode = this.HandleParentGroupAddition( node, out addCount, e );
-
-            if( node.IsComputedExpanded )
             {
-              GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( addNode, 0, 0 );//index not important, will reserve find it.
-              nodeHelper.ReverseCalculateIndex();
+              int addCount;
+              GeneratorNode addNode = this.HandleParentGroupAddition( node, out addCount, e );
 
-              this.IncrementCurrentGenerationCount();
+              if( node.IsComputedExpanded )
+              {
+                GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( addNode, 0, 0 );//index not important, will reserve find it.
+                nodeHelper.ReverseCalculateIndex();
 
-              GeneratorPosition genPos = this.GeneratorPositionFromIndex( nodeHelper.Index );
+                this.IncrementCurrentGenerationCount();
+
+                GeneratorPosition genPos = this.GeneratorPositionFromIndex( nodeHelper.Index );
 
-              this.SendAddEvent( genPos, nodeHelper.Index, addCount );
+                this.SendAddEvent( genPos, nodeHelper.Index, addCount );
+              }
             }
             break;
-          case NotifyCollectionChangedAction.Move:
-            if( node.Child == null )
-            {
-              throw new DataGridInternalException();
-            }
-            else
+
+          case NotifyCollectionChangedAction.Move:
             {
-              Debug.Assert( e.OldStartingIndex != e.NewStartingIndex, "An attempt was made to move a group to the same location." );
-#if LOG
-              Log.Assert( this, e.OldStartingIndex != e.NewStartingIndex, "An attempt was made to move a group to the same location." );
-#endif
+              if( node.Child == null )
+                throw new DataGridInternalException( "An attempt was made to move a group with a null child GeneratorNode.", m_dataGridControl );
+
+              m_log.Assert( this, e.OldStartingIndex != e.NewStartingIndex, "An attempt was made to move a group to the same location." );
 
               this.HandleSameLevelGroupMove( node.Child, e );
             }
             break;
+
           case NotifyCollectionChangedAction.Remove:
-            if( node.Child == null )
-            {
-              throw new DataGridInternalException();
-            }
-            else
             {
+              if( node.Child == null )
+                throw new DataGridInternalException( "An attempt was made to remove a group with a null child GeneratorNode.", m_dataGridControl );
+
               int remCount;
               int generatedRemCount;
               int removeIndex;
@@ -3494,41 +3737,34 @@ namespace Xceed.Wpf.DataGrid
 
                 this.SendRemoveEvent( remPos, removeIndex, remCount, generatedRemCount, removedContainers );
               }
-
             }
             break;
+
           case NotifyCollectionChangedAction.Replace:
-            //if( node.Child == null )
-            //{
-            //  throw new DataGridInternalException();
-            //}
-            //else
-            //{
-            //  this.HandleGroupReplace( node.Child, e );
-            //}
-
-            //m_currentGeneratorContentGeneration++;
-            throw new DataGridInternalException();
-          //break;
+            DataGridException.ThrowSystemException( "Replace not supported at the moment on groups.", typeof( NotSupportedException ), m_dataGridControl.Name );
+            break;
+
           case NotifyCollectionChangedAction.Reset:
-            //m_currentGeneratorContentGeneration++;
-            throw new DataGridInternalException();
-          default:
-            throw new DataGridInternalException();
+            {
+              if( node.Child == null )
+                throw new DataGridInternalException( "An attempt was made to reset a group with a null child GeneratorNode.", m_dataGridControl );
 
+              this.HandleSameLevelGroupReset( node.Child );
+            }
+            break;
         }
       }
-
     }
 
     private void OnViewThemeChanged( object sender, EventArgs e )
     {
       if( this.Status == GeneratorStatus.GeneratingContainers )
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       if( m_startNode != null )
       {
-        this.CleanupGenerator( false );
+        this.CleanupGenerator();
       }
 
       this.IncrementCurrentGenerationCount();
@@ -3536,7 +3772,7 @@ namespace Xceed.Wpf.DataGrid
 
     private void OnGroupConfigurationSelectorChanged()
     {
-      this.CleanupGenerator( false );
+      this.CleanupGenerator();
     }
 
     private void ResetNodeList()
@@ -3601,6 +3837,7 @@ namespace Xceed.Wpf.DataGrid
         int chainLength;
         GeneratorNodeHelper.EvaluateChain( m_firstItem, out removeCount, out chainLength );
 
+        this.ClearLateGroupLevelDescriptions();
         m_groupNodeMappingCache.Clear();
         this.NodeFactory.CleanGeneratorNodeTree( m_firstItem );
         m_firstItem = null;
@@ -3621,16 +3858,10 @@ namespace Xceed.Wpf.DataGrid
       DependencyObject container = m_genPosToContainer[ index ];
       GeneratorNode node = m_genPosToNode[ index ];
 
-      Debug.Assert( ( m_genPosToContainer.Count != 0 )
-                       && ( m_genPosToIndex.Count != 0 )
-                       && ( m_genPosToItem.Count != 0 )
-                       && ( m_genPosToNode.Count != 0 ), "Internal Generator's lists are empty, cannot continue to process RemoveGeneratedItems" );
-#if LOG
-      Log.Assert( this, ( m_genPosToContainer.Count != 0 )
-                       && ( m_genPosToIndex.Count != 0 )
-                       && ( m_genPosToItem.Count != 0 )
-                       && ( m_genPosToNode.Count != 0 ), "Internal Generator's lists are empty, cannot continue to process RemoveGeneratedItems" );
-#endif
+      m_log.Assert( this, ( m_genPosToContainer.Count != 0 )
+                     && ( m_genPosToIndex.Count != 0 )
+                     && ( m_genPosToItem.Count != 0 )
+                     && ( m_genPosToNode.Count != 0 ), "Internal Generator's lists are empty, cannot continue to process RemoveGeneratedItems" );
 
       //remove the item from the 4 lists... (same as doing a "remove")
       this.GenPosArraysRemoveAt( index );
@@ -3669,38 +3900,38 @@ namespace Xceed.Wpf.DataGrid
 
     private int RemoveGeneratedItems( int startIndex, int endIndex, IList<DependencyObject> removedContainers )
     {
-      int genCountRemoved = 0;
+      if( startIndex > endIndex )
+        return 0;
+
+      var count = m_genPosToIndex.Count;
+      if( ( count <= 0 ) || ( m_genPosToIndex[ 0 ] > endIndex ) || ( m_genPosToIndex[ count - 1 ] < startIndex ) )
+        return 0;
+
+      var removed = 0;
 
       //cycle through the list of generated items, and see if any items are generated between the indexes in the removed range.
-      //start from the end so that removing an item will not cause the indexes to shift
-      for( int i = m_genPosToIndex.Count - 1; i >= 0; i-- )
+      //start from the end so that removing an item will not cause the indexes to shift.
+      for( var i = count - 1; i >= 0; i-- )
       {
-        Debug.Assert( ( m_genPosToContainer.Count != 0 )
-                      && ( m_genPosToIndex.Count != 0 )
-                      && ( m_genPosToItem.Count != 0 )
-                      && ( m_genPosToNode.Count != 0 ), "Internal Generator's lists are empty, cannot continue to process RemoveGeneratedItems" );
-#if LOG
-        Log.Assert( this, ( m_genPosToContainer.Count != 0 )
-                      && ( m_genPosToIndex.Count != 0 )
-                      && ( m_genPosToItem.Count != 0 )
-                      && ( m_genPosToNode.Count != 0 ), "Internal Generator's lists are empty, cannot continue to process RemoveGeneratedItems" );
-#endif
+        m_log.Assert( this, ( m_genPosToContainer.Count != 0 )
+                         && ( m_genPosToIndex.Count != 0 )
+                         && ( m_genPosToItem.Count != 0 )
+                         && ( m_genPosToNode.Count != 0 ), "Internal Generator's lists are empty, cannot continue to process RemoveGeneratedItems" );
 
-        int itemIndex = m_genPosToIndex[ i ];
+        var index = m_genPosToIndex[ i ];
 
         //if the item is within the range removed
-        if( ( itemIndex >= startIndex ) && ( itemIndex <= endIndex ) )
+        if( ( index >= startIndex ) && ( index <= endIndex ) )
         {
           //this will ensure to recurse the call to the appropriate Detail Generator for clearing of the container.
           //otherwise, it will only remove it from the list of container generated in the current generator instance.
           this.RemoveGeneratedItem( i, removedContainers );
 
-          //increment realized item count removed
-          genCountRemoved++;
+          removed++;
         }
       }
 
-      return genCountRemoved;
+      return removed;
     }
 
     private int RemoveGeneratedItems( GeneratorNode referenceNode, IList<DependencyObject> removedContainers )
@@ -3749,24 +3980,14 @@ namespace Xceed.Wpf.DataGrid
 
     private void RemoveAllGeneratedItems()
     {
-      this.RemoveAllGeneratedItems( false );
-    }
-
-    private void RemoveAllGeneratedItems( bool itemsSourceChanged )
-    {
-#if LOG
-      Log.Start( this, "RemoveAllGeneratedItems" );
-#endif
+      m_log.Assert( this.IsHandlingGlobalItemsReset, "IsHandlingGlobalItemsReset is not set." );
 
-      using( new ProcessingGlobalItemsResetOrRemovingAllGeneratedItemsDisposable( this ) )
+      using( m_log.BeginBlock( this, null ) )
       {
         //Call RemoveAllGeneratedItems() on all the detail generators
-        foreach( KeyValuePair<object, List<DetailGeneratorNode>> masterToDetails in m_masterToDetails )
+        foreach( var generator in this.GetDetailGenerators() )
         {
-          foreach( DetailGeneratorNode detailNode in masterToDetails.Value )
-          {
-            detailNode.DetailGenerator.RemoveAllGeneratedItems( itemsSourceChanged );
-          }
+          generator.RemoveAllGeneratedItems();
         }
 
         //then we can clean the list of items of items generated held by this generator
@@ -3791,10 +4012,6 @@ namespace Xceed.Wpf.DataGrid
           this.GenPosArraysRemoveAt( i );
         }
       }
-
-#if LOG
-      Log.End( this, "RemoveAllGeneratedItems" );
-#endif
     }
 
     private bool RemoveGeneratedItems( HeadersFootersGeneratorNode referenceNode, object referenceItem, IList<DependencyObject> removedContainers )
@@ -3869,9 +4086,7 @@ namespace Xceed.Wpf.DataGrid
         }
         else
         {
-#if LOG
-          Log.WriteLine( this, "UpdateHeaders - new tree" );
-#endif
+          m_log.WriteLine( this, "UpdateHeaders - new tree" );
         }
 
         //set the start node as the first header node.
@@ -3910,9 +4125,8 @@ namespace Xceed.Wpf.DataGrid
           else
           {
             m_startNode = m_firstFooter;
-#if LOG
-            Log.WriteLine( this, "UpdateFooters - new tree" );
-#endif
+
+            m_log.WriteLine( this, "UpdateFooters - new tree" );
           }
         }
       }
@@ -3933,7 +4147,6 @@ namespace Xceed.Wpf.DataGrid
 
     private GeneratorNode SetupInitialItemsNodes( out int addCount )
     {
-      //TODO ( case 117275 ): Check the amount of time this is executed for a single grid being populated!
       GeneratorNode newItemNode = null;
 
       addCount = 0;
@@ -3983,15 +4196,15 @@ namespace Xceed.Wpf.DataGrid
           }
           else
           {
-            throw new DataGridInternalException(); //this case should not be possible: no header, no footers but there is a startNode
+            //this case should not be possible: no header, no footers but there is a startNode
+            throw new DataGridInternalException( "No start node found for the current GeneratorNode.", m_dataGridControl );
           }
         }
         else
         {
           m_startNode = m_firstItem;
-#if LOG
-          Log.WriteLine( this, "SetupInitialItemsNodes - new tree" );
-#endif
+
+          m_log.WriteLine( this, "SetupInitialItemsNodes - new tree" );
         }
       }
 
@@ -4014,18 +4227,21 @@ namespace Xceed.Wpf.DataGrid
           //Registers to the groups collection change notification.
           CollectionChangedEventManager.AddListener( m_groupsCollection, this );
         }
-
       }
-
     }
 
     private GeneratorNode CreateStandaloneItemsNode()
     {
-      return this.NodeFactory.CreateItemsGeneratorNode( m_listInterface, null, null, null, this );
+      var list = CustomItemContainerGenerator.GetList( m_collectionView );
+
+      return this.NodeFactory.CreateItemsGeneratorNode( list, null, null, null, this );
     }
 
     private GeneratorNode CreateGroupListFromCollection( IList collection, GeneratorNode parentNode )
     {
+      if( collection.Count == 0 )
+        return null;
+
       GeneratorNode rootNode = null;
       GeneratorNode previousNode = null;
       GroupGeneratorNode actualNode = null;
@@ -4037,23 +4253,24 @@ namespace Xceed.Wpf.DataGrid
 
       ObservableCollection<GroupDescription> groupDescriptions = DataGridContext.GetGroupDescriptionsHelper( m_collectionView );
       GroupConfigurationSelector groupConfigurationSelector = m_dataGridContext.GroupConfigurationSelector;
-
+      LateGroupLevelDescription lateGroupLevelDescription = this.CreateOrGetLateGroupLevelDescription( level, groupDescriptions );
 
       foreach( CollectionViewGroup group in collection )
       {
         groupConfig = GroupConfiguration.GetGroupConfiguration( m_dataGridContext, groupDescriptions, groupConfigurationSelector, level, group );
 
-        Debug.Assert( groupConfig != null, "groupConfig != null" );
-#if LOG
-        Log.Assert( this, groupConfig != null, "groupConfig != null" );
-#endif
+        m_log.Assert( this, groupConfig != null, "groupConfig != null" );
 
         if( groupConfig.UseDefaultHeadersFooters )
+        {
           groupConfig.AddDefaultHeadersFooters();
+        }
 
         initiallyExpanded = groupConfig.InitiallyExpanded;
 
         actualNode = ( GroupGeneratorNode )this.NodeFactory.CreateGroupGeneratorNode( group, parentNode, previousNode, null, groupConfig );
+        actualNode.UIGroup = new Group( actualNode, group, lateGroupLevelDescription, m_dataGridContext );
+
         m_groupNodeMappingCache.Add( group, actualNode );
 
         if( rootNode == null )
@@ -4063,8 +4280,6 @@ namespace Xceed.Wpf.DataGrid
 
         previousNode = actualNode;
 
-        actualNode.UIGroup = new Group( actualNode, group, m_dataGridContext.GroupLevelDescriptions, m_dataGridContext );
-
         //Independently if the Group is the bottom level or not, we need to setup GroupHeaders
         childNode = this.SetupGroupHeaders( groupConfig, actualNode );
         actualNode.Child = childNode;
@@ -4072,7 +4287,6 @@ namespace Xceed.Wpf.DataGrid
         GeneratorNodeHelper childNodeHelper = new GeneratorNodeHelper( childNode, 0, 0 ); //do not care about index.
         childNodeHelper.MoveToEnd(); //extensibility, just in case SetupGroupHeaders() ever return a node list.
 
-
         IList<object> subItems = group.GetItems();
 
         //if the node newly created is not the bottom level
@@ -4103,12 +4317,50 @@ namespace Xceed.Wpf.DataGrid
       return rootNode;
     }
 
+    private LateGroupLevelDescription CreateOrGetLateGroupLevelDescription( int level, IList<GroupDescription> groupDescriptions )
+    {
+      Debug.Assert( groupDescriptions != null );
+
+      if( ( m_groupLevelDescriptionCache == null ) || ( level >= m_groupLevelDescriptionCache.Length ) )
+      {
+        var newSize = Math.Max( level + 1, groupDescriptions.Count );
+        Array.Resize<LateGroupLevelDescription>( ref m_groupLevelDescriptionCache, newSize );
+      }
+
+      var item = m_groupLevelDescriptionCache[ level ];
+      if( item == null )
+      {
+        var groupDescription = groupDescriptions[ level ];
+        Debug.Assert( groupDescription != null );
+
+        item = new LateGroupLevelDescription( groupDescription, m_dataGridContext.GroupLevelDescriptions );
+        m_groupLevelDescriptionCache[ level ] = item;
+      }
+
+      return item;
+    }
+
+    private void ClearLateGroupLevelDescriptions()
+    {
+      if( m_groupLevelDescriptionCache == null )
+        return;
+
+      for( int i = 0; i < m_groupLevelDescriptionCache.Length; i++ )
+      {
+        var item = m_groupLevelDescriptionCache[ i ];
+        if( item == null )
+          continue;
+
+        item.Clear();
+      }
+
+      m_groupLevelDescriptionCache = null;
+    }
+
     private GeneratorNode SetupGroupFooters( GroupConfiguration groupConfig, GeneratorNode actualNode )
     {
       if( groupConfig == null )
-      {
         return new GeneratorNode( actualNode );
-      }
 
       return this.NodeFactory.CreateHeadersFootersGeneratorNode( groupConfig.Footers, actualNode, null, null );
     }
@@ -4116,9 +4368,7 @@ namespace Xceed.Wpf.DataGrid
     private GeneratorNode SetupGroupHeaders( GroupConfiguration groupConfig, GeneratorNode actualNode )
     {
       if( groupConfig == null )
-      {
         return new GeneratorNode( actualNode );
-      }
 
       return this.NodeFactory.CreateHeadersFootersGeneratorNode( groupConfig.Headers, actualNode, null, null );
     }
@@ -4130,10 +4380,8 @@ namespace Xceed.Wpf.DataGrid
       // start by moving to the first child... of the node (GroupHeaders node, most probably).
       // false parameter is to prevent skipping over a collapsed node (item count 0 )
       if( !nodeHelper.MoveToChild( false ) )
-      {
         //could not advance to the child item so there is no items to be removed...
-        throw new DataGridInternalException();
-      }
+        throw new DataGridInternalException( "No child item in the group to remove.", m_dataGridControl );
 
       return this.HandleSameLevelGroupRemove( nodeHelper.CurrentNode, out countRemoved, out genCountRemoved, out removeIndex, e, removedContainers );
     }
@@ -4148,18 +4396,16 @@ namespace Xceed.Wpf.DataGrid
       GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( firstChild, 0, 0 );
       nodeHelper.ReverseCalculateIndex();
 
-      //Advance to the first "Group" node (skip the GroupHEaders)
+      //Advance to the first "Group" node (skip the GroupHeaders)
       while( !( nodeHelper.CurrentNode is GroupGeneratorNode ) )
       {
         if( !nodeHelper.MoveToNext() )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "Unable to move to next GeneratorNode.", m_dataGridControl );
       }
 
       //then move up to the removal start point.
       if( !nodeHelper.MoveToNextBy( e.OldStartingIndex ) )
-      {
-        throw new DataGridInternalException();
-      }
+        throw new DataGridInternalException( "Unable to move to the requested generator index.", m_dataGridControl );
 
       GroupGeneratorNode startNode = nodeHelper.CurrentNode as GroupGeneratorNode;
       removeIndex = -1;
@@ -4191,17 +4437,9 @@ namespace Xceed.Wpf.DataGrid
       return retval;
     }
 
-    private GroupGeneratorNode ProcessGroupRemoval(
-      GeneratorNode startNode,
-      int removeCount,
-      bool updateGroupNodeMappingCache,
-      out int countRemoved )
+    private GroupGeneratorNode ProcessGroupRemoval( GeneratorNode startNode, int removeCount, bool updateGroupNodeMappingCache, out int countRemoved )
     {
-
-      Debug.Assert( removeCount != 0, "remove count cannot be 0" );
-#if LOG
-      Log.Assert( this, removeCount != 0, "remove count cannot be 0" );
-#endif
+      m_log.Assert( this, removeCount != 0, "remove count cannot be 0" );
 
       GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( startNode, 0, 0 );//index not important.
       GroupGeneratorNode parentGroup = startNode.Parent as GroupGeneratorNode;
@@ -4218,10 +4456,7 @@ namespace Xceed.Wpf.DataGrid
           m_groupNodeMappingCache.Remove( group.CollectionViewGroup );
         }
 
-        Debug.Assert( group != null, "node to be removed must be a GroupGeneratorNode" );
-#if LOG
-        Log.Assert( this, group != null, "node to be removed must be a GroupGeneratorNode" );
-#endif
+        m_log.Assert( this, group != null, "node to be removed must be a GroupGeneratorNode" );
 
         //add the total number of child to the count of items removed.
         countRemoved += group.ItemCount;
@@ -4231,11 +4466,7 @@ namespace Xceed.Wpf.DataGrid
         if( i < removeCount )
         {
           if( !nodeHelper.MoveToNext() )
-          {
-            //could not advance to the last item to be removed...
-
-            throw new DataGridInternalException();
-          }
+            throw new DataGridInternalException( "Could not move to the last node to be removed.", m_dataGridControl );
         }
       }
       while( i < removeCount );
@@ -4244,51 +4475,346 @@ namespace Xceed.Wpf.DataGrid
       GeneratorNode previous = startNode.Previous;
       GeneratorNode next = nodeHelper.CurrentNode.Next;
 
-      if( next != null )
-      {
-        next.Previous = previous;
-      }
+      if( next != null )
+      {
+        next.Previous = previous;
+      }
+
+      if( previous != null )
+      {
+        previous.Next = next;
+      }
+
+      //if the first node removed was the first child of its parent
+      if( ( parentGroup != null ) && ( parentGroup.Child == startNode ) )
+      {
+        //set the next in line after the chain to be removed as the first child
+        parentGroup.Child = next;
+      }
+
+      //break the link between the chain and its same-level siblings.
+      nodeHelper.CurrentNode.Next = null;
+      startNode.Previous = null;
+
+      //Here, I need a special handling case... If I remove the first group node, I need to set a new firstItem
+      if( startNode == m_firstItem )
+      {
+        if( next != m_firstFooter )
+        {
+          m_firstItem = next;
+        }
+        else
+        {
+          m_firstItem = null;
+        }
+
+        if( m_startNode == startNode )
+        {
+          m_startNode = next;
+        }
+      }
+
+      m_log.Assert( this, nodeHelper.CurrentNode is GroupGeneratorNode, "last node is not a GroupGeneratorNode" );
+
+      return ( GroupGeneratorNode )nodeHelper.CurrentNode;
+    }
+
+    private void HandleSameLevelGroupReset( GeneratorNode node )
+    {
+      Debug.Assert( node != null );
+
+      var parentNode = node.Parent as GroupGeneratorNode;
+      var oldGroups = new List<CollectionViewGroup>();
+      var nodeHelper = new GeneratorNodeHelper( node, 0, 0 );
+
+      do
+      {
+        var groupNode = nodeHelper.CurrentNode as GroupGeneratorNode;
+        if( groupNode != null )
+        {
+          Debug.Assert( groupNode.CollectionViewGroup != null );
+          oldGroups.Add( groupNode.CollectionViewGroup );
+        }
+      }
+      while( nodeHelper.MoveToNext() );
+
+      var newGroups = ( parentNode != null )
+                        ? parentNode.CollectionViewGroup.GetItems().Cast<CollectionViewGroup>().ToList()
+                        : m_groupsCollection.Cast<CollectionViewGroup>().ToList();
+
+      Debug.Assert( ( oldGroups.Count > 0 ), "The group being reset should have had at least a child group." );
+      Debug.Assert( ( newGroups.Count > 0 ), "The group being reset should have at least a child group." );
+
+      // If nothing has changed, avoid the heavy process of finding out which groups have been added,
+      // removed and moved.
+      if( newGroups.Count == oldGroups.Count )
+      {
+        if( newGroups.SequenceEqual( oldGroups ) )
+          return;
+      }
+
+      var groupsAdded = default( ICollection<CollectionViewGroup> );
+      var groupsRemoved = default( ICollection<CollectionViewGroup> );
+      var groupsMoved = default( ICollection<CollectionViewGroup> );
+
+      this.GetGroupChanges( oldGroups, newGroups, out groupsAdded, out groupsRemoved, out groupsMoved );
+
+      if( groupsAdded.Count + groupsRemoved.Count + groupsMoved.Count > CustomItemContainerGenerator.GlobalItemsResetThreshold )
+      {
+        this.HandleGlobalItemsReset();
+      }
+      else
+      {
+        this.ApplyGroupChanges( node, oldGroups, newGroups, groupsAdded, groupsRemoved, groupsMoved );
+      }
+    }
+
+    private void GetGroupChanges(
+      IList<CollectionViewGroup> oldGroups,
+      IList<CollectionViewGroup> newGroups,
+      out ICollection<CollectionViewGroup> groupsAdded,
+      out ICollection<CollectionViewGroup> groupsRemoved,
+      out ICollection<CollectionViewGroup> groupsMoved )
+    {
+      Debug.Assert( oldGroups != null );
+      Debug.Assert( newGroups != null );
+
+      groupsAdded = new HashSet<CollectionViewGroup>();
+      groupsRemoved = new HashSet<CollectionViewGroup>();
+      groupsMoved = new HashSet<CollectionViewGroup>();
+
+      var oldGroupsPositions = new Dictionary<CollectionViewGroup, int>();
+
+      for( var i = 0; i < oldGroups.Count; i++ )
+      {
+        oldGroupsPositions.Add( oldGroups[ i ], i );
+      }
+
+      var sequence = new List<int>( newGroups.Count );
+      var isAlive = new BitArray( oldGroups.Count, false );
+
+      foreach( var group in newGroups )
+      {
+        int index;
+
+        if( oldGroupsPositions.TryGetValue( group, out index ) )
+        {
+          isAlive[ index ] = true;
+          sequence.Add( index );
+        }
+        else
+        {
+          Debug.Assert( !m_groupNodeMappingCache.ContainsKey( group ), "How come there is a node for the group." );
+
+          groupsAdded.Add( group );
+        }
+      }
+
+      var hasNotMoved = new BitArray( oldGroups.Count, false );
+
+      // The subsequence contains the position of the old groups that are in the new groups and that have not moved.
+      foreach( var index in LongestIncreasingSubsequence.Find( sequence ) )
+      {
+        hasNotMoved[ index ] = true;
+      }
+
+      for( var i = 0; i < oldGroups.Count; i++ )
+      {
+        if( isAlive[ i ] )
+        {
+          if( !hasNotMoved[ i ] )
+          {
+            groupsMoved.Add( oldGroups[ i ] );
+          }
+        }
+        else
+        {
+          groupsRemoved.Add( oldGroups[ i ] );
+        }
+      }
+    }
+
+    private void ApplyGroupChanges(
+      GeneratorNode node,
+      IList<CollectionViewGroup> oldGroups,
+      IList<CollectionViewGroup> newGroups,
+      ICollection<CollectionViewGroup> groupsAdded,
+      ICollection<CollectionViewGroup> groupsRemoved,
+      ICollection<CollectionViewGroup> groupsMoved )
+    {
+      Debug.Assert( node != null );
+
+      var parentNode = node.Parent as GroupGeneratorNode;
+      var insertAfter = !( node is GroupGeneratorNode );
+
+      if( ( groupsRemoved.Count > 0 ) || ( groupsMoved.Count > 0 ) )
+      {
+        var removeNodeHelper = new GeneratorNodeHelper( m_groupNodeMappingCache[ oldGroups.Last() ], 0, 0 );
+        removeNodeHelper.ReverseCalculateIndex();
+
+        for( int i = oldGroups.Count - 1; i >= 0; i-- )
+        {
+          var group = oldGroups[ i ];
+          var removed = groupsRemoved.Contains( group );
+          var moved = ( !removed && groupsMoved.Contains( group ) );
+
+          if( removed || moved )
+          {
+            var groupNode = removeNodeHelper.CurrentNode;
+            Debug.Assert( ( groupNode != null ) && ( groupNode == m_groupNodeMappingCache[ group ] ) );
+
+            if( groupNode == node )
+            {
+              Debug.Assert( !( groupNode.Previous is GroupGeneratorNode ), "How come the node was not the first GroupGeneratorNode." );
+
+              node = groupNode.Next;
+              insertAfter = false;
+            }
+
+            var startIndex = removeNodeHelper.Index;
+            int count;
+
+            removeNodeHelper.MoveToPrevious();
+
+            if( removed )
+            {
+              this.ProcessGroupRemoval( groupNode, 1, true, out count );
+              this.NodeFactory.CleanGeneratorNodeTree( groupNode );
+            }
+            else
+            {
+              this.ProcessGroupRemoval( groupNode, 1, false, out count );
+            }
+
+            if( count > 0 )
+            {
+              this.RemoveGeneratedItems( startIndex, startIndex + count - 1, null );
+            }
+          }
+          else
+          {
+            removeNodeHelper.MoveToPrevious();
+          }
+        }
+      }
+
+      if( ( groupsAdded.Count > 0 ) || ( groupsMoved.Count > 0 ) )
+      {
+        var firstGroup = newGroups[ 0 ];
+        var added = groupsAdded.Contains( firstGroup );
+        var moved = ( !added && groupsMoved.Contains( firstGroup ) );
+
+        if( added || moved )
+        {
+          var groupNode = default( GeneratorNode );
+
+          if( added )
+          {
+            groupNode = this.CreateGroupListFromCollection( new object[] { firstGroup }, parentNode );
+          }
+          else
+          {
+            groupNode = m_groupNodeMappingCache[ firstGroup ];
+          }
+
+          Debug.Assert( groupNode != null );
+
+          if( node != null )
+          {
+            var addNodeHelper = new GeneratorNodeHelper( node, 0, 0 );
+
+            if( insertAfter )
+            {
+              addNodeHelper.InsertAfter( groupNode );
+            }
+            else
+            {
+              addNodeHelper.InsertBefore( groupNode );
+              insertAfter = true;
+            }
+
+            if( parentNode == null )
+            {
+              if( m_startNode == m_firstItem )
+              {
+                m_startNode = groupNode;
+              }
+
+              m_firstItem = groupNode;
+            }
+          }
+          else
+          {
+            if( parentNode == null )
+            {
+              m_firstItem = groupNode;
+
+              if( m_startNode != null )
+              {
+                if( m_firstFooter != null )
+                {
+                  var addNodeHelper = new GeneratorNodeHelper( m_firstFooter, 0, 0 );
+                  addNodeHelper.InsertBefore( groupNode );
+                }
+                else if( m_firstHeader != null )
+                {
+                  var addNodeHelper = new GeneratorNodeHelper( m_firstHeader, 0, 0 );
+                  addNodeHelper.MoveToEnd();
+                  addNodeHelper.InsertAfter( groupNode );
+                }
+                else
+                {
+                  throw new DataGridInternalException( "No start node found for the current GeneratorNode.", m_dataGridControl );
+                }
+              }
+              else
+              {
+                m_startNode = groupNode;
+              }
+            }
+            else
+            {
+              Debug.Assert( parentNode.Child != null );
+
+              var addNodeHelper = new GeneratorNodeHelper( parentNode.Child, 0, 0 );
+              addNodeHelper.MoveToEnd();
+              addNodeHelper.InsertAfter( groupNode );
+            }
+          }
+
+          node = groupNode;
+        }
+
+        for( var i = 1; i < newGroups.Count; i++ )
+        {
+          var group = newGroups[ i ];
+
+          added = groupsAdded.Contains( group );
+          moved = ( !added && groupsMoved.Contains( group ) );
 
-      if( previous != null )
-      {
-        previous.Next = next;
-      }
+          if( !added && !moved )
+            continue;
 
-      //if the first node removed was the first child of its parent
-      if( ( parentGroup != null ) && ( parentGroup.Child == startNode ) )
-      {
-        //set the next in line after the chain to be removed as the first child
-        parentGroup.Child = next;
-      }
+          var groupNode = default( GeneratorNode );
 
-      //break the link between the chain and its same-level siblings.
-      nodeHelper.CurrentNode.Next = null;
-      startNode.Previous = null;
+          if( added )
+          {
+            groupNode = this.CreateGroupListFromCollection( new object[] { group }, parentNode );
+          }
+          else
+          {
+            groupNode = m_groupNodeMappingCache[ group ];
+          }
 
-      //Here, I need a special handling case... If I remove the first group node, I need to set a new firstItem
-      if( startNode == m_firstItem )
-      {
-        if( next != m_firstFooter )
-        {
-          m_firstItem = next;
-        }
-        else
-        {
-          m_firstItem = null;
-        }
+          Debug.Assert( groupNode != null );
 
-        if( m_startNode == startNode )
-        {
-          m_startNode = next;
+          var addNodeHelper = new GeneratorNodeHelper( m_groupNodeMappingCache[ newGroups[ i - 1 ] ], 0, 0 );
+          addNodeHelper.InsertAfter( groupNode );
         }
       }
 
-      Debug.Assert( nodeHelper.CurrentNode is GroupGeneratorNode, "last node is not a GroupGeneratorNode" );
-#if LOG
-      Log.Assert( this, nodeHelper.CurrentNode is GroupGeneratorNode, "last node is not a GroupGeneratorNode" );
-#endif
-
-      return ( GroupGeneratorNode )nodeHelper.CurrentNode;
+      this.IncrementCurrentGenerationCount();
+      this.SendResetEvent();
     }
 
     private void HandleSameLevelGroupMove( GeneratorNode node, NotifyCollectionChangedEventArgs e )
@@ -4303,14 +4829,12 @@ namespace Xceed.Wpf.DataGrid
       while( !( nodeHelper.CurrentNode is GroupGeneratorNode ) )
       {
         if( !nodeHelper.MoveToNext() )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "Unable to move to next GeneratorNode.", m_dataGridControl );
       }
 
       //then move up to the removal start point.
       if( !nodeHelper.MoveToNextBy( e.OldStartingIndex ) )
-      {
-        throw new DataGridInternalException();
-      }
+        throw new DataGridInternalException( "Unable to move to the requested generator index.", m_dataGridControl );
 
       //remember the current node as the start point of the move (will be used when "extracting the chain")
       GeneratorNode startNode = nodeHelper.CurrentNode;
@@ -4334,7 +4858,7 @@ namespace Xceed.Wpf.DataGrid
       node = ( parentGroup != null ) ? parentGroup.Child : m_firstItem;
 
       if( node == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "No node found to move.", m_dataGridControl );
 
       //Once the chain was pulled out, re-insert it at the appropriate location.
       nodeHelper = new GeneratorNodeHelper( node, 0, 0 ); //do not care about the index for what I need
@@ -4343,7 +4867,7 @@ namespace Xceed.Wpf.DataGrid
       while( !( nodeHelper.CurrentNode is GroupGeneratorNode ) )
       {
         if( !nodeHelper.MoveToNext() )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "Unable to move to next GeneratorNode.", m_dataGridControl );
       }
 
       bool insertBefore = nodeHelper.MoveToNextBy( e.NewStartingIndex );
@@ -4374,11 +4898,7 @@ namespace Xceed.Wpf.DataGrid
 
     private GeneratorNode HandleSameLevelGroupAddition( GeneratorNode firstChild, out int countAdded, NotifyCollectionChangedEventArgs e )
     {
-
-      Debug.Assert( ( ( firstChild.Parent == null ) || ( firstChild.Parent is GroupGeneratorNode ) ), "parent of the node should be a GroupGeneratorNode" );
-#if LOG
-      Log.Assert( this, ( ( firstChild.Parent == null ) || ( firstChild.Parent is GroupGeneratorNode ) ), "parent of the node should be a GroupGeneratorNode" );
-#endif
+      m_log.Assert( this, ( ( firstChild.Parent == null ) || ( firstChild.Parent is GroupGeneratorNode ) ), "parent of the node should be a GroupGeneratorNode" );
 
       GeneratorNode newNodeChain = this.CreateGroupListFromCollection( e.NewItems, firstChild.Parent );
 
@@ -4444,12 +4964,8 @@ namespace Xceed.Wpf.DataGrid
       GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( parent, 0, 0 ); //do not care about index (for now).
 
       //start by moving to the first child... of the node (GroupHeaders node, most probably).
-      if( !nodeHelper.MoveToChild( false ) ) //case 120137: false parameter is to prevent skipping over a collapsed node (item count 0 )
-      {
-        //could not advance to the child item so there is no items to be removed...
-
-        throw new DataGridInternalException();
-      }
+      if( !nodeHelper.MoveToChild( false ) ) 
+        throw new DataGridInternalException( "Could not move to the child node to be removed.", m_dataGridControl );
 
       return this.HandleSameLevelGroupAddition( nodeHelper.CurrentNode, out countAdded, e );
     }
@@ -4481,44 +4997,10 @@ namespace Xceed.Wpf.DataGrid
         //and send notification message
         this.SendAddEvent( addGenPos, startIndex, e.NewItems.Count );
       }
-    }
-
-    private void OffsetDetails( ItemsGeneratorNode node, int startIndex, int addOffset )
-    {
-      if( ( node.Details == null ) || ( node.Details.Count == 0 ) )
-        return;
-
-      int detailsCount = node.Details.Count;
-      //first, create an array that will contain the keys for all the expanded details from the ItemsGeneratorNode
-      int[] keys = new int[ detailsCount ];
-      node.Details.Keys.CopyTo( keys, 0 );
-
-      //sort the array, this will prevent any operation that will duplicate keys in the dictionary.
-      Array.Sort<int>( keys );
-
-      //loop from the end of the sorted array to the beginning. to ensuyre
-      for( int i = detailsCount - 1; i >= 0; i-- )
+      else
       {
-        int key = keys[ i ];
-
-        //only process the key if it is in the processed range
-        if( key >= startIndex )
-        {
-          List<DetailGeneratorNode> details;
-          if( node.Details.TryGetValue( key, out details ) )
-          {
-#if LOG
-            Log.WriteLine( this, "details.Offset for Add - IN" + node.GetHashCode().ToString() + "- Di" + key.ToString() + " - new Di" + ( key + addOffset ).ToString() );
-#endif
-            node.Details.Remove( key );
-            node.Details.Add( key + addOffset, details );
-          }
-          else
-          {
-            //Key not found in the dictionary, something wrong is going on.
-            throw new DataGridInternalException();
-          }
-        }
+        //An item can be added in the source without the need to regenerate the containers, but still provoke a change to the realized containers' corresponding source index.
+        this.UpdateContainersIndex();
       }
     }
 
@@ -4545,13 +5027,10 @@ namespace Xceed.Wpf.DataGrid
       int removeCount = e.OldItems.Count + detailCountToRemove;
       int replaceCount = ( e.Action == NotifyCollectionChangedAction.Replace ) ? e.NewItems.Count : 0;
 
-      // *** RemoveDetails must be done before GeneratorPositionFromIndex, since GeneratorPositionFromIndex will indirectly do a RemapFloatingDetails
-      // *** that will cause the index to already be rectified and make a double rectification to occurs.
-
       //Remove the details from the ItemsGeneratorNode and re-index the other details appropriatly.
       this.RemoveDetails( node, nodeStartIndex, nodeEndIndex, replaceCount );
 
-      GeneratorPosition removeGenPos = this.GeneratorPositionFromIndex( startIndex );
+      GeneratorPosition removeGenPos = this.GetSafeGeneratorPositionFromIndex( startIndex );
 
       //Try to remap the old item for detail remapping (will do nothing if item has no details )
       foreach( object oldItem in e.OldItems )
@@ -4559,9 +5038,11 @@ namespace Xceed.Wpf.DataGrid
         this.QueueDetailItemForRemapping( oldItem );
       }
 
+      bool needsUpdateToIndexes = true;
       //if the node is totally expanded
       if( node.IsComputedExpanded )
       {
+        needsUpdateToIndexes = false;
         List<DependencyObject> removedContainers = new List<DependencyObject>();
         int genRemCount = this.RemoveGeneratedItems( startIndex, endIndex, removedContainers );
 
@@ -4583,13 +5064,18 @@ namespace Xceed.Wpf.DataGrid
           break;
 
         case NotifyCollectionChangedAction.Remove:
-          // Do nothing!
+          if( needsUpdateToIndexes )
+          {
+            //An item can be removed from the source without the need to regenerate the containers,
+            //but still provoke a change to the realized containers' corresponding source index.
+            this.UpdateContainersIndex();
+          }
           break;
 
         case NotifyCollectionChangedAction.Add:
         case NotifyCollectionChangedAction.Reset:
-        default:
-          throw new DataGridInternalException();
+          DataGridException.ThrowSystemException( "Add or Reset not supported at the moment on groups.", typeof( NotSupportedException ), m_dataGridControl.Name );
+          break;
       }
 
     }
@@ -4605,6 +5091,87 @@ namespace Xceed.Wpf.DataGrid
       this.SendAddEvent( new GeneratorPosition( -1, 1 ), nodeIndex + e.NewStartingIndex, e.NewItems.Count );
     }
 
+    private void UpdateContainersIndex()
+    {
+      DataGridCollectionView collectionView = m_collectionView.SourceCollection as DataGridCollectionView;
+      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+      int currentIndex = -1;
+      int offset = 0;
+      int sourceItemIndex;
+
+      foreach( object item in m_genPosToItem )
+      {
+        currentIndex++;
+
+        //If the item is not found, it means it belongs to a detail grid, no need to process it.
+        if( nodeHelper.FindItem( item ) == -1 )
+          continue;
+
+        //If we're not on a ItemsGeneratorNode, it means we are not on a DataRow, so no need to process it (all ItemIndex == -1 in this case).
+        ItemsGeneratorNode itemsNode = nodeHelper.CurrentNode as ItemsGeneratorNode;
+        if( itemsNode == null )
+        {
+          offset = 0;
+          continue;
+        }
+
+        //If we have a DataGridCollectionView, let's get the sorted index from it in case there are details expanded.
+        if( collectionView != null )
+        {
+          sourceItemIndex = collectionView.GetGlobalSortedIndexFromDataItem( item );
+        }
+        //If not a DGCV, it means there are no details, so this will work fine.
+        else
+        {
+          if( offset == 0 )
+          {
+            //This will make sure we get the right index in case the group is patially scrolled.
+            offset = itemsNode.IndexOf( item );
+          }
+          sourceItemIndex = nodeHelper.SourceDataIndex + offset++;
+        }
+        DataGridVirtualizingPanel.SetItemIndex( m_genPosToContainer[ currentIndex ], sourceItemIndex );
+      }
+    }
+
+    private void OffsetDetails( ItemsGeneratorNode node, int startIndex, int addOffset )
+    {
+      if( ( node.Details == null ) || ( node.Details.Count == 0 ) )
+        return;
+
+      int detailsCount = node.Details.Count;
+      //first, create an array that will contain the keys for all the expanded details from the ItemsGeneratorNode
+      int[] keys = new int[ detailsCount ];
+      node.Details.Keys.CopyTo( keys, 0 );
+
+      //sort the array, this will prevent any operation that will duplicate keys in the dictionary.
+      Array.Sort<int>( keys );
+
+      //loop from the end of the sorted array to the beginning. to ensuyre
+      for( int i = detailsCount - 1; i >= 0; i-- )
+      {
+        int key = keys[ i ];
+
+        //only process the key if it is in the processed range
+        if( key >= startIndex )
+        {
+          List<DetailGeneratorNode> details;
+          if( node.Details.TryGetValue( key, out details ) )
+          {
+            m_log.WriteLine( this, "details.Offset for Add - IN" + node.GetHashCode().ToString() + "- Di" + key.ToString() + " - new Di" + ( key + addOffset ).ToString() );
+
+            node.Details.Remove( key );
+            node.Details.Add( key + addOffset, details );
+          }
+          else
+          {
+            //Key not found in the dictionary, something wrong is going on.
+            throw new DataGridInternalException( "Key not found in Details dictionary.", m_dataGridControl );
+          }
+        }
+      }
+    }
+
     private void RemoveDetails( ItemsGeneratorNode node, int nodeStartIndex, int nodeEndIndex, int replaceCount )
     {
       if( ( node.Details == null ) || ( node.Details.Count == 0 ) )
@@ -4642,9 +5209,7 @@ namespace Xceed.Wpf.DataGrid
             }
             details.Clear(); //note: detail generators will be "closed" by another section of code (Remap floating details).
 
-#if LOG
-            Log.WriteLine( this, "details.Remove - IN" + node.GetHashCode().ToString() + " - Di" + key.ToString() );
-#endif
+            m_log.WriteLine( this, "details.Remove - IN" + node.GetHashCode().ToString() + " - Di" + key.ToString() );
 
             node.Details.Remove( key );
 
@@ -4656,7 +5221,7 @@ namespace Xceed.Wpf.DataGrid
           else
           {
             //Key not found in the dictionary, something wrong is going on.
-            throw new DataGridInternalException();
+            throw new DataGridInternalException( "Key not found in Details dictionary within the remove range.", m_dataGridControl );
           }
         }
         //If the key is above the remove range, re-key it appropriatly.
@@ -4665,16 +5230,15 @@ namespace Xceed.Wpf.DataGrid
           List<DetailGeneratorNode> details;
           if( node.Details.TryGetValue( key, out details ) )
           {
-#if LOG
-            Log.WriteLine( this, "details.offset for remove - IN" + node.GetHashCode().ToString() + "- Di" + key.ToString() + " - new Di" + ( key - removeCount ).ToString() );
-#endif
+            m_log.WriteLine( this, "details.offset for remove - IN" + node.GetHashCode().ToString() + "- Di" + key.ToString() + " - new Di" + ( key - removeCount ).ToString() );
+
             node.Details.Remove( key );
             node.Details.Add( key - removeCount, details );
           }
           else
           {
             //Key not found in the dictionary, something wrong is going on.
-            throw new DataGridInternalException();
+            throw new DataGridInternalException( "Key not found in Details dictionary above the remove range.", m_dataGridControl );
           }
         }
       }
@@ -4735,9 +5299,7 @@ namespace Xceed.Wpf.DataGrid
           }
         }
 
-#if LOG
-        Log.WriteLine( this, "details.Clear - IN" + itemsNode.GetHashCode().ToString() );
-#endif
+        m_log.WriteLine( this, "details.Clear - IN" + itemsNode.GetHashCode().ToString() );
 
         itemsNode.Details.Clear();
         itemsNode.Details = null;
@@ -4856,35 +5418,21 @@ namespace Xceed.Wpf.DataGrid
 
     private void HandleGlobalItemsReset()
     {
-      this.HandleGlobalItemsReset( false );
-    }
-
-    private void HandleGlobalItemsReset( bool itemsSourceChanged )
-    {
-      Debug.Assert( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount == 0, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
-#if LOG
-      Log.Start( this, "HandleGlobalItemsReset" );
-#endif
+      m_log.Assert( this, !this.IsHandlingGlobalItemsResetLocally, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
 
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
-      {
-#if LOG
-        Log.End( this, "HandleGlobalItemsReset - Ignored 1" );
-#endif
+      if( this.IsHandlingGlobalItemsResetLocally )
         return;
-      }
 
       if( m_startNode == null )
       {
-#if LOG
-        Log.End( this, "HandleGlobalItemsReset - Ignored 2" );
-#endif
+        m_log.WriteLine( this, "No starting node in HandleGlobalItemsReset." );
         return;
       }
 
-      using( new ProcessingGlobalItemsResetOrRemovingAllGeneratedItemsDisposable( this ) )
+      using( m_log.BeginBlock( this, null ) )
+      using( this.SetIsHandlingGlobalItemsResetLocally() )
       {
-        this.RemoveAllGeneratedItems( itemsSourceChanged );
+        this.RemoveAllGeneratedItems();
 
         //No need to clean any more Master/Detail stuff, effectivelly, the call to ClearItems() below will clean the nodes themselves...
         //generator will then be able to remap.
@@ -4892,6 +5440,8 @@ namespace Xceed.Wpf.DataGrid
         //if there are items to start with!!!
         if( m_firstItem != null )
         {
+          m_dataGridControl.SaveDataGridContextState( m_dataGridContext, true, int.MaxValue );
+
           //requeue all opened details for remapping!
           foreach( object item in m_masterToDetails.Keys )
           {
@@ -4907,34 +5457,10 @@ namespace Xceed.Wpf.DataGrid
           //Note: There is no need to Clear the recyclingManager since this only represents a reset of the Items (not the headers and footers nodes)
           //and that the list of containers to be recycled is not "invalidated"
 
-          try
-          {
-            this.IsHandlingItemsRecreation = true;
-            this.HandleItemsRecreation();
-            m_dataGridControl.RestoreDataGridContextState( m_dataGridContext );
-          }
-          finally
-          {
-            this.IsHandlingItemsRecreation = false;
-          }
         }
 
         this.SendResetEvent();
-
-        if( itemsSourceChanged )
-        {
-          IList<DependencyObject> removedContainers = m_dataGridContext.RecyclingManager.Clear();
-          //Do not remove the Generator's reference to the RecyclingManager as all we want is to empty it!
-          //Effectivelly, for an items source change (only time where this method is called with notify == true ) we need
-          //to get rid of the containers.
-
-          this.NotifyContainersRemoved( removedContainers );
-        }
       }
-
-#if LOG
-      Log.End( this, "HandleGlobalItemsReset" );
-#endif
     }
 
     internal void EnsureNodeTreeCreated()
@@ -4946,15 +5472,12 @@ namespace Xceed.Wpf.DataGrid
       if( this.IsEnsuringNodeTreeCreated )
         return;
 
-      this.IsEnsuringNodeTreeCreated = true;
-
-      try
+      using( this.SetIsEnsuringNodeTreeCreated() )
       {
         if( m_startNode == null )
         {
-#if LOG
-          Log.WriteLine( this, "EnsureNodeTreeCreated - new tree" );
-#endif
+          m_log.WriteLine( this, "EnsureNodeTreeCreated - new tree" );
+
           int addCount;
 
           this.UpdateHeaders( m_dataGridContext.Headers );
@@ -4974,10 +5497,6 @@ namespace Xceed.Wpf.DataGrid
 
         m_dataGridControl.RestoreDataGridContextState( m_dataGridContext );
       }
-      finally
-      {
-        this.IsEnsuringNodeTreeCreated = false;
-      }
     }
 
     private void HandleItemsRecreation()
@@ -4987,43 +5506,20 @@ namespace Xceed.Wpf.DataGrid
       GeneratorNode addNode = this.SetupInitialItemsNodes( out resetAddCount );
 
       if( addNode != null )
+      {
         this.IncrementCurrentGenerationCount();
+      }
     }
 
     private void UpdateGenPosToIndexList()
     {
-#if LOG
-      int count = m_genPosToIndex.Count;
-      int previousIndex = -1;
-
-      for( int i = 0; i < count; i++ )
-      {
-        int tempIndex = m_genPosToIndex[ i ];
+      this.ValidateIndexOrder( "Before" );
 
-        if( tempIndex >= previousIndex )
-        {
-          previousIndex = tempIndex;
-        }
-        else
-        {
-          Debug.Assert( false, "### none sequential index detected (before)" );
-          Log.Assert( this, false, "### none sequential index detected (before)" );
-          this.WriteStateInLog();
-          break;
-        }
-      }
-#endif
       //after the modification to have the item count stored "locally" in the DetailGeneratorNodes,
       //it becomes important to have the nodes updated when the layout of the items changes.
-      if( m_masterToDetails.Count > 0 )
+      foreach( var detailNode in this.GetDetailGeneratorNodes() )
       {
-        foreach( KeyValuePair<object, List<DetailGeneratorNode>> masterToDetails in m_masterToDetails )
-        {
-          foreach( DetailGeneratorNode detailNode in masterToDetails.Value )
-          {
-            detailNode.UpdateItemCount();
-          }
-        }
+        detailNode.UpdateItemCount();
       }
 
       if( m_startNode != null )
@@ -5058,16 +5554,8 @@ namespace Xceed.Wpf.DataGrid
             }
             else
             {
-#if LOG
-              if( item == null )
-              {
-                Log.WriteLine( this, "# UpdateGenPosToIndexList - item not found Dnull" );
-              }
-              else
-              {
-                Log.WriteLine( this, "# UpdateGenPosToIndexList - Item not found D" + item.GetHashCode() );
-              }
-#endif
+              m_log.WriteLine( this, CustomItemContainerGenerator.FormatObjectId( "# UpdateGenPosToIndexList - item not found D", item ) );
+
               //a possible fix for this is to set the index of the "not found" element to the same index as previous item in the generated list...
               m_genPosToIndex[ i ] = ( i > 0 ) ? m_genPosToIndex[ i - 1 ] : 0;
 
@@ -5090,27 +5578,7 @@ namespace Xceed.Wpf.DataGrid
         } //end for()
       }
 
-#if LOG
-      count = m_genPosToIndex.Count;
-      previousIndex = -1;
-
-      for( int i = 0; i < count; i++ )
-      {
-        int tempIndex = m_genPosToIndex[ i ];
-
-        if( tempIndex >= previousIndex )
-        {
-          previousIndex = tempIndex;
-        }
-        else
-        {
-          Debug.Assert( false, "### none sequential index detected (after)" );
-          Log.Assert( this, false, "### none sequential index detected (after)" );
-          this.WriteStateInLog();
-          break;
-        }
-      }
-#endif
+      this.ValidateIndexOrder( "After" );
     }
 
     private int IndexFromRealizedItem( object referenceItem, int startIndex, out int foundIndex )
@@ -5135,97 +5603,42 @@ namespace Xceed.Wpf.DataGrid
 
     private int FindGlobalIndexForDetailNode( DetailGeneratorNode detailNode )
     {
-      int retval = -1;
-
-      //first thing, loop through the details for the 
-      foreach( KeyValuePair<object, List<DetailGeneratorNode>> masterItemToDetails in m_masterToDetails )
-      {
-        //in each master to details entry, try to find the detail node passed
-        int detailIndex = masterItemToDetails.Value.IndexOf( detailNode );
-        if( detailIndex != -1 )
-        {
-          //if the desired detailNode is present for this master item... then evaluate it...
-          int detailNodeOffset = 0;
-          for( int i = 0; i < detailIndex; i++ )
-          {
-            detailNodeOffset += masterItemToDetails.Value[ i ].ItemCount - 1;
-          }
-
-          int index = m_genPosToItem.IndexOf( masterItemToDetails.Key );
-          int masterItemIndex;
-
-          if( index > -1 )
-          {
-            masterItemIndex = m_genPosToIndex[ index ];
-          }
-          else
-          {
-            GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-            masterItemIndex = nodeHelper.FindItem( masterItemToDetails.Key );
-          }
-
-          if( masterItemIndex == -1 )
-            throw new DataGridInternalException();
-
-          retval = detailNodeOffset + masterItemIndex + detailIndex + 1;
-
-          //leave the top level loop
-          break;
-        }
-      }
-
-      return retval;
-    }
-
-    private void SendRemoveEvent( GeneratorPosition remPos, int oldIndex, int remCount, int generatedRemCount, IList<DependencyObject> removedContainers )
-    {
-      // Never send Remove events while processing ItemsRecreation
-      // to avoid bad ItemCount on master node
-      if( this.IsHandlingItemsRecreation )
-        return;
-
-      if( this.ItemsChanged != null )
-      {
-        using( new DeferDetailsRemapDisposable( this ) )
-        {
-          this.ItemsChanged( this, new CustomGeneratorChangedEventArgs( NotifyCollectionChangedAction.Remove, remPos, oldIndex, remPos, oldIndex, remCount, generatedRemCount, removedContainers ) );
-        }
-      }
-    }
-
-    private void SendAddEvent( GeneratorPosition genPos, int index, int addCount )
-    {
-      // Never send Add events while processing ItemsRecreation
-      // to avoid bad ItemCount on master node
-      if( this.IsHandlingItemsRecreation )
-        return;
-
-      if( this.ItemsChanged != null )
-      {
-        using( new DeferDetailsRemapDisposable( this ) )
-        {
-          this.ItemsChanged( this, new CustomGeneratorChangedEventArgs( NotifyCollectionChangedAction.Add, genPos, index, addCount, 0 ) );
-        }
-      }
-    }
-
-    private void SendResetEvent()
-    {
-      if( this.ItemsChanged != null )
+      foreach( var masterItemToDetails in m_masterToDetails )
       {
-        using( new DeferDetailsRemapDisposable( this ) )
+        var detailsNodes = masterItemToDetails.Value;
+        var detailIndex = detailsNodes.IndexOf( detailNode );
+        if( detailIndex < 0 )
+          continue;
+
+        var parentItem = masterItemToDetails.Key;
+        var offset = detailsNodes.Take( detailIndex ).Sum( item => item.ItemCount - 1 );
+
+        var index = m_genPosToItem.IndexOf( parentItem );
+
+        if( index >= 0 )
         {
-          this.ItemsChanged( this, new CustomGeneratorChangedEventArgs( NotifyCollectionChangedAction.Reset, new GeneratorPosition(), 0, 0, 0 ) );
+          if( m_genPosToNode[ index ] is ItemsGeneratorNode )
+            return offset + detailIndex + m_genPosToIndex[ index ] + 1;
         }
+
+        // Look for parent item index the old way.
+        var nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+
+        var parentItemIndex = nodeHelper.FindItem( parentItem );
+        if( parentItemIndex < 0 )
+          throw new DataGridInternalException( "Master item index is out of bound.", m_dataGridControl );
+
+        return offset + detailIndex + parentItemIndex + 1;
       }
+
+      return -1;
     }
 
     private void StartGenerator( GeneratorPosition startPos, GeneratorDirection direction )
     {
       if( this.Status == GeneratorStatus.GeneratingContainers )
-      {
-        throw new InvalidOperationException( "Cannot perform this operation while the generator is busy generating items" );
-      }
+        DataGridException.ThrowSystemException( "Cannot perform this operation while the generator is busy generating items.",
+                                                typeof( InvalidOperationException ), m_dataGridControl.Name );
 
       //set the GeneratorStatus to "Generating"
       m_generatorStatus = GeneratorStatus.GeneratingContainers;
@@ -5236,14 +5649,11 @@ namespace Xceed.Wpf.DataGrid
       //retrieve the Index for the GeneratorPosition retrieved
       m_generatorCurrentGlobalIndex = this.IndexFromGeneratorPosition( startPos );
 
-      // case 117460: throw an exception if the GeneratorPosition is bad, but not if the itemcount is 0 
-      //(and generator position maps to index 0 ).
       int itemCount = this.ItemCount;
       if( ( m_generatorCurrentGlobalIndex < 0 ) || ( ( itemCount > 0 ) && ( m_generatorCurrentGlobalIndex >= itemCount ) ) )
-        throw new ArgumentOutOfRangeException( "startPos", "The specified start position is outside the range of the Generator content." );
+        DataGridException.ThrowSystemException( "The specified start position is outside the range of the Generator content.",
+                                                typeof( ArgumentOutOfRangeException ), m_dataGridControl.Name, "startPos" );
 
-      //case 117460: if the item count is 0, return without doing any check, GenerateNext will never process any content in that case.
-      //Since the GeneratorNodeHelper is never created.
       if( itemCount == 0 )
         return;
 
@@ -5252,10 +5662,8 @@ namespace Xceed.Wpf.DataGrid
 
       //position the GeneratorNodeHelper to the appropriate node
       if( !m_generatorNodeHelper.FindNodeForIndex( m_generatorCurrentGlobalIndex ) ) //find index?!?!
-      {
         //there was a problem moving the Node helper... 
-        throw new DataGridInternalException();
-      }
+        throw new DataGridInternalException( "Unable to move to the required generator node by using the current index.", m_dataGridControl );
 
       //Calculate the offset
       m_generatorCurrentOffset = m_generatorCurrentGlobalIndex - m_generatorNodeHelper.Index;
@@ -5268,6 +5676,10 @@ namespace Xceed.Wpf.DataGrid
 
       if( m_generatorCurrentDetail != null )
       {
+        // No detail generator should be started already.
+        if( m_generatorCurrentDetailDisposable != null )
+          throw new DataGridInternalException( "The detail generator is already started.", m_dataGridControl );
+
         m_generatorCurrentDetailDisposable = ( ( IItemContainerGenerator )m_generatorCurrentDetail.DetailGenerator ).StartAt( m_generatorCurrentDetail.DetailGenerator.GeneratorPositionFromIndex( m_generatorCurrentDetailIndex ), direction, true );
       }
     }
@@ -5275,9 +5687,7 @@ namespace Xceed.Wpf.DataGrid
     private void StopGenerator()
     {
       if( this.Status != GeneratorStatus.GeneratingContainers )
-      {
-        throw new DataGridInternalException();
-      }
+        throw new DataGridInternalException( "Cannot perform this operation while the generator is busy generating items.", m_dataGridControl );
 
       m_generatorNodeHelper = null;
       m_generatorCurrentOffset = -1;
@@ -5290,8 +5700,17 @@ namespace Xceed.Wpf.DataGrid
 
       if( m_generatorCurrentDetailDisposable != null )
       {
-        m_generatorCurrentDetailDisposable.Dispose();
-        m_generatorCurrentDetailDisposable = null;
+        try
+        {
+          m_generatorCurrentDetailDisposable.Dispose();
+          m_generatorCurrentDetailDisposable = null;
+        }
+        catch( Exception e )
+        {
+          m_generatorStatus = GeneratorStatus.Error;
+
+          throw new DataGridInternalException( "The generator failed to stop.", e, m_dataGridControl );
+        }
       }
 
       m_generatorStatus = GeneratorStatus.ContainersGenerated;
@@ -5313,1139 +5732,892 @@ namespace Xceed.Wpf.DataGrid
         {
           retval.Offset++;
           break;
-        }
-
-        index++;
-      }
-
-      return retval;
-    }
-
-    private GeneratorPosition FindPreviousUnrealizedGeneratorPosition( GeneratorPosition position )
-    {
-      int index = this.IndexFromGeneratorPosition( position ) - 1;
-
-      while( index >= 0 )
-      {
-        if( !m_genPosToIndex.Contains( index ) )
-        {
-          break;
-        }
-
-        index--;
-      }
-
-      GeneratorPosition retval = this.GeneratorPositionFromIndex( index );
-
-      return retval;
-    }
-
-    private void RemoveContainer( DependencyObject container, object dataItem )
-    {
-      m_dataGridControl.ClearItemContainer( container, dataItem );
-
-      if( this.IsRecyclingEnabled )
-      {
-        this.EnqueueContainer( container, dataItem );
-
-        CustomItemContainerGenerator.SetDataItemProperty( container, CustomItemContainerGenerator.NotSet );
-        if( GroupLevelIndicatorPane.GetGroupLevel( container ) == -1 )
-        {
-          container.ClearValue( GroupLevelIndicatorPane.GroupLevelProperty );
-        }
-
-        if( container is HeaderFooterItem )
-        {
-          container.ClearValue( DataGridControl.StatContextPropertyKey );
-        }
-      }
-    }
-
-    private DependencyObject CreateContainerForItem( object dataItem, GeneratorNode node )
-    {
-      DependencyObject retval = null;
-
-      if( node is HeadersFootersGeneratorNode )
-      {
-        retval = this.CreateHeaderFooterContainer( dataItem );
-        if( node.Parent == null )
-        {
-          GroupLevelIndicatorPane.SetGroupLevel( retval, -1 );
-        }
-        else
-        {
-          GroupLevelIndicatorPane.SetGroupLevel( retval, node.Level );
-        }
-
-        this.SetStatContext( retval, node );
-      }
-      else if( node is ItemsGeneratorNode )
-      {
-        //ensure that item is not its own container...
-        if( !this.IsItemItsOwnContainer( dataItem ) )
-        {
-          retval = this.CreateNextItemContainer();
-        }
-        else
-        {
-          retval = dataItem as DependencyObject;
-        }
-
-        GroupLevelIndicatorPane.SetGroupLevel( retval, node.Level );
-      }
-      else
-      {
-        throw new DataGridInternalException();
-      }
-
-      if( retval == null )
-      {
-        throw new DataGridInternalException();
-      }
-
-      CustomItemContainerGenerator.SetDataItemProperty( retval, dataItem );
-      DataGridControl.SetDataGridContext( retval, m_dataGridContext );
-
-      return retval;
-    }
-
-    private void SetStatContext( DependencyObject container, GeneratorNode node )
-    {
-      GroupGeneratorNode parentGroup = node.Parent as GroupGeneratorNode;
-      DataGridCollectionViewGroup cvg = null;
-
-      if( parentGroup == null )
-      {
-        DataGridCollectionViewBase dataGridCollectionViewBase = null;
-
-        if( m_dataGridContext != null )
-        {
-          dataGridCollectionViewBase = m_dataGridContext.ItemsSourceCollection as DataGridCollectionViewBase;
-        }
-
-        Debug.Assert( dataGridCollectionViewBase != null, "dataGridCollectionViewBase != null" );
-
-        if( dataGridCollectionViewBase != null )
-          cvg = dataGridCollectionViewBase.RootGroup as DataGridCollectionViewGroup;
-      }
-      else
-      {
-        cvg = parentGroup.CollectionViewGroup as DataGridCollectionViewGroup;
-      }
-
-      if( cvg != null )
-        container.SetValue( DataGridControl.StatContextPropertyKey, cvg );
-    }
-
-    private bool IsItemItsOwnContainer( object dataItem )
-    {
-      return m_dataGridControl.IsItemItsOwnContainer( dataItem );
-    }
-
-    private DependencyObject CreateHeaderFooterContainer( object dataItem )
-    {
-      if( this.IsRecyclingEnabled )
-      {
-        DependencyObject recycledContainer = null;
-        recycledContainer = this.DequeueHeaderFooterContainer( dataItem );
-        if( recycledContainer != null )
-          return recycledContainer;
-      }
-
-      //If the container cannot be recycled, then create a new one.
-      object realDataItem = dataItem;
-      if( dataItem.GetType() == typeof( GroupHeaderFooterItem ) )
-      {
-        realDataItem = ( ( GroupHeaderFooterItem )dataItem ).Template;
-      }
-
-      DataTemplate template = realDataItem as DataTemplate;
-      if( template == null )
-      {
-        GroupHeaderFooterItemTemplate vwc = realDataItem as GroupHeaderFooterItemTemplate;
-        if( vwc != null )
-        {
-          vwc.Seal();
-          template = vwc.Template;
-        }
-
-        if( template == null )
-          throw new DataGridInternalException();
-      }
-
-      HeaderFooterItem newItem = new HeaderFooterItem();
-
-      BindingOperations.SetBinding( newItem, HeaderFooterItem.ContentProperty, m_headerFooterDataContextBinding );
-      newItem.ContentTemplate = template;
-
-      return newItem;
-    }
-
-    private int FindInsertionPoint( int itemIndex )
-    {
-      int i = 0;
-
-      int collectionCount = m_genPosToIndex.Count;
-      for( i = 0; i < collectionCount; i++ )
-      {
-        //if the item is larger in index, then I want to insert before it!
-        if( m_genPosToIndex[ i ] > itemIndex )
-        {
-          break;
-        }
-
-      }
-
-      return i;
-    }
-
-    private void QueueDetailItemForRemapping( object item )
-    {
-      if( item == null )
-        return;
-
-      if( ( !m_floatingDetails.Contains( item ) ) && ( m_masterToDetails.ContainsKey( item ) ) )
-      {
-        m_floatingDetails.Add( item );
-      }
-    }
-
-    private void CleanDetailNode( DetailGeneratorNode detailNode )
-    {
-#if LOG
-      Log.Start( this, "CleanDetailNode - DN" + detailNode.GetHashCode().ToString() );
-#endif
-
-      m_dataGridControl.SelectionChangerManager.Begin();
-
-      try
-      {
-        m_dataGridControl.SelectionChangerManager.UnselectAllItems( detailNode.DetailContext );
-        m_dataGridControl.SelectionChangerManager.UnselectAllCells( detailNode.DetailContext );
-      }
-      finally
-      {
-        m_dataGridControl.SelectionChangerManager.End( false, false, false );
-      }
-
-      m_dataGridControl.SaveDataGridContextState( detailNode.DetailContext, true, int.MaxValue );
-
-      CustomItemContainerGenerator generator = detailNode.DetailGenerator;
-
-      detailNode.CleanGeneratorNode();
-
-      DetailsChangedEventManager.RemoveListener( generator, this );
-      generator.ItemsChanged -= HandleDetailGeneratorContentChanged;
-      generator.ContainersRemoved -= OnDetailContainersRemoved;
-      generator.SetGenPosToIndexUpdateInhibiter( null );
-
-#if LOG
-      Log.End( this, "CleanDetailNode - DN" + detailNode.GetHashCode().ToString() );
-#endif
-    }
-
-    private void HandleDetailGeneratorContentChanged( object sender, CustomGeneratorChangedEventArgs e )
-    {
-      Debug.Assert( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount == 0, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
-#if LOG
-      Log.Assert( this, m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount == 0, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
-#endif
-
-      if( m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount > 0 )
-        return;
-
-      using( new ProcessingGlobalItemsResetOrRemovingAllGeneratedItemsDisposable( this ) )
-      {
-        Debug.Assert( m_startNode != null, "m_startNode != null" );
-#if LOG
-        Log.Assert( this, m_startNode != null, "m_startNode != null" );
-#endif
-
-        CustomItemContainerGenerator detailGenerator = sender as CustomItemContainerGenerator;
-
-        Debug.Assert( detailGenerator != null, "detailGenerator != null" );
-#if LOG
-        Log.Assert( this, detailGenerator != null, "detailGenerator != null" );
-#endif
-
-        object masterItem;
-        DetailGeneratorNode detailNode = this.FindDetailGeneratorNodeForGenerator( detailGenerator, out masterItem );
-
-        Debug.Assert( masterItem != null, "masterItem != null" );
-        Debug.Assert( detailNode != null, "detailNode != null" );
-#if LOG
-        Log.Assert( this, masterItem != null, "masterItem != null" );
-        Log.Assert( this, detailNode != null, "detailNode != null" );
-#endif
-
-        if( ( detailNode != null ) && ( masterItem != null ) )
-        {
-          switch( e.Action )
-          {
-            case NotifyCollectionChangedAction.Add:
-              this.HandleDetailAddition( masterItem, detailNode, e );
-              break;
-
-            case NotifyCollectionChangedAction.Move:
-            case NotifyCollectionChangedAction.Remove:
-              this.HandleDetailMoveRemove( masterItem, detailNode, e );
-              break;
-
-            case NotifyCollectionChangedAction.Replace: //CustomItemContainerGenreator never issues a Replace!
-              throw new DataGridInternalException();
-
-            case NotifyCollectionChangedAction.Reset:
-              this.HandleDetailReset( masterItem, detailNode );
-              break;
-
-            default:
-              break;
-          }
-        }
-      }
-    }
-
-    private void HandleDetailAddition( object masterItem, DetailGeneratorNode detailNode, CustomGeneratorChangedEventArgs e )
-    {
-      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-      int masterIndex = nodeHelper.FindItem( masterItem );
-
-      //If the masterItem is part of an ItemsGeneratorNode which is below a collapsed group, masterIndex will be -1
-      if( masterIndex == -1 )
-      {
-        //in that case, I need to determine the appropriate masterNode another way
-        nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-        if( !nodeHelper.Contains( masterItem ) )
-          throw new DataGridInternalException();
-      }
-
-      ItemsGeneratorNode masterNode = nodeHelper.CurrentNode as ItemsGeneratorNode;
-
-      Debug.Assert( masterNode != null, "masterNode != null" );
-#if LOG
-      Log.Assert( this, masterNode != null, "masterNode != null" );
-#endif
-
-      int globalIndex;
-      GeneratorPosition convertedGeneratorPosition = ( masterIndex != -1 ) ? this.ConvertDetailGeneratorPosition( e.Position, masterItem, detailNode, out globalIndex ) : new GeneratorPosition( -1, 1 );
-
-      masterNode.AdjustItemCount( e.ItemCount );
-
-      detailNode.UpdateItemCount();
-
-      this.IncrementCurrentGenerationCount();
-
-      if( masterIndex != -1 )
-      {
-        this.SendAddEvent( convertedGeneratorPosition, masterIndex + 1 + e.Index, e.ItemCount );
+        }
+
+        index++;
       }
+
+      return retval;
     }
 
-    private void HandleDetailMoveRemove( object masterItem, DetailGeneratorNode detailNode, CustomGeneratorChangedEventArgs e )
+    private GeneratorPosition FindPreviousUnrealizedGeneratorPosition( GeneratorPosition position )
     {
-      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-      int masterIndex = nodeHelper.FindItem( masterItem );
+      int index = this.IndexFromGeneratorPosition( position ) - 1;
 
-      //If the masterItem is part of an ItemsGeneratorNode which is below a collapsed group, masterIndex will be -1
-      if( masterIndex == -1 )
+      while( index >= 0 )
       {
-        //in that case, I need to determine the appropriate masterNode another way
-        nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-        if( !nodeHelper.Contains( masterItem ) )
-          throw new DataGridInternalException();
-      }
+        if( !m_genPosToIndex.Contains( index ) )
+        {
+          break;
+        }
 
-      ItemsGeneratorNode masterNode = nodeHelper.CurrentNode as ItemsGeneratorNode;
+        index--;
+      }
 
-      Debug.Assert( masterNode != null, "masterNode != null" );
-#if LOG
-      Log.Assert( this, masterNode != null, "masterNode != null" );
-#endif
+      GeneratorPosition retval = this.GeneratorPositionFromIndex( index );
 
-      int globalIndex = -1;
-      GeneratorPosition convertedGeneratorPosition = ( masterIndex != -1 ) ? this.ConvertDetailGeneratorPosition( e.OldPosition, masterItem, detailNode, out globalIndex ) : new GeneratorPosition( -1, 1 );
+      return retval;
+    }
 
-      if( masterIndex != -1 )
-      {
-        this.RemoveDetailContainers( convertedGeneratorPosition, e.ItemUICount );
-      }
+    private void RemoveContainer( DependencyObject container, object dataItem )
+    {
+      m_dataGridControl.ClearItemContainer( container, dataItem );
 
-      if( e.Action == NotifyCollectionChangedAction.Remove )
+      if( this.IsRecyclingEnabled )
       {
-        masterNode.AdjustItemCount( -e.ItemCount );
+        this.EnqueueContainer( container, dataItem );
 
-        detailNode.UpdateItemCount();
-      }
+        var dataItemStore = container.ReadLocalValue( CustomItemContainerGenerator.DataItemPropertyProperty ) as DataItemDataProviderBase;
+        if( dataItemStore != null )
+        {
+          dataItemStore.ClearDataItem();
+        }
 
-      this.IncrementCurrentGenerationCount();
+        if( GroupLevelIndicatorPane.GetGroupLevel( container ) == -1 )
+        {
+          container.ClearValue( GroupLevelIndicatorPane.GroupLevelProperty );
+        }
 
-      if( masterIndex != -1 )
-      {
-        this.SendRemoveEvent( convertedGeneratorPosition, globalIndex, e.ItemCount, e.ItemUICount, e.RemovedContainers );
+        if( container is HeaderFooterItem )
+        {
+          container.ClearValue( DataGridControl.StatContextPropertyKey );
+        }
       }
     }
 
-    private void HandleDetailReset( object masterItem, DetailGeneratorNode detailNode )
+    private DependencyObject CreateContainerForItem( object dataItem, GeneratorNode node )
     {
-      GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-      int masterIndex = nodeHelper.FindItem( masterItem );
+      DependencyObject container = null;
 
-      // -1 means either taht the master item is below a collapsed group node, or that the item does not exists, validate.
-      if( masterIndex == -1 )
+      if( node is HeadersFootersGeneratorNode )
       {
-        nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
-        if( !nodeHelper.Contains( masterItem ) )
-          throw new DataGridInternalException();
-      }
+        container = this.CreateHeaderFooterContainer( dataItem );
 
-      ItemsGeneratorNode masterNode = nodeHelper.CurrentNode as ItemsGeneratorNode;
-
-      Debug.Assert( masterNode != null, "masterNode != null" );
-#if LOG
-      Log.Assert( this, masterNode != null, "masterNode != null" );
-#endif
-
-      //start index will be ignored later on if the masterIndex is -1!!
-      int startIndex = nodeHelper.Index + masterNode.IndexOf( masterItem ) + 1; //details start a master index + 1
-
-      List<DetailGeneratorNode> detailsForMaster = null;
-
-      //edge case, it is possible to receive a Reset from Floating details!
-      if( masterNode.Details == null )
-      {
-        //check for floating details, if not present, throw, this is an abnormal case.
-        if( !m_floatingDetails.Contains( masterItem ) )
+        if( node.Parent == null )
         {
-          throw new DataGridInternalException();
+          GroupLevelIndicatorPane.SetGroupLevel( container, -1 );
+        }
+        else
+        {
+          GroupLevelIndicatorPane.SetGroupLevel( container, node.Level );
         }
-      }
-      else
-      {
-        masterNode.Details.TryGetValue( masterNode.Items.IndexOf( masterItem ), out detailsForMaster );
 
-        Debug.Assert( detailsForMaster != null, "detailsForMaster != null" );
-#if LOG
-        Log.Assert( this, detailsForMaster != null, "detailsForMaster != null" );
-#endif
+        this.SetStatContext( container, node );
       }
-
-      if( detailsForMaster != null )
+      else if( node is ItemsGeneratorNode )
       {
-        //this is required to ensure that if the details that resets is not the first one, the index is calculated appropriatly.
-        foreach( DetailGeneratorNode node in detailsForMaster )
+        //ensure that item is not its own container...
+        if( !this.IsItemItsOwnContainer( dataItem ) )
         {
-          if( node == detailNode )
-          {
-            break;
-          }
-          else
-          {
-            startIndex += node.ItemCount;
-          }
+          container = this.CreateNextItemContainer( dataItem );
         }
-
-        //if there were 'items' in the detail node, process the remove of them
-        int oldDetailCount = detailNode.ItemCount;
-        if( oldDetailCount > 0 )
+        else
         {
-          int endIndex = startIndex + oldDetailCount - 1; //last detail index
-
-          GeneratorPosition removeGenPos = ( masterIndex != -1 )
-            ? this.GeneratorPositionFromIndex( startIndex )
-            : new GeneratorPosition( -1, 1 );
-
-          int genRemCount = 0;
-
-          List<DependencyObject> removedContainers = new List<DependencyObject>();
-
-          //this has no uses if the masterIndex is -1 ( collapsed master item )
-          if( masterIndex != -1 )
-          {
-            genRemCount = this.RemoveGeneratedItems( startIndex, endIndex, removedContainers );
-          }
-
-          masterNode.AdjustItemCount( -oldDetailCount );
-
-          this.IncrementCurrentGenerationCount();
-
-          //this has no uses if the masterIndex is -1 ( collapsed master item )
-          if( masterIndex != -1 )
-          {
-            this.SendRemoveEvent( removeGenPos, masterIndex + 1, oldDetailCount, genRemCount, removedContainers );
-          }
+          container = dataItem as DependencyObject;
         }
 
-        detailNode.UpdateItemCount();
+        GroupLevelIndicatorPane.SetGroupLevel( container, node.Level );
+      }
+      else
+      {
+        throw new DataGridInternalException( "Cannot create container for the GeneratorNode, as it is not of a valid type.", m_dataGridControl );
+      }
 
-        int newDetailCount = detailNode.ItemCount;
-        if( newDetailCount > 0 )
-        {
-          GeneratorPosition addGenPos = new GeneratorPosition( -1, 1 );
+      if( container == null )
+        throw new DataGridInternalException( "A container could not be created or recycled for the GeneratorNode.", m_dataGridControl );
 
-          //this has no uses if the masterIndex is -1 ( collapsed master item )
-          if( masterIndex != -1 )
-          {
-            addGenPos = this.GeneratorPositionFromIndex( startIndex );
-          }
+      var dataItemStore = container.ReadLocalValue( CustomItemContainerGenerator.DataItemPropertyProperty ) as DataItemDataProviderBase;
+      if( dataItemStore != null )
+      {
+        dataItemStore.SetDataItem( dataItem );
+      }
+      else
+      {
+        dataItemStore = new DataItemDataProvider();
+        dataItemStore.SetDataItem( dataItem );
 
-          masterNode.AdjustItemCount( newDetailCount );
+        CustomItemContainerGenerator.SetDataItemProperty( container, dataItemStore );
+      }
 
-          this.IncrementCurrentGenerationCount();
+      DataGridControl.SetDataGridContext( container, m_dataGridContext );
 
-          //this has no uses if the masterIndex is -1 ( collapsed master item )
-          if( masterIndex != -1 )
-          {
-            this.SendAddEvent( addGenPos, masterIndex + 1, newDetailCount );
-          }
-        }
-      }
+      return container;
     }
 
-    private void RemoveDetailContainers( GeneratorPosition convertedGeneratorPosition, int removeCount )
+    private void SetStatContext( DependencyObject container, GeneratorNode node )
     {
-      int removeGenPosIndex = convertedGeneratorPosition.Index;
-      if( convertedGeneratorPosition.Offset > 0 )
+      GroupGeneratorNode parentGroup = node.Parent as GroupGeneratorNode;
+      DataGridCollectionViewGroup collectionViewGroup = null;
+
+      if( parentGroup != null )
       {
-        removeGenPosIndex++;
+        collectionViewGroup = parentGroup.CollectionViewGroup as DataGridCollectionViewGroup;
+      }
+      else if( m_dataGridContext != null )
+      {
+        var collectionView = m_dataGridContext.ItemsSourceCollection as DataGridCollectionViewBase;
+        if( collectionView != null )
+        {
+          collectionViewGroup = collectionView.RootGroup as DataGridCollectionViewGroup;
+        }
       }
 
-      for( int i = 0; i < removeCount; i++ )
+      if( collectionViewGroup != null )
       {
-        this.GenPosArraysRemoveAt( removeGenPosIndex );
+        container.SetValue( DataGridControl.StatContextPropertyKey, collectionViewGroup );
       }
     }
 
-    private GeneratorPosition ConvertDetailGeneratorPosition( GeneratorPosition referencePosition, object masterItem, DetailGeneratorNode detailNode, out int globalIndex )
+    private bool IsItemItsOwnContainer( object dataItem )
     {
-      //If the requested generator position map past at least one generated item from the detail generator, then the job is easy...
-      if( referencePosition.Index >= 0 )
-      {
-        int generatorIndex = this.FindGeneratorIndexForNode( detailNode, referencePosition.Index );
+      return m_dataGridControl.IsItemItsOwnContainer( dataItem );
+    }
 
-        // Ensure to return the globalIndex as -1
-        // if the generator index is not found for
-        // a DetailNode. This can occur if a Detail
-        // is filtered out via AutoFiltering.
-        globalIndex = ( generatorIndex > -1 )
-          ? m_genPosToIndex[ generatorIndex ]
-          : globalIndex = -1;
+    private DependencyObject CreateHeaderFooterContainer( object dataItem )
+    {
+      if( this.IsRecyclingEnabled )
+      {
+        DependencyObject recycledContainer = null;
+        recycledContainer = this.DequeueHeaderFooterContainer( dataItem );
+        if( recycledContainer != null )
+          return recycledContainer;
+      }
 
-        return new GeneratorPosition( generatorIndex, referencePosition.Offset );
+      //If the container cannot be recycled, then create a new one.
+      object realDataItem = dataItem;
+      if( dataItem.GetType() == typeof( GroupHeaderFooterItem ) )
+      {
+        realDataItem = ( ( GroupHeaderFooterItem )dataItem ).Template;
       }
-      else
+
+      DataTemplate template = realDataItem as DataTemplate;
+      if( template == null )
       {
-        //This means the GeneratorPosition returned by the DetailGenerator is "before" any generated item from the detail generator.
-        //I need more complex detection of the GeneratorPosition.
+        GroupHeaderFooterItemTemplate vwc = realDataItem as GroupHeaderFooterItemTemplate;
+        if( vwc != null )
+        {
+          vwc.Seal();
+          template = vwc.Template;
+        }
 
-        // First - Get the Index of the MasterItem
-        int masterIndex = this.IndexFromItem( masterItem );
+        if( template == null )
+          throw new DataGridInternalException( "No template found for the creation of a header or footer container.", m_dataGridControl );
+      }
 
-        //Second - Get the DetailGenerator's Index for the DetailGenerator's GenPos
-        int detailGeneratorIndex = detailNode.DetailGenerator.IndexFromGeneratorPosition( referencePosition );
+      HeaderFooterItem newItem = new HeaderFooterItem();
 
-        globalIndex = masterIndex + detailGeneratorIndex + 1;
+      BindingOperations.SetBinding( newItem, HeaderFooterItem.ContentProperty, m_headerFooterDataContextBinding );
+      newItem.ContentTemplate = template;
 
-        // Finally - Have the Master Generator compute the GeneratorPosition from the sum of both
-        return this.GeneratorPositionFromIndex( globalIndex );
-      }
+      return newItem;
     }
 
-    private int FindGeneratorIndexForNode( DetailGeneratorNode referenceNode, int offset )
+    private int FindInsertionPoint( int itemIndex )
     {
-      int offsetCounter = -1;
+      int i = 0;
 
-      for( int i = 0; i < m_genPosToNode.Count; i++ )
+      int collectionCount = m_genPosToIndex.Count;
+      for( i = 0; i < collectionCount; i++ )
       {
-        GeneratorNode node = m_genPosToNode[ i ];
-        if( node == referenceNode )
+        //if the item is larger in index, then I want to insert before it!
+        if( m_genPosToIndex[ i ] > itemIndex )
         {
-          offsetCounter++;
-          if( offsetCounter == offset )
-          {
-            return i;
-          }
+          break;
         }
+
       }
 
-      return -1;
+      return i;
     }
 
-    private DetailGeneratorNode FindDetailGeneratorNodeForGenerator( CustomItemContainerGenerator detailGenerator, out object masterItem )
+    private void QueueDetailItemForRemapping( object item )
     {
-      foreach( KeyValuePair<object, List<DetailGeneratorNode>> detailsForItem in m_masterToDetails )
+      if( item == null )
+        return;
+
+      if( ( !m_floatingDetails.Contains( item ) ) && ( m_masterToDetails.ContainsKey( item ) ) )
       {
-        foreach( DetailGeneratorNode detailNode in detailsForItem.Value )
-        {
-          if( detailNode.DetailGenerator == detailGenerator )
-          {
-            masterItem = detailsForItem.Key;
-            return detailNode;
-          }
-        }
+        m_floatingDetails.Add( item );
       }
-
-      masterItem = null;
-      return null;
     }
 
-    internal void SetGenPosToIndexUpdateInhibiter( IInhibitGenPosToIndexUpdating inhibiter )
+    private DetailGeneratorNode CreateDetailGeneratorNode( object dataItem, DataGridCollectionViewBase collectionView, DetailConfiguration detailConfiguration )
     {
-      m_genPosToIndexInhibiter = inhibiter;
-    }
+      var detailDataGridContext = new DataGridContext( m_dataGridContext, m_dataGridControl, dataItem, collectionView, detailConfiguration );
+      detailDataGridContext.SetAssociatedAutomationPeer();
 
-    private IDisposable InhibitParentGenPosToIndexUpdate()
-    {
-      if( m_genPosToIndexInhibiter != null )
+      var detailGenerator = CustomItemContainerGenerator.CreateGenerator( m_dataGridControl, collectionView, detailDataGridContext, this );
+      detailGenerator.SetGenPosToIndexUpdateInhibiter( this );
+      detailGenerator.IsRecyclingEnabled = this.IsRecyclingEnabled;
+
+      if( m_dataGridControl.AreDetailsFlatten )
       {
-        return m_genPosToIndexInhibiter.InhibitGenPosToIndexUpdates();
+        var updateColumnSortCommand = detailDataGridContext.UpdateColumnSortCommand;
+        if( updateColumnSortCommand.CanExecute() )
+        {
+          updateColumnSortCommand.Execute();
+        }
       }
-      return null;
+
+      DetailsChangedEventManager.AddListener( detailGenerator, this );
+
+      var detailNode = new DetailGeneratorNode( detailDataGridContext, detailGenerator );
+
+      //register to the ItemsChanged only after the columns were updated (to avoid a reset being received without having completed the initialization ).
+      //Also wait after the creation of the DetailGeneratorNode, since messages could be issued before initialization completes.
+      detailGenerator.ItemsChanged += new CustomGeneratorChangedEventHandler( this.HandleDetailGeneratorContentChanged );
+      detailGenerator.ContainersRemoved += new ContainersRemovedEventHandler( this.OnDetailContainersRemoved );
+
+      return detailNode;
     }
 
-    private int FindFirstGeneratedIndexForLocalItem( object item )
+    private void ClearDetailGeneratorNode( DetailGeneratorNode detailNode )
     {
-      //this function will find an item in the m_genPosToItem, but will filter out those that belongs to details.
-      //This is to avoid the problem caused by Detail items that belongs also to a master.
-      int retval = -1;
+      using( m_log.BeginBlock( this, CustomItemContainerGenerator.FormatObjectId( "ClearDetailGeneratorNode - DN", detailNode ) ) )
+      {
+        m_dataGridControl.SelectionChangerManager.Begin();
 
-      int runningIndex = 0;
-      int itemCount = m_genPosToItem.Count;
+        try
+        {
+          m_dataGridControl.SelectionChangerManager.UnselectAllItems( detailNode.DetailContext );
+          m_dataGridControl.SelectionChangerManager.UnselectAllCells( detailNode.DetailContext );
+        }
+        finally
+        {
+          m_dataGridControl.SelectionChangerManager.End( false, false, false );
+        }
 
-      while( runningIndex < itemCount )
-      {
-        retval = m_genPosToItem.IndexOf( item, runningIndex );
+        m_dataGridControl.SaveDataGridContextState( detailNode.DetailContext, true, int.MaxValue );
 
-        //No item found past the current runningIndex
-        if( retval == -1 )
-          break;
+        CustomItemContainerGenerator detailGenerator = detailNode.DetailGenerator;
 
-        //check if the item belongs to a Detail or not.
-        DetailGeneratorNode detailNode = m_genPosToNode[ retval ] as DetailGeneratorNode;
-        if( detailNode == null )
-          break; //the item is not a detail and therefore qualifies as a return value.
+        detailNode.CleanGeneratorNode();
 
-        //Item is from a detail
-        runningIndex = retval + 1;
+        DetailsChangedEventManager.RemoveListener( detailGenerator, this );
+        detailGenerator.ItemsChanged -= new CustomGeneratorChangedEventHandler( this.HandleDetailGeneratorContentChanged );
+        detailGenerator.ContainersRemoved -= new ContainersRemovedEventHandler( this.OnDetailContainersRemoved );
+        detailGenerator.SetGenPosToIndexUpdateInhibiter( null );
+        detailGenerator.UnregisterEvents();
+        detailGenerator.ClearEvents();
       }
-
-      return retval;
     }
 
-    private void EnqueueContainer( DependencyObject container, object item )
+    private void RegisterEvents()
     {
-      RecyclingManager manager = m_dataGridContext.RecyclingManager;
+      Debug.Assert( m_dataGridControl != null );
+      Debug.Assert( m_collectionView != null );
+      Debug.Assert( ( m_dataGridContext != null ) && ( m_dataGridContext.DetailConfigurations != null ) );
 
-      Debug.Assert( manager != null, "manager != null" );
-#if LOG
-      Log.Assert( this, manager != null, "manager != null" );
-#endif
+      CollectionChangedEventManager.AddListener( m_collectionView, this );
+      GroupConfigurationSelectorChangedEventManager.AddListener( m_dataGridContext, this );
+      CollectionChangedEventManager.AddListener( m_dataGridContext.DetailConfigurations, this );
+      PropertyChangedEventManager.AddListener( m_collectionView, this, "Groups" );
 
-      if( container is HeaderFooterItem )
+      // The top most generator must register to additional events.
+      if( m_dataGridContext.SourceDetailConfiguration == null )
       {
-        if( item is GroupHeaderFooterItem )
-        {
-          //If the group is not in the CollectionView anymore (e.g. all its rows have been deleted), do not recycle it.
-          CollectionViewGroup viewGroup = ( ( GroupHeaderFooterItem )item ).Group;
-          if( viewGroup == null )
-            return;
-
-          //The tree is already correctly created since we are recycling containers!
-          this.IsEnsuringNodeTreeCreated = true;
-          Group UIgroup = this.GetGroupFromCollectionViewGroup( viewGroup );
-          this.IsEnsuringNodeTreeCreated = false;
+        ItemsSourceChangeCompletedEventManager.AddListener( m_dataGridControl, this );
+        ViewChangedEventManager.AddListener( m_dataGridControl, this );
+        ThemeChangedEventManager.AddListener( m_dataGridControl, this );
+      }
+    }
 
-          if( UIgroup == null )
-            return;
+    private void UnregisterEvents()
+    {
+      Debug.Assert( m_dataGridControl != null );
+      Debug.Assert( m_collectionView != null );
+      Debug.Assert( ( m_dataGridContext != null ) && ( m_dataGridContext.DetailConfigurations != null ) );
 
-          string groupBy = UIgroup.GroupBy;
-          if( string.IsNullOrEmpty( groupBy ) )
-            return;
+      CollectionChangedEventManager.RemoveListener( m_collectionView, this );
+      GroupConfigurationSelectorChangedEventManager.RemoveListener( m_dataGridContext, this );
+      CollectionChangedEventManager.RemoveListener( m_dataGridContext.DetailConfigurations, this );
+      PropertyChangedEventManager.RemoveListener( m_collectionView, this, "Groups" );
 
-          manager.EnqueueGroupHeaderFooterContainer( groupBy, item, container );
-        }
-        else
-        {
-          manager.EnqueueHeaderFooterContainer( item, container );
-        }
-      }
-      else
+      // The top most generator must unregister from additional events.
+      if( m_dataGridContext.SourceDetailConfiguration == null )
       {
-        manager.EnqueueItemContainer( container );
+        ItemsSourceChangeCompletedEventManager.RemoveListener( m_dataGridControl, this );
+        ViewChangedEventManager.RemoveListener( m_dataGridControl, this );
+        ThemeChangedEventManager.RemoveListener( m_dataGridControl, this );
       }
     }
 
-    private DependencyObject DequeueItemContainer()
+    private void ClearEvents()
     {
-      RecyclingManager manager = m_dataGridContext.RecyclingManager;
-
-      Debug.Assert( manager != null, "manager != null" );
-#if LOG
-      Log.Assert( this, manager != null, "manager != null" );
-#endif
-
-      return manager.DequeueItemContainer();
+      this.ContainersRemoved = null;
+      this.DetailsChanged = null;
+      this.ItemsChanged = null;
+      this.PropertyChanged = null;
     }
 
-    private DependencyObject DequeueHeaderFooterContainer( object item )
+    private void HandleDetailGeneratorContentChanged( object sender, CustomGeneratorChangedEventArgs e )
     {
-      RecyclingManager manager = m_dataGridContext.RecyclingManager;
+      m_log.Assert( this, !this.IsHandlingGlobalItemsResetLocally, "Generator is already processing a HandleGlobalItemReset or CleanupGenerator" );
 
-      Debug.Assert( manager != null, "manager != null" );
-#if LOG
-      Log.Assert( this, manager != null, "manager != null" );
-#endif
+      if( this.IsHandlingGlobalItemsResetLocally )
+        return;
 
-      if( item is GroupHeaderFooterItem )
-      {
-        CollectionViewGroup viewGroup = ( ( GroupHeaderFooterItem )item ).Group;
-        if( viewGroup == null )
-          return null;
+      m_log.Assert( this, m_startNode != null, "m_startNode != null" );
 
-        //The tree is already correctly created since we are recycling containers!
-        this.IsEnsuringNodeTreeCreated = true;
-        Group UIgroup = this.GetGroupFromCollectionViewGroup( viewGroup );
-        this.IsEnsuringNodeTreeCreated = false;
+      CustomItemContainerGenerator detailGenerator = sender as CustomItemContainerGenerator;
 
-        if( UIgroup == null )
-          return null;
+      m_log.Assert( this, detailGenerator != null, "detailGenerator != null" );
 
-        string groupBy = UIgroup.GroupBy;
-        if( string.IsNullOrEmpty( groupBy ) )
-          return null;
+      object masterItem;
+      DetailGeneratorNode detailNode = this.FindDetailGeneratorNodeForGenerator( detailGenerator, out masterItem );
 
-        return manager.DequeueGroupHeaderFooterContainer( groupBy, item );
-      }
-      else
+      m_log.Assert( this, masterItem != null, "masterItem != null" );
+      m_log.Assert( this, detailNode != null, "detailNode != null" );
+
+      if( ( detailNode != null ) && ( masterItem != null ) )
       {
-        return manager.DequeueHeaderFooterContainer( item );
+        switch( e.Action )
+        {
+          case NotifyCollectionChangedAction.Add:
+            this.HandleDetailAddition( masterItem, detailNode, e );
+            break;
+
+          case NotifyCollectionChangedAction.Move:
+          case NotifyCollectionChangedAction.Remove:
+            this.HandleDetailMoveRemove( masterItem, detailNode, e );
+            break;
+
+          case NotifyCollectionChangedAction.Replace: //CustomItemContainerGenreator never issues a Replace!
+            throw new DataGridInternalException( "CustomItemContainerGenerator never notifies a Replace action.", m_dataGridControl );
+
+          case NotifyCollectionChangedAction.Reset:
+            this.HandleDetailReset( masterItem, detailNode );
+            break;
+
+          default:
+            break;
+        }
       }
     }
 
-    private void NotifyContainersRemoved( IList<DependencyObject> removedContainers )
+    private void HandleDetailAddition( object masterItem, DetailGeneratorNode detailNode, CustomGeneratorChangedEventArgs e )
     {
-      if( m_containersRemovedDeferCount > 0 )
+      if( m_floatingDetails.Contains( masterItem ) )
+        return;
+
+      var nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+      var masterIndex = nodeHelper.FindItem( masterItem );
+
+      // The master item has been found.
+      if( masterIndex != -1 )
       {
-        m_deferredContainersRemoved.AddRange( removedContainers );
+        int globalIndex = -1;
+        var convertedGeneratorPosition = this.ConvertDetailGeneratorPosition( e.Position, masterItem, detailNode, out globalIndex );
+        var masterNode = ( ItemsGeneratorNode )nodeHelper.CurrentNode;
+
+        masterNode.AdjustItemCount( e.ItemCount );
+        detailNode.UpdateItemCount();
+
+        this.IncrementCurrentGenerationCount();
+        this.SendAddEvent( convertedGeneratorPosition, masterIndex + 1 + e.Index, e.ItemCount );
       }
-      else if( removedContainers.Count > 0 )
+      // The master item could be located inside a collapsed group.
+      else
       {
-        this.NotifyContainersRemoved( new ContainersRemovedEventArgs( removedContainers ) );
-      }
-    }
+        //in that case, I need to determine the appropriate masterNode another way
+        nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+        if( !nodeHelper.Contains( masterItem ) )
+          DataGridException.ThrowSystemException( "An attempt was made to add a detail for an item that does not belong to the generator.",
+                                                  typeof( InvalidOperationException ), m_dataGridControl.Name );
 
-    private void NotifyContainersRemoved( ContainersRemovedEventArgs e )
-    {
-      if( ( this.IsRecyclingEnabled ) && ( this.ContainersRemoved != null ) )
-      {
-        this.ContainersRemoved( this, e );
+        var masterNode = ( ItemsGeneratorNode )nodeHelper.CurrentNode;
+
+        masterNode.AdjustItemCount( e.ItemCount );
+        detailNode.UpdateItemCount();
+
+        this.IncrementCurrentGenerationCount();
       }
     }
 
-    private void OnDetailContainersRemoved( object sender, ContainersRemovedEventArgs e )
+    private void HandleDetailMoveRemove( object masterItem, DetailGeneratorNode detailNode, CustomGeneratorChangedEventArgs e )
     {
-      if( m_containersRemovedDeferCount > 0 )
+      if( m_floatingDetails.Contains( masterItem ) )
+        return;
+
+      var nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+      var masterIndex = nodeHelper.FindItem( masterItem );
+
+      // The master item has been found.
+      if( masterIndex != -1 )
       {
-        m_deferredContainersRemoved.AddRange( e.RemovedContainers );
+        int globalIndex = -1;
+        var convertedGeneratorPosition = this.ConvertDetailGeneratorPosition( e.OldPosition, masterItem, detailNode, out globalIndex );
+
+        this.RemoveDetailContainers( convertedGeneratorPosition, e.ItemUICount );
+
+        if( e.Action == NotifyCollectionChangedAction.Remove )
+        {
+          var masterNode = ( ItemsGeneratorNode )nodeHelper.CurrentNode;
+
+          masterNode.AdjustItemCount( -e.ItemCount );
+          detailNode.UpdateItemCount();
+        }
+
+        this.IncrementCurrentGenerationCount();
+        this.SendRemoveEvent( convertedGeneratorPosition, globalIndex, e.ItemCount, e.ItemUICount, e.RemovedContainers );
       }
+      // The master item could be located inside a collapsed group.
       else
       {
-        this.NotifyContainersRemoved( e );
+        //in that case, I need to determine the appropriate masterNode another way
+        nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+        if( !nodeHelper.Contains( masterItem ) )
+          DataGridException.ThrowSystemException( "An attempt was made to move or remove a detail for an item that does not belong to the generator.",
+                                                  typeof( InvalidOperationException ), m_dataGridControl.Name );
+
+        if( e.Action == NotifyCollectionChangedAction.Remove )
+        {
+          var masterNode = ( ItemsGeneratorNode )nodeHelper.CurrentNode;
+
+          masterNode.AdjustItemCount( -e.ItemCount );
+          detailNode.UpdateItemCount();
+        }
+
+        this.IncrementCurrentGenerationCount();
       }
     }
 
-    private IDisposable DeferContainersRemovedNotification()
+    private void HandleDetailReset( object masterItem, DetailGeneratorNode detailNode )
     {
-      return new DeferContainersRemovedDisposable( this );
-    }
+      if( m_floatingDetails.Contains( masterItem ) )
+        return;
 
-    private DependencyObject CreateNextItemContainer()
-    {
-      DependencyObject container = null;
+      var nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+      var masterIndex = nodeHelper.FindItem( masterItem );
+      var masterItemFound = ( masterIndex != -1 );
 
-      if( this.IsRecyclingEnabled )
+      // The master item could be located inside a collapsed group.
+      if( !masterItemFound )
       {
-        container = this.DequeueItemContainer();
+        nodeHelper = new GeneratorNodeHelper( m_startNode, 0, 0 );
+        if( !nodeHelper.Contains( masterItem ) )
+          DataGridException.ThrowSystemException( "An attempt was made to reset a detail for an item that does not belong to the generator.",
+                                                  typeof( InvalidOperationException ), m_dataGridControl.Name );
       }
 
-      if( container == null )
-        container = m_dataGridControl.CreateContainerForItem();
-
-      return container;
-    }
+      var masterNode = ( ItemsGeneratorNode )nodeHelper.CurrentNode;
 
-#if LOG
-    private void WriteStateInLog()
-    {
-      StringBuilder state = new StringBuilder( 1024 );
+      List<DetailGeneratorNode> detailsForMaster;
+      if( ( masterNode.Details == null ) || !masterNode.Details.TryGetValue( masterNode.Items.IndexOf( masterItem ), out detailsForMaster ) )
+        throw new DataGridInternalException( "An attempt was made to reset a detail that does not belong to the generator.", m_dataGridControl );
 
-      state.AppendLine( "Generator state" );
+      //start index will be ignored later on if the masterIndex is -1!!
+      int startIndex = nodeHelper.Index + masterNode.IndexOf( masterItem ) + 1; //details start a master index + 1
 
-      state.AppendLine( " m_genPosToContainer :" );
-      for( int i = 0; i < m_genPosToContainer.Count; i++ )
+      //this is required to ensure that if the details that resets is not the first one, the index is calculated appropriatly.
+      foreach( DetailGeneratorNode node in detailsForMaster )
       {
-        object value = m_genPosToContainer[ i ];
+        if( node == detailNode )
+          break;
 
-        if( value == null )
+        startIndex += node.ItemCount;
+      }
+
+      var removePosition = new GeneratorPosition( -1, 1 );
+      int removedCount = 0;
+      var removedContainers = new List<DependencyObject>();
+      var oldDetailCount = detailNode.ItemCount;
+      var hasOldDetailItems = ( oldDetailCount > 0 );
+
+      if( hasOldDetailItems )
+      {
+        // The information about the removal is only required when the master item is not collapsed.
+        if( masterItemFound )
         {
-          state.AppendLine( "  [ " + i.ToString() + " ] - null" );
+          removePosition = this.GetSafeGeneratorPositionFromIndex( startIndex );
+          removedCount = this.RemoveGeneratedItems( startIndex, startIndex + oldDetailCount - 1, removedContainers );
         }
-        else
+
+        masterNode.AdjustItemCount( -oldDetailCount );
+      }
+
+      detailNode.UpdateItemCount();
+
+      GeneratorPosition addPosition = new GeneratorPosition( -1, 1 );
+      int newDetailCount = detailNode.ItemCount;
+      bool hasNewDetailItems = ( newDetailCount > 0 );
+
+      if( hasNewDetailItems )
+      {
+        // The information about the addition is only required when the master item is not collapsed.
+        if( masterItemFound )
         {
-          state.AppendLine( "  [ " + i.ToString() + " ] - " + value.GetHashCode() );
+          addPosition = this.GetSafeGeneratorPositionFromIndex( startIndex );
         }
+
+        masterNode.AdjustItemCount( newDetailCount );
       }
 
-      state.AppendLine( " m_genPosToIndex :" );
-      for( int i = 0; i < m_genPosToIndex.Count; i++ )
-      {
-        object value = m_genPosToIndex[ i ];
+      this.IncrementCurrentGenerationCount();
 
-        if( value == null )
+      // The events must be raised only when the master item is not collapsed.
+      if( masterItemFound )
+      {
+        if( hasOldDetailItems && hasNewDetailItems )
         {
-          state.AppendLine( "  [ " + i.ToString() + " ] - null" );
+          this.SendResetEvent();
         }
-        else
+        else if( hasOldDetailItems )
         {
-          state.AppendLine( "  [ " + i.ToString() + " ] - " + value.ToString() );
+          this.SendRemoveEvent( removePosition, masterIndex + 1, oldDetailCount, removedCount, removedContainers );
+        }
+        else if( hasNewDetailItems )
+        {
+          this.SendAddEvent( addPosition, masterIndex + 1, newDetailCount );
         }
       }
+    }
 
-      state.AppendLine( " m_genPosToItem :" );
-      for( int i = 0; i < m_genPosToItem.Count; i++ )
+    private void RemoveDetailContainers( GeneratorPosition convertedGeneratorPosition, int removeCount )
+    {
+      int removeGenPosIndex = convertedGeneratorPosition.Index;
+      if( convertedGeneratorPosition.Offset > 0 )
       {
-        object value = m_genPosToItem[ i ];
+        Debug.Assert( convertedGeneratorPosition.Offset == 1 );
+        removeGenPosIndex++;
+      }
 
-        if( value == null )
-        {
-          state.AppendLine( "  [ " + i.ToString() + " ] - null" );
-        }
-        else
-        {
-          state.AppendLine( "  [ " + i.ToString() + " ] - D" + value.GetHashCode() );
-        }
+      for( int i = 0; i < removeCount; i++ )
+      {
+        this.GenPosArraysRemoveAt( removeGenPosIndex );
       }
+    }
 
-      state.AppendLine( " m_genPosToNode :" );
-      for( int i = 0; i < m_genPosToNode.Count; i++ )
+    private GeneratorPosition ConvertDetailGeneratorPosition( GeneratorPosition referencePosition, object masterItem, DetailGeneratorNode detailNode, out int globalIndex )
+    {
+      //If the requested generator position map past at least one generated item from the detail generator, then the job is easy...
+      if( referencePosition.Index >= 0 )
       {
-        object value = m_genPosToNode[ i ];
+        int generatorIndex = this.FindGeneratorIndexForNode( detailNode, referencePosition.Index );
 
-        if( value == null )
-        {
-          state.AppendLine( "  [ " + i.ToString() + " ] - null" );
-        }
-        else
-        {
-          string prefix;
+        // Ensure to return the globalIndex as -1
+        // if the generator index is not found for
+        // a DetailNode. This can occur if a Detail
+        // is filtered out via AutoFiltering.
+        globalIndex = ( generatorIndex > -1 ) ? m_genPosToIndex[ generatorIndex ] : -1;
 
-          if( value is DetailGeneratorNode )
-          {
-            prefix = "DN";
-          }
-          else if( value is ItemsGeneratorNode )
-          {
-            prefix = "IN";
-          }
-          else if( value is CollectionGeneratorNode )
-          {
-            prefix = "CN";
-          }
-          else
-          {
-            prefix = "?N";
-          }
+        return new GeneratorPosition( generatorIndex, referencePosition.Offset );
+      }
+      else
+      {
+        //This means the GeneratorPosition returned by the DetailGenerator is "before" any generated item from the detail generator.
+        //I need more complex detection of the GeneratorPosition.
+
+        // First - Get the Index of the MasterItem
+        int masterIndex = this.IndexFromItem( masterItem );
+
+        //Second - Get the DetailGenerator's Index for the DetailGenerator's GenPos
+        int detailGeneratorIndex = detailNode.DetailGenerator.IndexFromGeneratorPosition( referencePosition );
+
+        globalIndex = masterIndex + detailGeneratorIndex + 1;
 
-          state.AppendLine( "  [ " + i.ToString() + " ] - " + prefix + value.GetHashCode() );
+        // Finally - Have the Master Generator compute the GeneratorPosition from the sum of both
+        return this.GeneratorPositionFromIndex( globalIndex );
+      }
+    }
+
+    private int FindGeneratorIndexForNode( DetailGeneratorNode referenceNode, int offset )
+    {
+      int offsetCounter = -1;
+
+      for( int i = 0; i < m_genPosToNode.Count; i++ )
+      {
+        GeneratorNode node = m_genPosToNode[ i ];
+        if( node == referenceNode )
+        {
+          offsetCounter++;
+          if( offsetCounter == offset )
+            return i;
         }
       }
 
-      state.AppendLine( " m_generatorDirection :" + m_generatorDirection.ToString() );
+      return -1;
+    }
 
-      if( m_generatorCurrentDetail == null )
-      {
-        state.AppendLine( " m_generatorCurrentDetail : null" );
-      }
-      else
+    private DetailGeneratorNode FindDetailGeneratorNodeForGenerator( CustomItemContainerGenerator detailGenerator, out object masterItem )
+    {
+      foreach( KeyValuePair<object, List<DetailGeneratorNode>> detailsForItem in m_masterToDetails )
       {
-        state.AppendLine( " m_generatorCurrentDetail : DN" + m_generatorCurrentDetail.GetHashCode() );
+        foreach( DetailGeneratorNode detailNode in detailsForItem.Value )
+        {
+          if( detailNode.DetailGenerator == detailGenerator )
+          {
+            masterItem = detailsForItem.Key;
+            return detailNode;
+          }
+        }
       }
 
-      state.AppendLine( " m_generatorCurrentDetailIndex : " + m_generatorCurrentDetailIndex.ToString() );
-      state.AppendLine( " m_generatorCurrentDetailNodeIndex : " + m_generatorCurrentDetailNodeIndex.ToString() );
-      state.AppendLine( " m_generatorCurrentGlobalIndex : " + m_generatorCurrentGlobalIndex.ToString() );
-      state.AppendLine( " m_generatorCurrentOffset : " + m_generatorCurrentOffset.ToString() );
-      state.AppendLine( " m_generatorStatus : " + m_generatorStatus.ToString() );
-      state.AppendLine( " m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount : " + m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount.ToString() );
-      state.AppendLine( " m_remapDeferCount : " + m_remapDeferCount.ToString() );
-      state.AppendLine( " m_genPosToIndexUpdateInhibitCount : " + m_genPosToIndexUpdateInhibitCount.ToString() );
-      state.AppendLine( "" );
+      masterItem = null;
+      return null;
+    }
 
-      Log.WriteLine( this, state.ToString() );
+    internal void SetGenPosToIndexUpdateInhibiter( IInhibitGenPosToIndexUpdating inhibiter )
+    {
+      m_genPosToIndexInhibiter = inhibiter;
     }
-#endif
 
-    public void Skip()
+    private IDisposable InhibitParentGenPosToIndexUpdate()
     {
-      if( m_generatorDirection == GeneratorDirection.Forward )
-      {
-        this.MoveGeneratorForward();
-      }
-      else
+      if( m_genPosToIndexInhibiter != null )
       {
-        this.MoveGeneratorBackward();
+        return m_genPosToIndexInhibiter.InhibitGenPosToIndexUpdates();
       }
+      return null;
     }
 
-    // Data Members
+    private int FindFirstGeneratedIndexForLocalItem( object item )
+    {
+      //this function will find an item in the m_genPosToItem, but will filter out those that belongs to details.
+      //This is to avoid the problem caused by Detail items that belongs also to a master.
+      int retval = -1;
 
-    #region Private Fields
+      int runningIndex = 0;
+      int itemCount = m_genPosToItem.Count;
 
-    private BitVector32 m_flags = new BitVector32();
+      while( runningIndex < itemCount )
+      {
+        retval = m_genPosToItem.IndexOf( item, runningIndex );
 
-    private int m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount; // = false;
+        //No item found past the current runningIndex
+        if( retval == -1 )
+          break;
 
-    //This list is used to map from a Realized Item generator position to an actual index. Index in list is the GenPos Index.
-    private readonly List<int> m_genPosToIndex = new List<int>();
-    private readonly List<object> m_genPosToItem = new List<object>();
-    private readonly List<DependencyObject> m_genPosToContainer = new List<DependencyObject>();
-    private readonly List<GeneratorNode> m_genPosToNode = new List<GeneratorNode>();
+        //check if the item belongs to a Detail or not.
+        DetailGeneratorNode detailNode = m_genPosToNode[ retval ] as DetailGeneratorNode;
+        if( detailNode == null )
+          break; //the item is not a detail and therefore qualifies as a return value.
 
-    private readonly Dictionary<object, List<DetailGeneratorNode>> m_masterToDetails = new Dictionary<object, List<DetailGeneratorNode>>();
-    private readonly List<object> m_floatingDetails = new List<object>();
+        //Item is from a detail
+        runningIndex = retval + 1;
+      }
 
-    private GeneratorNode m_startNode;
-    private HeadersFootersGeneratorNode m_firstHeader;
-    private GeneratorNode m_firstItem;
-    private HeadersFootersGeneratorNode m_firstFooter;
+      return retval;
+    }
 
-    private ReadOnlyObservableCollection<Object> m_groupsCollection;
+    private void EnqueueContainer( DependencyObject container, object item )
+    {
+      RecyclingManager manager = m_dataGridContext.RecyclingManager;
 
-    private readonly DataGridControl m_dataGridControl;
-    private readonly DataGridContext m_dataGridContext;
-    private readonly CollectionView m_collectionView;
-    private readonly IList m_listInterface;
-    private readonly GeneratorNodeFactory m_nodeFactory;
+      m_log.Assert( this, manager != null, "manager != null" );
 
-    private int m_currentGeneratorContentGeneration = 0;
+      if( container is HeaderFooterItem )
+      {
+        if( item is GroupHeaderFooterItem )
+        {
+          //If the group is not in the CollectionView anymore (e.g. all its rows have been deleted), do not recycle it.
+          CollectionViewGroup viewGroup = ( ( GroupHeaderFooterItem )item ).Group;
+          if( viewGroup == null )
+            return;
 
-    private int m_lastValidItemCountGeneration = 0;
+          //The tree is already correctly created since we are recycling containers!
+          Group group;
 
-    private int m_cachedItemCount = 0;
+          using( this.SetIsEnsuringNodeTreeCreated() )
+          {
+            group = this.GetGroupFromCollectionViewGroup( viewGroup );
+          }
 
-    private GeneratorStatus m_generatorStatus = GeneratorStatus.NotStarted;
-    private GeneratorDirection m_generatorDirection;
-    private int m_generatorCurrentOffset;
-    private int m_generatorCurrentGlobalIndex = -1;
-    private GeneratorNodeHelper m_generatorNodeHelper; // = null
+          if( group == null )
+            return;
 
-    private readonly Dictionary<CollectionViewGroup, GroupGeneratorNode> m_groupNodeMappingCache = new Dictionary<CollectionViewGroup, GroupGeneratorNode>();
+          string groupBy = group.GroupBy;
+          if( string.IsNullOrEmpty( groupBy ) )
+            return;
 
-    private IDisposable m_generatorCurrentDetailDisposable; // = null
-    private DetailGeneratorNode m_generatorCurrentDetail; // = null
-    private int m_generatorCurrentDetailIndex = -1;
-    private int m_generatorCurrentDetailNodeIndex = -1;
+          manager.EnqueueGroupHeaderFooterContainer( groupBy, item, container );
+        }
+        else
+        {
+          manager.EnqueueHeaderFooterContainer( item, container );
+        }
+      }
+      else
+      {
+        manager.EnqueueItemContainer( item, container );
+      }
+    }
 
-    private int m_genPosToIndexUpdateInhibitCount = 0;
+    private DependencyObject DequeueItemContainer( object item )
+    {
+      RecyclingManager manager = m_dataGridContext.RecyclingManager;
 
-    private IInhibitGenPosToIndexUpdating m_genPosToIndexInhibiter; // = null
-    private IDisposable m_currentGenPosToIndexInhibiterDisposable; // = null
+      m_log.Assert( this, manager != null, "manager != null" );
 
-    private List<DependencyObject> m_deferredContainersRemoved = new List<DependencyObject>();
-    private int m_containersRemovedDeferCount = 0;
+      return manager.DequeueItemContainer( item );
+    }
 
-    private int m_remapDeferCount = 0;
+    private DependencyObject DequeueHeaderFooterContainer( object item )
+    {
+      RecyclingManager manager = m_dataGridContext.RecyclingManager;
 
-    private Binding m_headerFooterDataContextBinding;
+      m_log.Assert( this, manager != null, "manager != null" );
 
-    #endregion
+      if( item is GroupHeaderFooterItem )
+      {
+        CollectionViewGroup viewGroup = ( ( GroupHeaderFooterItem )item ).Group;
+        if( viewGroup == null )
+          return null;
 
-    #region CustomItemContainerGeneratorDisposableDisposer Private Class
+        //The tree is already correctly created since we are recycling containers!
+        Group group;
 
-    private sealed class CustomItemContainerGeneratorDisposableDisposer : IDisposable
-    {
-      public CustomItemContainerGeneratorDisposableDisposer( CustomItemContainerGenerator generator, GeneratorPosition startGenPos, GeneratorDirection direction )
-      {
-        if( generator == null )
+        using( this.SetIsEnsuringNodeTreeCreated() )
         {
-          throw new ArgumentNullException( "generator" );
+          group = this.GetGroupFromCollectionViewGroup( viewGroup );
         }
 
-        m_generator = generator;
-
-        m_generator.StartGenerator( startGenPos, direction );
-      }
+        if( group == null )
+          return null;
 
-      #region IDisposable Members
+        string groupBy = group.GroupBy;
+        if( string.IsNullOrEmpty( groupBy ) )
+          return null;
 
-      public void Dispose()
+        return manager.DequeueGroupHeaderFooterContainer( groupBy, item );
+      }
+      else
       {
-        m_generator.StopGenerator();
-        m_generator = null;
+        return manager.DequeueHeaderFooterContainer( item );
       }
-
-      #endregion
-
-      CustomItemContainerGenerator m_generator = null;
     }
 
-    #endregion
-
-    #region GenPostoIndexInhibitionDisposable Private Class
-
-    private sealed class GenPostoIndexInhibitionDisposable : IDisposable
+    private void OnDetailContainersRemoved( object sender, ContainersRemovedEventArgs e )
     {
-      public GenPostoIndexInhibitionDisposable( CustomItemContainerGenerator generator )
+      if( m_containersRemovedDeferCount > 0 )
       {
-        if( generator == null )
-          throw new ArgumentNullException( "generator" );
-
-        m_generator = generator;
-
-        m_generator.m_genPosToIndexUpdateInhibitCount++;
-
-        if( m_generator.m_genPosToIndexInhibiter != null )
-        {
-          m_nestedDisposable = m_generator.m_genPosToIndexInhibiter.InhibitGenPosToIndexUpdates();
-        }
+        m_deferredContainersRemoved.AddRange( e.RemovedContainers );
       }
-
-      #region IDisposable Members
-
-      public void Dispose()
+      else
       {
-        m_generator.m_genPosToIndexUpdateInhibitCount--;
-
-        if( ( m_generator.m_genPosToIndexUpdateInhibitCount == 0 ) && ( m_generator.GenPosToIndexNeedsUpdate ) )
-        {
-          m_generator.IncrementCurrentGenerationCount();
-        }
-
-        if( m_nestedDisposable != null )
-        {
-          m_nestedDisposable.Dispose();
-          m_nestedDisposable = null;
-        }
+        this.NotifyContainersRemoved( e );
       }
-
-      #endregion
-
-      private CustomItemContainerGenerator m_generator; // = null
-      private IDisposable m_nestedDisposable; // = null
     }
 
-    #endregion
-
-    #region DeferDetailsRemapDisposable Private Class
-
-    private sealed class DeferDetailsRemapDisposable : IDisposable
+    private IDisposable DeferContainersRemovedNotification()
     {
-      public DeferDetailsRemapDisposable( CustomItemContainerGenerator generator )
-      {
-        if( generator == null )
-          throw new ArgumentNullException( "generator" );
+      return new DeferContainersRemovedDisposable( this );
+    }
 
-        m_generator = generator;
+    private DependencyObject CreateNextItemContainer( object item )
+    {
+      DependencyObject container = null;
 
-        m_generator.m_remapDeferCount++;
+      if( this.IsRecyclingEnabled )
+      {
+        container = this.DequeueItemContainer( item );
       }
 
-      #region IDisposable Members
-
-      public void Dispose()
+      if( container == null )
       {
-        m_generator.m_remapDeferCount--;
+        container = m_dataGridControl.CreateContainerForItem();
       }
 
-      #endregion
-
-      private CustomItemContainerGenerator m_generator; // = null
+      return container;
     }
 
-    #endregion
+    private IEnumerable<DataGridContext> GetDetailContexts()
+    {
+      return ( from node in this.GetDetailGeneratorNodes()
+               select node.DetailContext );
+    }
 
-    #region DeferContainersRemovedDisposable Private Class
+    private IEnumerable<CustomItemContainerGenerator> GetDetailGenerators()
+    {
+      return ( from node in this.GetDetailGeneratorNodes()
+               select node.DetailGenerator );
+    }
 
-    private sealed class DeferContainersRemovedDisposable : IDisposable
+    private IEnumerable<DetailGeneratorNode> GetDetailGeneratorNodes()
     {
-      public DeferContainersRemovedDisposable( CustomItemContainerGenerator generator )
+      foreach( List<DetailGeneratorNode> details in m_masterToDetails.Values )
       {
-        if( generator == null )
-          throw new ArgumentNullException( "generator" );
-
-        m_generator = generator;
+        foreach( DetailGeneratorNode detailNode in details )
+        {
+          yield return detailNode;
+        }
+      }
+    }
 
-        Debug.Assert( ( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 ), "( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 )" );
-#if LOG
-        Log.Assert( this, ( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 ), "( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 )" );
-#endif
+    private static IList GetList( CollectionView collectionView )
+    {
+      if( collectionView == null )
+        return null;
 
-        m_generator.m_containersRemovedDeferCount++;
-      }
+      var list = collectionView as IList;
+      if( list != null )
+        return list;
 
-      #region IDisposable Members
+      return collectionView.SourceCollection as IList;
+    }
 
-      public void Dispose()
+    public void Skip()
+    {
+      if( m_generatorDirection == GeneratorDirection.Forward )
       {
-        m_generator.m_containersRemovedDeferCount--;
-
-        if( ( m_generator.m_containersRemovedDeferCount == 0 ) && ( m_generator.m_deferredContainersRemoved.Count > 0 ) )
-        {
-          m_generator.NotifyContainersRemoved( new ContainersRemovedEventArgs( m_generator.m_deferredContainersRemoved ) );
-          m_generator.m_deferredContainersRemoved.Clear();
-        }
+        this.MoveGeneratorForward();
+      }
+      else
+      {
+        this.MoveGeneratorBackward();
       }
+    }
 
-      #endregion
+    // Data Members
 
-      private CustomItemContainerGenerator m_generator; // = null
-    }
+    #region Private Fields
 
-    #endregion
+    private BitVector32 m_flags = new BitVector32();
 
-    #region ProcessingGlobalItemsResetOrRemovingAllGeneratedItemsDisposable Private Class
+    //This list is used to map from a Realized Item generator position to an actual index. Index in list is the GenPos Index.
+    private readonly List<int> m_genPosToIndex = new List<int>();
+    private readonly List<object> m_genPosToItem = new List<object>();
+    private readonly List<DependencyObject> m_genPosToContainer = new List<DependencyObject>();
+    private readonly List<GeneratorNode> m_genPosToNode = new List<GeneratorNode>();
 
-    private sealed class ProcessingGlobalItemsResetOrRemovingAllGeneratedItemsDisposable : IDisposable
-    {
-      public ProcessingGlobalItemsResetOrRemovingAllGeneratedItemsDisposable( CustomItemContainerGenerator generator )
-      {
-        if( generator == null )
-          throw new ArgumentNullException( "generator" );
+    private readonly Dictionary<object, List<DetailGeneratorNode>> m_masterToDetails = new Dictionary<object, List<DetailGeneratorNode>>();
+    private readonly List<object> m_floatingDetails = new List<object>();
 
-        m_generator = generator;
+    private GeneratorNode m_startNode;
+    private GeneratorNode m_firstItem;
 
-        Debug.Assert( ( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 ), "( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 )" );
-#if LOG
-        Log.Assert( this, ( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 ), "( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 )" );
-#endif
+    private ReadOnlyObservableCollection<object> m_groupsCollection;
 
-        m_generator.m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount++;
-      }
+    private readonly DataGridControl m_dataGridControl;
+    private readonly DataGridContext m_dataGridContext;
+    private readonly CollectionView m_collectionView;
 
-      #region IDisposable Members
+    private int m_lastValidItemCountGeneration = 0;
 
-      public void Dispose()
-      {
-        m_generator.m_isProcessingGlobalResetOrRemovingAllGeneratedItemsDisposableCount--;
-      }
+    private int m_cachedItemCount = 0;
 
-      #endregion
+    private GeneratorDirection m_generatorDirection;
+    private int m_generatorCurrentOffset;
+    private int m_generatorCurrentGlobalIndex = -1;
+    private GeneratorNodeHelper m_generatorNodeHelper; // = null
 
-      private CustomItemContainerGenerator m_generator; // = null
-    }
+    private readonly Dictionary<CollectionViewGroup, GroupGeneratorNode> m_groupNodeMappingCache = new Dictionary<CollectionViewGroup, GroupGeneratorNode>();
+    private LateGroupLevelDescription[] m_groupLevelDescriptionCache; // = null
 
-    #endregion
+    private IDisposable m_generatorCurrentDetailDisposable; // = null
+    private DetailGeneratorNode m_generatorCurrentDetail; // = null
+    private int m_generatorCurrentDetailIndex = -1;
+    private int m_generatorCurrentDetailNodeIndex = -1;
 
-    #region CustomItemContainerGeneratorFlags Private Enum
+    private int m_genPosToIndexUpdateInhibitCount = 0;
 
-    [Flags]
-    private enum CustomItemContainerGeneratorFlags : int
-    {
-      RecyclingEnabled = 1,
-      InUse = 2,
-      GenPosToIndexNeedsUpdate = 4,
-      IsHandlingItemsRecreation = 8,
-      IsEnsuringNodeTreeCreated = 16,
-    }
+    private IInhibitGenPosToIndexUpdating m_genPosToIndexInhibiter; // = null
+    private IDisposable m_currentGenPosToIndexInhibiterDisposable; // = null
+
+    private List<DependencyObject> m_deferredContainersRemoved = new List<DependencyObject>();
+    private int m_containersRemovedDeferCount = 0;
+
+    private Binding m_headerFooterDataContextBinding;
 
     #endregion
 
@@ -6459,7 +6631,7 @@ namespace Xceed.Wpf.DataGrid
 
         if( sender == m_collectionView )
         {
-          this.OnItemsChanged( sender, nccArgs );
+          this.OnItemsChanged( sender, nccArgs.GetRangeActionOrSelf() );
           return true;
         }
         else if( sender == m_groupsCollection )
@@ -6475,6 +6647,12 @@ namespace Xceed.Wpf.DataGrid
       }
       else if( managerType == typeof( PropertyChangedEventManager ) )
       {
+        if( sender == m_collectionView )
+        {
+          this.OnCollectionViewGroupsPropertyChanged();
+          return true;
+        }
+
         //this is only registered on the DataGridContext, this has the effect of forwarding property changes for all properties of the DataGridContext
         PropertyChangedEventArgs pcArgs = ( PropertyChangedEventArgs )e;
         this.OnNotifyPropertyChanged( pcArgs );
@@ -6528,7 +6706,7 @@ namespace Xceed.Wpf.DataGrid
 
     IDisposable IInhibitGenPosToIndexUpdating.InhibitGenPosToIndexUpdates()
     {
-      return new GenPostoIndexInhibitionDisposable( this );
+      return new GenPosToIndexInhibitionDisposable( this );
     }
 
     #endregion
@@ -6568,5 +6746,266 @@ namespace Xceed.Wpf.DataGrid
     }
 
     #endregion
+
+    #region InheritAutoResetFlag Private Class
+
+    private sealed class InheritAutoResetFlag : AutoResetFlag
+    {
+      internal InheritAutoResetFlag()
+        : this( null )
+      {
+      }
+
+      internal InheritAutoResetFlag( AutoResetFlag parent )
+      {
+        m_parent = parent;
+        m_current = AutoResetFlagFactory.Create();
+      }
+
+      public override bool IsSet
+      {
+        get
+        {
+          return ( this.IsSetLocal )
+              || ( ( m_parent != null ) && m_parent.IsSet );
+        }
+      }
+
+      public bool IsSetLocal
+      {
+        get
+        {
+          return m_current.IsSet;
+        }
+      }
+
+      public override IDisposable Set()
+      {
+        return m_current.Set();
+      }
+
+      public IDisposable SetLocal()
+      {
+        return this.Set();
+      }
+
+      private readonly AutoResetFlag m_parent;
+      private readonly AutoResetFlag m_current;
+    }
+
+    #endregion
+
+    #region LeveledAutoResetFlag Private Class
+
+    private sealed class LeveledAutoResetFlag : AutoResetFlag
+    {
+      internal LeveledAutoResetFlag()
+        : this( new List<WeakReference>( 3 ), 0 )
+      {
+      }
+
+      private LeveledAutoResetFlag( IList<WeakReference> levels, int index )
+      {
+        Debug.Assert( levels != null );
+        Debug.Assert( ( index >= 0 ) && ( index <= levels.Count ) );
+
+        m_levels = levels;
+        m_flag = AutoResetFlagFactory.Create();
+        m_index = index;
+
+        var self = new WeakReference( this );
+        if( m_index == m_levels.Count )
+        {
+          m_levels.Add( self );
+        }
+        else
+        {
+          m_levels[ m_index ] = self;
+        }
+      }
+
+      public override bool IsSet
+      {
+        get
+        {
+          return m_flag.IsSet;
+        }
+      }
+
+      public override IDisposable Set()
+      {
+        return m_flag.Set();
+      }
+
+      internal LeveledAutoResetFlag GetChild()
+      {
+        int index = m_index + 1;
+        if( index < m_levels.Count )
+        {
+          var flag = ( LeveledAutoResetFlag )m_levels[ index ].Target;
+          if( flag != null )
+            return flag;
+        }
+
+        return new LeveledAutoResetFlag( m_levels, index );
+      }
+
+      private readonly IList<WeakReference> m_levels;
+      private readonly AutoResetFlag m_flag;
+      private readonly int m_index;
+    }
+
+    #endregion
+
+    #region CustomItemContainerGeneratorDisposableDisposer Private Class
+
+    private sealed class CustomItemContainerGeneratorDisposableDisposer : IDisposable
+    {
+      public CustomItemContainerGeneratorDisposableDisposer( CustomItemContainerGenerator generator, GeneratorPosition startGenPos, GeneratorDirection direction )
+      {
+        if( generator == null )
+          throw new ArgumentNullException( "generator" );
+
+        try
+        {
+          generator.StartGenerator( startGenPos, direction );
+        }
+        catch( Exception e )
+        {
+          try
+          {
+            generator.StopGenerator();
+          }
+          catch
+          {
+            // We swallow all exceptions thrown here because the actual exception we want to raise to the user
+            // is the one that has been thrown in the call to StartGenerator.
+          }
+
+          throw new DataGridInternalException( "The generator failed to start.", e, generator.m_dataGridControl );
+        }
+
+        m_generator = generator;
+      }
+
+      void IDisposable.Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var generator = m_generator;
+
+        // Prevent this method from being called more than once.
+        if( Interlocked.CompareExchange<CustomItemContainerGenerator>( ref m_generator, null, generator ) == null )
+          return;
+
+        generator.StopGenerator();
+      }
+
+      ~CustomItemContainerGeneratorDisposableDisposer()
+      {
+        this.Dispose( false );
+      }
+
+      private CustomItemContainerGenerator m_generator; //null
+    }
+
+    #endregion
+
+    #region GenPosToIndexInhibitionDisposable Private Class
+
+    private sealed class GenPosToIndexInhibitionDisposable : IDisposable
+    {
+      public GenPosToIndexInhibitionDisposable( CustomItemContainerGenerator generator )
+      {
+        if( generator == null )
+          throw new ArgumentNullException( "generator" );
+
+        m_generator = generator;
+
+        m_generator.m_genPosToIndexUpdateInhibitCount++;
+
+        if( m_generator.m_genPosToIndexInhibiter != null )
+        {
+          m_nestedDisposable = m_generator.m_genPosToIndexInhibiter.InhibitGenPosToIndexUpdates();
+        }
+      }
+
+      #region IDisposable Members
+
+      public void Dispose()
+      {
+        m_generator.m_genPosToIndexUpdateInhibitCount--;
+
+        if( ( m_generator.m_genPosToIndexUpdateInhibitCount == 0 ) && ( m_generator.GenPosToIndexNeedsUpdate ) )
+        {
+          m_generator.IncrementCurrentGenerationCount();
+        }
+
+        if( m_nestedDisposable != null )
+        {
+          m_nestedDisposable.Dispose();
+          m_nestedDisposable = null;
+        }
+      }
+
+      #endregion
+
+      private CustomItemContainerGenerator m_generator; // = null
+      private IDisposable m_nestedDisposable; // = null
+    }
+
+    #endregion
+
+    #region DeferContainersRemovedDisposable Private Class
+
+    private sealed class DeferContainersRemovedDisposable : IDisposable
+    {
+      public DeferContainersRemovedDisposable( CustomItemContainerGenerator generator )
+      {
+        if( generator == null )
+          throw new ArgumentNullException( "generator" );
+
+        m_generator = generator;
+
+        m_generator.m_log.Assert( this, ( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 ), "( m_generator.m_containersRemovedDeferCount != 0 ) || ( m_generator.m_deferredContainersRemoved.Count == 0 )" );
+
+        m_generator.m_containersRemovedDeferCount++;
+      }
+
+      #region IDisposable Members
+
+      public void Dispose()
+      {
+        m_generator.m_containersRemovedDeferCount--;
+
+        if( ( m_generator.m_containersRemovedDeferCount == 0 ) && ( m_generator.m_deferredContainersRemoved.Count > 0 ) )
+        {
+          m_generator.NotifyContainersRemoved( new ContainersRemovedEventArgs( m_generator.m_deferredContainersRemoved ) );
+          m_generator.m_deferredContainersRemoved.Clear();
+        }
+      }
+
+      #endregion
+
+      private CustomItemContainerGenerator m_generator; // = null
+    }
+
+    #endregion
+
+    #region CustomItemContainerGeneratorFlags Private Enum
+
+    [Flags]
+    private enum CustomItemContainerGeneratorFlags
+    {
+      RecyclingEnabled = 1,
+      InUse = 2,
+      GenPosToIndexNeedsUpdate = 4,
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProvider.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProvider.cs
new file mode 100644
index 00000000..5e24629e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProvider.cs
@@ -0,0 +1,109 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DataItemDataProvider : DataItemDataProviderBase
+  {
+    #region Static Fields
+
+    private static readonly object EmptyDataItem = new object();
+
+    #endregion
+
+    #region IsEmpty Property
+
+    public override bool IsEmpty
+    {
+      get
+      {
+        return m_isEmpty;
+      }
+    }
+
+    private void SetIsEmpty( bool value )
+    {
+      if( m_isEmpty == value )
+        return;
+
+      m_isEmpty = value;
+
+      this.OnPropertyChanged( new PropertyChangedEventArgs( "IsEmpty" ) );
+    }
+
+    private bool m_isEmpty = true;
+
+    #endregion
+
+    public override void SetDataItem( object dataItem )
+    {
+      if( m_dataItem == dataItem )
+        return;
+
+      m_dataItem = dataItem;
+
+      if( this.IsRefreshDeferred )
+        return;
+
+      this.Refresh();
+    }
+
+    public override void ClearDataItem()
+    {
+      if( m_dataItem == DataItemDataProvider.EmptyDataItem )
+        return;
+
+      m_dataItem = DataItemDataProvider.EmptyDataItem;
+
+      if( this.IsRefreshDeferred )
+        return;
+
+      this.Refresh();
+    }
+
+    protected override void BeginQuery()
+    {
+      if( this.IsRefreshDeferred )
+        return;
+
+      base.BeginQuery();
+
+      if( m_dataItem == DataItemDataProvider.EmptyDataItem )
+      {
+        this.OnQueryFinished( null, null, this.OnDataChanged, true );
+      }
+      else
+      {
+        this.OnQueryFinished( m_dataItem, null, this.OnDataChanged, false );
+      }
+    }
+
+    private object OnDataChanged( object arg )
+    {
+      this.SetIsEmpty( ( bool )arg );
+
+      return null;
+    }
+
+    #region Private Fields
+
+    private object m_dataItem = DataItemDataProvider.EmptyDataItem;
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProviderBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProviderBase.cs
new file mode 100644
index 00000000..18b5a77f
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/DataItemDataProviderBase.cs
@@ -0,0 +1,35 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System.Windows.Data;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class DataItemDataProviderBase : DataSourceProvider
+  {
+    #region IsEmpty Property
+
+    public abstract bool IsEmpty
+    {
+      get;
+    }
+
+    #endregion
+
+    public abstract void SetDataItem( object dataItem );
+    public abstract void ClearDataItem();
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/EmptyDataItemDataProvider.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/EmptyDataItemDataProvider.cs
new file mode 100644
index 00000000..0b9c4af9
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/EmptyDataItemDataProvider.cs
@@ -0,0 +1,70 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System.Threading;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class EmptyDataItemDataProvider : DataItemDataProviderBase
+  {
+    #region Constructor
+
+    private EmptyDataItemDataProvider()
+    {
+    }
+
+    #endregion
+
+    #region Instance Static Property
+
+    internal static EmptyDataItemDataProvider Instance
+    {
+      get
+      {
+        if( m_instance == null )
+        {
+          Interlocked.CompareExchange<EmptyDataItemDataProvider>( ref EmptyDataItemDataProvider.m_instance, new EmptyDataItemDataProvider(), null );
+        }
+
+        return m_instance;
+      }
+    }
+
+    private static EmptyDataItemDataProvider m_instance;
+
+    #endregion
+
+    #region IsEmpty Property
+
+    public override bool IsEmpty
+    {
+      get
+      {
+        return true;
+      }
+    }
+
+    #endregion
+
+    public override void SetDataItem( object dataItem )
+    {
+    }
+
+    public override void ClearDataItem()
+    {
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNode.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNode.cs
index ea1ed1cd..c2a5ef90 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNode.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNode.cs
@@ -19,7 +19,7 @@ using System.ComponentModel;
 
 namespace Xceed.Wpf.DataGrid
 {
-  public partial class GeneratorNode
+  internal partial class GeneratorNode
   {
     internal GeneratorNode( GeneratorNode parent )
     {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeFactory.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeFactory.cs
index 2a383858..38c40e8a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeFactory.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeFactory.cs
@@ -19,11 +19,9 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Diagnostics;
-using System.Windows.Data;
-using System.Windows.Controls;
-using System.Collections.ObjectModel;
-using Xceed.Wpf.DataGrid.Utils;
 using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -33,61 +31,53 @@ namespace Xceed.Wpf.DataGrid
                                  NotifyCollectionChangedEventHandler groupsChangedHandler,
                                  EventHandler<ExpansionStateChangedEventArgs> expansionStateChangedHandler,
                                  EventHandler isExpandedChangingHandler,
-                                 EventHandler isExpandedChangedHandler )
+                                 EventHandler isExpandedChangedHandler,
+                                 DataGridControl dataGridControl )
     {
       if( itemsChangedHandler == null )
-      {
         throw new ArgumentNullException( "itemsChangedHandler" );
-      }
 
       if( groupsChangedHandler == null )
-      {
         throw new ArgumentNullException( "groupsChangedHandler" );
-      }
 
       if( expansionStateChangedHandler == null )
-      {
         throw new ArgumentNullException( "expansionStateChangedHandler" );
-      }
 
       if( isExpandedChangingHandler == null )
-      {
         throw new ArgumentNullException( "isExpandedChangingHandler" );
-      }
 
       if( isExpandedChangedHandler == null )
-      {
         throw new ArgumentNullException( "isExpandedChangedHandler" );
-      }
 
       m_itemsChangedHandler = itemsChangedHandler;
       m_groupsChangedHandler = groupsChangedHandler;
       m_expansionStateChangedHandler = expansionStateChangedHandler;
       m_isExpandedChangingHandler = isExpandedChangingHandler;
       m_isExpandedChangedHandler = isExpandedChangedHandler;
+
+      if( dataGridControl != null )
+      {
+        m_dataGridControl = new WeakReference( dataGridControl );
+      }
     }
 
-    #region IWeakEventListener Members
+    #region DataGridControl Private Property
 
-    public bool ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    private DataGridControl DataGridControl
     {
-      if( managerType == typeof( CollectionChangedEventManager ) )
+      get
       {
-        NotifyCollectionChangedEventHandler handler;
-        m_nodesCollectionChangedEventHandlers.TryGetValue( sender, out handler );
-
-        if( handler != null )
-        {
-          handler.Invoke( sender, ( NotifyCollectionChangedEventArgs )e );
-        }
+        if( m_dataGridControl == null )
+          return null;
 
-        return true;
+        return m_dataGridControl.Target as DataGridControl;
       }
-
-      return false;
     }
 
-    #endregion IWeakEventListener Members
+    //For exception purposes only.
+    private readonly WeakReference m_dataGridControl; //null
+
+    #endregion
 
     public GeneratorNode CreateGroupGeneratorNode(
       CollectionViewGroup collectionViewGroup,
@@ -114,12 +104,10 @@ namespace Xceed.Wpf.DataGrid
 
       node.IsExpanded = groupConfig.InitiallyExpanded;
 
-      if( collectionViewGroup.IsBottomLevel == false )
+      if( !collectionViewGroup.IsBottomLevel )
       {
-        IList<object> subItems = collectionViewGroup.GetItems();
-
         this.RegisterNodeCollectionChanged(
-          ( INotifyCollectionChanged )subItems,
+          ( INotifyCollectionChanged )collectionViewGroup.GetItems(),
           new NotifyCollectionChangedEventHandler( node.OnCollectionChanged ) );
 
         node.CollectionChanged += m_groupsChangedHandler;
@@ -151,10 +139,6 @@ namespace Xceed.Wpf.DataGrid
 
       Debug.Assert( notifyCollection != null, "collection must be a INotifyCollectionChanged for CreateItemsGeneratorNode()" );
 
-      //case 113904: If the item source for the ItemsGeneratorNode is an ItemCollection, then
-      //check if the underlying SourceCollection is a DataGridCollectionView.
-      //This particular exception case is there to handle messaging quirks in the case 
-      //of Master Detail edition. Refer to case for more details.
       ItemCollection itemCollection = collection as ItemCollection;
       if( itemCollection != null )
       {
@@ -299,9 +283,7 @@ namespace Xceed.Wpf.DataGrid
       }
       newNode.Next = next;
 
-      this.RegisterNodeCollectionChanged( 
-        ( INotifyCollectionChanged )newNode.Items,
-        new NotifyCollectionChangedEventHandler( newNode.OnCollectionChanged ) );
+      this.RegisterNodeCollectionChanged( ( INotifyCollectionChanged )newNode.Items, new NotifyCollectionChangedEventHandler( newNode.OnCollectionChanged ) );
 
       newNode.CollectionChanged += m_itemsChangedHandler;
       newNode.ExpansionStateChanged += m_expansionStateChangedHandler;
@@ -312,18 +294,15 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void ConfigureHeadersFootersNotification( INotifyCollectionChanged notifyCollection, HeadersFootersGeneratorNode node )
+    private void ConfigureHeadersFootersNotification( INotifyCollectionChanged collection, HeadersFootersGeneratorNode node )
     {
-      List<HeadersFootersGeneratorNode> nodeList;
-      bool keyFound = m_headersFootersMapping.TryGetValue( notifyCollection, out nodeList );
-
-      if( keyFound == false )
+      ICollection<HeadersFootersGeneratorNode> nodeList;
+      if( !m_headersFootersMapping.TryGetValue( collection, out nodeList ) )
       {
-        nodeList = new List<HeadersFootersGeneratorNode>();
+        nodeList = new HashSet<HeadersFootersGeneratorNode>();
 
-        notifyCollection.CollectionChanged += OnHeadersFootersCollectionChanged;
-
-        m_headersFootersMapping.Add( notifyCollection, nodeList );
+        m_headersFootersMapping.Add( collection, nodeList );
+        CollectionChangedEventManager.AddListener( collection, this );
       }
 
       nodeList.Add( node );
@@ -331,47 +310,24 @@ namespace Xceed.Wpf.DataGrid
 
     private void CleanHeadersFootersNotification( HeadersFootersGeneratorNode node )
     {
-      INotifyCollectionChanged notifyCollection = node.Items as INotifyCollectionChanged;
-      if( notifyCollection != null )
-      {
-        try
-        {
-          List<HeadersFootersGeneratorNode> nodeList = m_headersFootersMapping[ notifyCollection ];
+      var collection = node.Items as INotifyCollectionChanged;
+      if( collection == null )
+        return;
 
-          nodeList.Remove( node );
+      try
+      {
+        var nodeList = m_headersFootersMapping[ collection ];
+        nodeList.Remove( node );
 
-          if( nodeList.Count == 0 )
-          {
-            notifyCollection.CollectionChanged -= OnHeadersFootersCollectionChanged;
-            m_headersFootersMapping.Remove( notifyCollection );
-          }
-        }
-        catch( Exception e )
+        if( nodeList.Count == 0 )
         {
-          throw new DataGridInternalException( e );
+          CollectionChangedEventManager.RemoveListener( collection, this );
+          m_headersFootersMapping.Remove( collection );
         }
       }
-    }
-
-    private void OnHeadersFootersCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
-    {
-      INotifyCollectionChanged collectionChanged = sender as INotifyCollectionChanged;
-
-      if( collectionChanged != null )
+      catch( Exception e )
       {
-        try
-        {
-          List<HeadersFootersGeneratorNode> nodeList = m_headersFootersMapping[ collectionChanged ];
-
-          foreach( HeadersFootersGeneratorNode node in nodeList )
-          {
-            m_itemsChangedHandler.Invoke( node, e );
-          }
-        }
-        catch( Exception ex )
-        {
-          throw new DataGridInternalException( ex );
-        }
+        throw new DataGridInternalException( e.Message, e, this.DataGridControl );
       }
     }
 
@@ -391,14 +347,57 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    #region IWeakEventListener Members
+
+    bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      if( managerType == typeof( CollectionChangedEventManager ) )
+      {
+        this.OnCollectionChanged( ( INotifyCollectionChanged )sender, ( NotifyCollectionChangedEventArgs )e );
+        return true;
+      }
+
+      return false;
+    }
+
+    private void OnCollectionChanged( INotifyCollectionChanged source, NotifyCollectionChangedEventArgs e )
+    {
+      NotifyCollectionChangedEventHandler handler;
+      ICollection<HeadersFootersGeneratorNode> nodeList;
+
+      if( m_nodesCollectionChangedEventHandlers.TryGetValue( source, out handler ) )
+      {
+        handler.Invoke( source, e );
+      }
+      else if( m_headersFootersMapping.TryGetValue( source, out nodeList ) )
+      {
+        try
+        {
+          foreach( var node in nodeList )
+          {
+            m_itemsChangedHandler.Invoke( node, e );
+          }
+        }
+        catch( Exception ex )
+        {
+          throw new DataGridInternalException( ex.Message, ex, this.DataGridControl );
+        }
+      }
+    }
+
+    #endregion
+
+    #region Private Fields
+
     private readonly NotifyCollectionChangedEventHandler m_itemsChangedHandler; // = null
     private readonly NotifyCollectionChangedEventHandler m_groupsChangedHandler; // = null
     private readonly EventHandler<ExpansionStateChangedEventArgs> m_expansionStateChangedHandler; // = null
     private readonly EventHandler m_isExpandedChangedHandler; // = null
     private readonly EventHandler m_isExpandedChangingHandler; // = null
 
-    private readonly Dictionary<INotifyCollectionChanged, List<HeadersFootersGeneratorNode>> m_headersFootersMapping = new Dictionary<INotifyCollectionChanged, List<HeadersFootersGeneratorNode>>(32);
+    private readonly Dictionary<INotifyCollectionChanged, ICollection<HeadersFootersGeneratorNode>> m_headersFootersMapping = new Dictionary<INotifyCollectionChanged, ICollection<HeadersFootersGeneratorNode>>( 32 );
+    private readonly Dictionary<object, NotifyCollectionChangedEventHandler> m_nodesCollectionChangedEventHandlers = new Dictionary<object, NotifyCollectionChangedEventHandler>( 32 );
 
-    private readonly Dictionary<object, NotifyCollectionChangedEventHandler> m_nodesCollectionChangedEventHandlers = new Dictionary<object, NotifyCollectionChangedEventHandler>(32);
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeHelper.cs
index 2a7f7776..6423c1d7 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeHelper.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GeneratorNodeHelper.cs
@@ -15,11 +15,9 @@
   ***********************************************************************************/
 
 using System;
-using System.Windows.Data;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Windows;
 using System.Collections;
+using System.Windows;
+using System.Windows.Data;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -221,7 +219,7 @@ namespace Xceed.Wpf.DataGrid
     public bool InsertAfter( GeneratorNode insert )
     {
       if( insert == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "GeneratorNode is null." );
 
       int insertionCount;
       int chainLength;
@@ -238,7 +236,7 @@ namespace Xceed.Wpf.DataGrid
 
       // Move the current node to the last node inserted
       if( !this.MoveToNextBy( chainLength ) )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "Unable to move to the requested generator index." );
 
       return true;
     }
@@ -246,7 +244,7 @@ namespace Xceed.Wpf.DataGrid
     public bool InsertBefore( GeneratorNode insert )
     {
       if( insert == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "GeneratorNode is null" );
 
       int insertionCount;
       int chainLength;
@@ -779,7 +777,10 @@ namespace Xceed.Wpf.DataGrid
       int endSourceDataItemIndex = -1;
 
       if( minIndex < 0 )
-        throw new ArgumentException( "The minimum index must be greater than or equal to zero." );
+      {
+        DataGridException.ThrowSystemException( "The minimum index must be greater than or equal to zero.",
+                                                typeof( ArgumentException ), sourceContext.DataGridControl.Name, "minIndex" );
+      }
 
       if( ( visitorType & DataGridContextVisitorType.DataGridContext ) == DataGridContextVisitorType.DataGridContext )
       {
@@ -893,7 +894,7 @@ namespace Xceed.Wpf.DataGrid
         }
 
         if( !processed )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "Unable to process the visit.", sourceContext.DataGridControl );
 
         if( visitWasStopped )
           break;
@@ -915,7 +916,7 @@ namespace Xceed.Wpf.DataGrid
         {
           bool stopVisit = false;
           visitor.Visit( sourceContext, startSourceDataItemIndex, endSourceDataItemIndex, ref stopVisit );
-          visitWasStopped |= stopVisit;
+          visitWasStopped = visitWasStopped || stopVisit;
         }
       }
     }
@@ -981,7 +982,7 @@ namespace Xceed.Wpf.DataGrid
           ( ( IDataGridContextVisitable )detailNode.DetailGenerator ).AcceptVisitor(
             detailStartIndex, detailEndIndex, visitor, visitorType, visitDetails, out visitWasStopped );
 
-          stopVisit |= visitWasStopped;
+          stopVisit = stopVisit || visitWasStopped;
 
           if( stopVisit )
             break;
@@ -1049,10 +1050,10 @@ namespace Xceed.Wpf.DataGrid
           {
             bool visitWasStopped;
 
-            ( ( IDataGridContextVisitable )detailNode.DetailGenerator ).AcceptVisitor( 
+            ( ( IDataGridContextVisitable )detailNode.DetailGenerator ).AcceptVisitor(
               detailStartIndex, detailEndIndex, visitor, visitorType, visitDetails, out visitWasStopped );
 
-            stopVisit |= visitWasStopped;
+            stopVisit = stopVisit || visitWasStopped;
 
             if( stopVisit )
               break;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GroupGeneratorNode.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GroupGeneratorNode.cs
index 44a7e319..671e27f1 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GroupGeneratorNode.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/GroupGeneratorNode.cs
@@ -230,7 +230,7 @@ namespace Xceed.Wpf.DataGrid
 
         if( this.TotalLeafCountChanged != null )
         {
-          this.TotalLeafCountChanged( this, new EventArgs() );
+          this.TotalLeafCountChanged( this, EventArgs.Empty );
         }
       }
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/NotifyCollectionChangedGeneratorNode.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/NotifyCollectionChangedGeneratorNode.cs
index 5cfce013..11f005bb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/NotifyCollectionChangedGeneratorNode.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/NotifyCollectionChangedGeneratorNode.cs
@@ -19,7 +19,7 @@ using System.ComponentModel;
 
 namespace Xceed.Wpf.DataGrid
 {
-  public class NotifyCollectionChangedGeneratorNode : GeneratorNode, INotifyCollectionChanged
+  internal class NotifyCollectionChangedGeneratorNode : GeneratorNode, INotifyCollectionChanged
   {
     internal NotifyCollectionChangedGeneratorNode( GeneratorNode parent )
       : base( parent )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/RangeSelectionVisitor.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/RangeSelectionVisitor.cs
index fe01531e..175a11b8 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/RangeSelectionVisitor.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/RangeSelectionVisitor.cs
@@ -23,9 +23,10 @@ namespace Xceed.Wpf.DataGrid
 {
   internal class RangeSelectionVisitor : IDataGridContextVisitor
   {
-    public RangeSelectionVisitor( SelectionRange[] selectedColumns )
+    public RangeSelectionVisitor( SelectionRange[] selectedColumns, bool unselect )
     {
       m_selectedColumns = selectedColumns;
+      m_unselect = unselect;
     }
 
     #region IDataGridContextVisitor Members
@@ -56,21 +57,40 @@ namespace Xceed.Wpf.DataGrid
           if( intersectionSelectionRange.IsEmpty )
             continue;
 
-          Debug.WriteLine( "Selection : Adding cell : (" + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() + ") - ("
+#if DEBUG
+          string action = ( m_unselect ) ? "Removing" : "Adding";
+          Debug.WriteLine( "Selection : " + action + " cell : (" + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() + ") - ("
              + intersectionSelectionRange.StartIndex.ToString() + " - " + intersectionSelectionRange.EndIndex.ToString() + ")" );
-
-          selectionChangerManager.SelectCells(
-            sourceContext,
-            new SelectionCellRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null, intersectionSelectionRange ) );
+#endif
+
+          var cellRange = new SelectionCellRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null, intersectionSelectionRange );
+
+          if( m_unselect )
+          {
+            selectionChangerManager.UnselectCells( sourceContext, cellRange );
+          }
+          else
+          {
+            selectionChangerManager.SelectCells( sourceContext, cellRange );
+          }
         }
       }
       else
       {
-        Debug.WriteLine( "Selection : Adding item : " + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() );
+#if DEBUG
+        string action = ( m_unselect ) ? "Removing" : "Adding";
+        Debug.WriteLine( "Selection : " + action + " Adding item : " + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() );
+#endif
+        var itemRange = new SelectionRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null );
 
-        selectionChangerManager.SelectItems(
-          sourceContext,
-          new SelectionRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null ) );
+        if( m_unselect )
+        {
+          selectionChangerManager.UnselectItems( sourceContext, itemRange );
+        }
+        else
+        {
+          selectionChangerManager.SelectItems( sourceContext, itemRange );
+        }
       }
     }
 
@@ -97,5 +117,6 @@ namespace Xceed.Wpf.DataGrid
     #endregion
 
     private SelectionRange[] m_selectedColumns;
+    private bool m_unselect;
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/SelectAllVisitor.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/SelectAllVisitor.cs
index fecd68bd..48a52128 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/SelectAllVisitor.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/SelectAllVisitor.cs
@@ -67,7 +67,7 @@ namespace Xceed.Wpf.DataGrid
       else
       {
         HashedLinkedList<ColumnBase> columnsByVisiblePosition = sourceContext.ColumnsByVisiblePosition;
-        SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage( null, 8 );
+        SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage( null );
         SelectionRange fullColumnRange = new SelectionRange( 0, columnsByVisiblePosition.Count - 1 );
         selectedColumnStore.Add( new SelectionRangeWithItems( fullColumnRange, null ) );
         int index = 0;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/VisibilityChangingEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/VisibilityChangingEventManager.cs
new file mode 100644
index 00000000..819e8582
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(Generator)/VisibilityChangingEventManager.cs
@@ -0,0 +1,72 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class VisibilityChangingEventManager : WeakEventManager
+  {
+    private VisibilityChangingEventManager()
+    {
+    }
+
+    public static void AddListener( ColumnCollection source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( ColumnCollection source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var columnCollection = ( ColumnCollection )source;
+      columnCollection.ColumnVisibilityChanging += new EventHandler( this.OnColumnVisibilityChanging );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var columnCollection = ( ColumnCollection )source;
+      columnCollection.ColumnVisibilityChanging -= new EventHandler( this.OnColumnVisibilityChanging );
+    }
+
+    private static VisibilityChangingEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( VisibilityChangingEventManager );
+        var currentManager = ( VisibilityChangingEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new VisibilityChangingEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    private void OnColumnVisibilityChanging( object sender, EventArgs args )
+    {
+      this.DeliverEvent( sender, args );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemSourceTriggersEnum.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemSourceTriggersEnum.cs
new file mode 100644
index 00000000..423ac4c1
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemSourceTriggersEnum.cs
@@ -0,0 +1,39 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid
+{
+  [Flags]
+  internal enum AutoScrollCurrentItemSourceTriggers
+  {
+    None = 0x0000,
+    Navigation = 0x0001,
+    Editing = 0x0002,
+    FocusChanged = 0x0004,
+    SelectionChanged = 0x0008,
+    SortChanged = 0x0010,
+    GroupChanged = 0x0020,
+    CurrentItemChanged = 0x0040,
+    CurrentColumnChanged = 0x0080,
+    CollectionViewCurrentItemChanged = 0x0100,
+    ColumnsCollectionChanged = 0x0200,
+    ItemsSourceChanged = 0x0400,
+    ViewChanged = 0x0800,
+    ThemeChanged = 0x1000,
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemTriggersEnum.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemTriggersEnum.cs
new file mode 100644
index 00000000..535c7a13
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/AutoScrollCurrentItemTriggersEnum.cs
@@ -0,0 +1,37 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid
+{
+  // Defines the events that trigger the bring into view for the current item.
+  [Flags]
+  public enum AutoScrollCurrentItemTriggers
+  {
+    None = 0x00,
+
+    CurrentChanged = 0x01,
+    ItemsSourceChanged = 0x02,
+    FocusChanged = 0x04,
+    SortChanged = 0x08,
+    GroupChanged = 0x10,
+    ViewChanged = 0x20,
+    ThemeChanged = 0x40,
+
+    All = ~0x00
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/DistinctValuesConstraintEnum.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/DistinctValuesConstraintEnum.cs
index b77db307..17d43d29 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/DistinctValuesConstraintEnum.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/(enums)/DistinctValuesConstraintEnum.cs
@@ -23,6 +23,7 @@ namespace Xceed.Wpf.DataGrid
   public enum DistinctValuesConstraint
   {
     All,
-    Filtered
+    Filtered,
+    FilteredWithAllFilters
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AssemblyVersionInfo.cs
index a8122b41..ecc7b16d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AssemblyVersionInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AssemblyVersionInfo.cs
@@ -19,7 +19,7 @@
 internal static class _XceedVersionInfo
 {
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
-  public const string BaseVersion = "2.3";
+  public const string BaseVersion = "2.4";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
   public const string Version = BaseVersion + ".0.0";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlag.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlag.cs
new file mode 100644
index 00000000..412e166e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlag.cs
@@ -0,0 +1,34 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class AutoResetFlag
+  {
+    #region IsSet Property
+
+    public abstract bool IsSet
+    {
+      get;
+    }
+
+    #endregion
+
+    public abstract IDisposable Set();
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlagFactory.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlagFactory.cs
new file mode 100644
index 00000000..fd06a03b
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoResetFlagFactory.cs
@@ -0,0 +1,156 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal static class AutoResetFlagFactory
+  {
+    public static AutoResetFlag Create()
+    {
+      return AutoResetFlagFactory.Create( true );
+    }
+
+    public static AutoResetFlag Create( bool singleSet )
+    {
+      if( singleSet )
+        return new SingleAutoResetFlag();
+
+      return new MultiAutoResetFlag();
+    }
+
+    #region IAutoResetFlag Private Interface
+
+    private interface IAutoResetFlag
+    {
+      void Set();
+      void Unset();
+    }
+
+    #endregion
+
+    #region ResetFlagDisposable Private Class
+
+    private sealed class ResetFlagDisposable : IDisposable
+    {
+      internal ResetFlagDisposable( IAutoResetFlag target )
+      {
+        Debug.Assert( target != null );
+
+        m_target = target;
+        m_target.Set();
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var target = m_target;
+
+        // The disposed method has already been called at least once.
+        if( Interlocked.CompareExchange<IAutoResetFlag>( ref m_target, null, target ) == null )
+          return;
+
+        Debug.Assert( m_target == null );
+        Debug.Assert( target != null );
+
+        // We can only get here if this is the first call to Dispose.
+        target.Unset();
+      }
+
+      void IDisposable.Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      ~ResetFlagDisposable()
+      {
+        this.Dispose( false );
+      }
+
+      private IAutoResetFlag m_target;
+    }
+
+    #endregion
+
+    #region SingleAutoResetFlag Private Class
+
+    private sealed class SingleAutoResetFlag : AutoResetFlag, IAutoResetFlag
+    {
+      public override bool IsSet
+      {
+        get
+        {
+          return ( Interlocked.CompareExchange( ref m_isSet, null, null ) == this );
+        }
+      }
+
+      public override IDisposable Set()
+      {
+        return new ResetFlagDisposable( this );
+      }
+
+      void IAutoResetFlag.Set()
+      {
+        if( Interlocked.CompareExchange( ref m_isSet, this, null ) != null )
+          throw new InvalidOperationException( "The flag is already set." );
+      }
+
+      void IAutoResetFlag.Unset()
+      {
+        Interlocked.CompareExchange( ref m_isSet, null, this );
+      }
+
+      private object m_isSet; //null
+    }
+
+    #endregion
+
+    #region MultiAutoResetFlag Private Class
+
+    private sealed class MultiAutoResetFlag : AutoResetFlag, IAutoResetFlag
+    {
+      public override bool IsSet
+      {
+        get
+        {
+          return ( m_count > 0 );
+        }
+      }
+
+      public override IDisposable Set()
+      {
+        return new ResetFlagDisposable( this );
+      }
+
+      void IAutoResetFlag.Set()
+      {
+        Interlocked.Increment( ref m_count );
+      }
+
+      void IAutoResetFlag.Unset()
+      {
+        Interlocked.Decrement( ref m_count );
+      }
+
+      private int m_count; //0
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoScrollCurrentItemSourceTriggersRestrictions.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoScrollCurrentItemSourceTriggersRestrictions.cs
new file mode 100644
index 00000000..0b95cf24
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/AutoScrollCurrentItemSourceTriggersRestrictions.cs
@@ -0,0 +1,105 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class AutoScrollCurrentItemSourceTriggersRestrictions
+  {
+    #region Restrictions Property
+
+    internal AutoScrollCurrentItemSourceTriggers Restrictions
+    {
+      get
+      {
+        var result = AutoScrollCurrentItemSourceTriggers.None;
+
+        for( int i = m_restrictions.Count - 1; i >= 0; i-- )
+        {
+          var item = m_restrictions[ i ].Target as SingleRestriction;
+
+          if( item != null )
+          {
+            result |= item.Value;
+          }
+          else
+          {
+            m_restrictions.RemoveAt( i );
+          }
+        }
+
+        return result;
+      }
+    }
+
+    #endregion
+
+    internal IDisposable SetRestriction( AutoScrollCurrentItemSourceTriggers value )
+    {
+      var disposable = new SingleRestriction( value );
+
+      m_restrictions.Add( new WeakReference( disposable ) );
+
+      return disposable;
+    }
+
+    #region Private Fields
+
+    private readonly List<WeakReference> m_restrictions = new List<WeakReference>();
+
+    #endregion
+
+    #region SingleRestriction Private Class
+
+    private sealed class SingleRestriction : IDisposable
+    {
+      internal SingleRestriction( AutoScrollCurrentItemSourceTriggers value )
+      {
+        m_value = value;
+      }
+
+      internal AutoScrollCurrentItemSourceTriggers Value
+      {
+        get
+        {
+          return m_value;
+        }
+      }
+
+      void IDisposable.Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        m_value = AutoScrollCurrentItemSourceTriggers.None;
+      }
+
+      ~SingleRestriction()
+      {
+        this.Dispose( false );
+      }
+
+      private AutoScrollCurrentItemSourceTriggers m_value;
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/ColumnManagerCellAutomationPeer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/ColumnManagerCellAutomationPeer.cs
index 44e397c0..638d30c5 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/ColumnManagerCellAutomationPeer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/ColumnManagerCellAutomationPeer.cs
@@ -141,7 +141,11 @@ namespace Xceed.Wpf.DataGrid.Automation
 
     void ITransformProvider.Resize( double width, double height )
     {
-      this.Owner.DoResize( width );
+      ColumnBase parentColumn = this.Owner.ParentColumn;
+      if( parentColumn == null )
+        return;
+
+      this.Owner.DoResize( width, parentColumn );
     }
 
     void ITransformProvider.Rotate( double degrees )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/DataGridGroupAutomationPeer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/DataGridGroupAutomationPeer.cs
index 0eb98274..0765d04b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/DataGridGroupAutomationPeer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/DataGridGroupAutomationPeer.cs
@@ -15,24 +15,28 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Automation;
 using System.Windows.Automation.Peers;
 using System.Windows.Automation.Provider;
 using System.Windows.Data;
-using System.Windows;
-using System.Windows.Controls;
-using System.Collections;
-using System.Collections.ObjectModel;
-using System.Windows.Automation;
-using System.Globalization;
-using System.Diagnostics;
+using Xceed.Wpf.DataGrid.Utils;
 
 namespace Xceed.Wpf.DataGrid.Automation
 {
-  public class DataGridGroupAutomationPeer : AutomationPeer, IExpandCollapseProvider, IItemContainerProvider
+  public class DataGridGroupAutomationPeer : AutomationPeer, IExpandCollapseProvider, IItemContainerProvider, IWeakEventListener
   {
+    #region Static Fields
+
+    private static readonly string GroupIsExpandedPropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.IsExpanded );
+
+    #endregion
+
     public DataGridGroupAutomationPeer( Group uiGroupOwner )
     {
       if( uiGroupOwner == null )
@@ -41,6 +45,8 @@ namespace Xceed.Wpf.DataGrid.Automation
       m_uiGroupOwner = uiGroupOwner;
       m_dataChildren = new Hashtable( 0 );
       m_headerFooterChildren = new Hashtable( 0 );
+
+      PropertyChangedEventManager.AddListener( uiGroupOwner, this, DataGridGroupAutomationPeer.GroupIsExpandedPropertyName );
     }
 
     #region Owner Property
@@ -53,6 +59,8 @@ namespace Xceed.Wpf.DataGrid.Automation
       }
     }
 
+    private readonly Group m_uiGroupOwner;
+
     #endregion
 
     public override object GetPattern( PatternInterface patternInterface )
@@ -174,7 +182,7 @@ namespace Xceed.Wpf.DataGrid.Automation
 
       for( int i = 0; i < itemsCount; i++ )
       {
-        Object item = items[ i ];
+        object item = items[ i ];
         CollectionViewGroup collectionViewGroup = item as CollectionViewGroup;
 
         if( collectionViewGroup == null )
@@ -372,7 +380,27 @@ namespace Xceed.Wpf.DataGrid.Automation
       throw new NotSupportedException();
     }
 
-    static internal void AddHeaderPeer(
+    private void OnOwnerPropertyChanged( object sender, PropertyChangedEventArgs e )
+    {
+      if( !AutomationPeer.ListenerExists( AutomationEvents.PropertyChanged ) )
+        return;
+
+      Debug.Assert( sender == this.Owner );
+
+      if( string.IsNullOrEmpty( e.PropertyName ) || ( e.PropertyName == DataGridGroupAutomationPeer.GroupIsExpandedPropertyName ) )
+      {
+        if( this.Owner.IsExpanded )
+        {
+          this.RaisePropertyChangedEvent( ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty, ExpandCollapseState.Collapsed, ExpandCollapseState.Expanded );
+        }
+        else
+        {
+          this.RaisePropertyChangedEvent( ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty, ExpandCollapseState.Expanded, ExpandCollapseState.Collapsed );
+        }
+      }
+    }
+
+    internal static void AddHeaderPeer(
       DataGridContext dataGridContext,
       HeadersFootersGeneratorNode node,
       List<AutomationPeer> list,
@@ -411,7 +439,7 @@ namespace Xceed.Wpf.DataGrid.Automation
       }
     }
 
-    static internal void AddFooterPeer(
+    internal static void AddFooterPeer(
       DataGridContext dataGridContext,
       HeadersFootersGeneratorNode node,
       List<AutomationPeer> list,
@@ -648,8 +676,30 @@ namespace Xceed.Wpf.DataGrid.Automation
 
     #endregion
 
-    private Group m_uiGroupOwner;
+    #region IWeakEventListener Members
+
+    bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      if( typeof( PropertyChangedEventManager ) == managerType )
+      {
+        if( sender == this.Owner )
+        {
+          this.OnOwnerPropertyChanged( sender, ( PropertyChangedEventArgs )e );
+        }
+
+        return true;
+      }
+
+      return false;
+    }
+
+    #endregion
+
+    #region Private Fields
+
     private Hashtable m_dataChildren;
     private Hashtable m_headerFooterChildren;
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/HeaderFooterItemAutomationPeer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/HeaderFooterItemAutomationPeer.cs
index 23a3cdf8..78ccef4c 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/HeaderFooterItemAutomationPeer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Automation/HeaderFooterItemAutomationPeer.cs
@@ -16,13 +16,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
 using System.Linq;
-using System.Text;
-using System.Windows.Automation.Peers;
 using System.Windows;
-using System.Globalization;
-using System.Diagnostics;
-using System.Windows.Media;
+using System.Windows.Automation.Peers;
 using System.Windows.Automation.Provider;
 using System.Windows.Controls.Primitives;
 using System.Windows.Threading;
@@ -312,21 +310,17 @@ namespace Xceed.Wpf.DataGrid.Automation
     internal UIElement GetWrapper()
     {
       HeaderFooterItem headerFooterItem = m_owner as HeaderFooterItem;
-
       if( headerFooterItem == null )
       {
-        headerFooterItem =
-          m_dataGridContext.GetContainerFromItem( m_owner ) as HeaderFooterItem;
+        headerFooterItem = m_dataGridContext.GetContainerFromItem( m_owner ) as HeaderFooterItem;
       }
 
       if( headerFooterItem == null )
         return null;
 
-      IDataGridItemContainer dataGridItemContainer = HeaderFooterItem.FindIDataGridItemContainerInChildren(
-        headerFooterItem, headerFooterItem.AsVisual() );
-
-      if( dataGridItemContainer != null )
-        return dataGridItemContainer as UIElement;
+      var container = headerFooterItem.GetTemplatedDescendantDataGridItemContainers().FirstOrDefault();
+      if( container != null )
+        return container as UIElement;
 
       return headerFooterItem;
     }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Cell.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Cell.cs
index c06f5f2c..f739c00b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Cell.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Cell.cs
@@ -27,6 +27,7 @@ using System.Windows;
 using System.Windows.Automation.Peers;
 using System.Windows.Controls;
 using System.Windows.Data;
+using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Threading;
@@ -52,29 +53,23 @@ namespace Xceed.Wpf.DataGrid
     static Cell()
     {
       Cell.ContentProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata(
+          new FrameworkPropertyMetadata(
           new PropertyChangedCallback( OnContentChanged ),
           new CoerceValueCallback( OnCoerceContent ) ) );
 
       //This configures the TAB key to go trough the controls of the cell once... then continue with other controls
-      KeyboardNavigation.TabNavigationProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata( KeyboardNavigationMode.None ) );
+      KeyboardNavigation.TabNavigationProperty.OverrideMetadata( typeof( Cell ), new FrameworkPropertyMetadata( KeyboardNavigationMode.None ) );
 
       //This configures the directional keys to go trough the controls of the cell once... then continue with other controls
-      KeyboardNavigation.DirectionalNavigationProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata( KeyboardNavigationMode.None ) );
+      KeyboardNavigation.DirectionalNavigationProperty.OverrideMetadata( typeof( Cell ), new FrameworkPropertyMetadata( KeyboardNavigationMode.None ) );
 
-      ContentControl.HorizontalContentAlignmentProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata( HorizontalAlignment.Stretch ) );
+      ContentControl.HorizontalContentAlignmentProperty.OverrideMetadata( typeof( Cell ), new FrameworkPropertyMetadata( HorizontalAlignment.Stretch ) );
 
-      ContentControl.VerticalContentAlignmentProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata( VerticalAlignment.Stretch ) );
+      ContentControl.VerticalContentAlignmentProperty.OverrideMetadata( typeof( Cell ), new FrameworkPropertyMetadata( VerticalAlignment.Stretch ) );
 
-      Cell.ContentTemplateProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata( new PropertyChangedCallback( OnContentTemplateChanged ) ) );
+      Cell.ContentTemplateProperty.OverrideMetadata( typeof( Cell ), new FrameworkPropertyMetadata( new PropertyChangedCallback( OnContentTemplateChanged ) ) );
 
-      Cell.ContentTemplateSelectorProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata( new PropertyChangedCallback( OnContentTemplateSelectorChanged ) ) );
+      Cell.ContentTemplateSelectorProperty.OverrideMetadata( typeof( Cell ), new FrameworkPropertyMetadata( new PropertyChangedCallback( OnContentTemplateSelectorChanged ) ) );
 
       Cell.IsCurrentProperty = Cell.IsCurrentPropertyKey.DependencyProperty;
       Cell.IsSelectedProperty = Cell.IsSelectedPropertyKey.DependencyProperty;
@@ -101,29 +96,28 @@ namespace Xceed.Wpf.DataGrid
 
       // Animated Column reordering Binding
       Cell.ParentColumnTranslationBinding = new Binding();
-      Cell.ParentColumnTranslationBinding.Path =
-        new PropertyPath( "ParentColumn.(0)",
-                          ColumnReorderingDragSourceManager.AnimatedColumnReorderingTranslationProperty );
+      Cell.ParentColumnTranslationBinding.Path = new PropertyPath( "ParentColumn.(0)", ColumnReorderingDragSourceManager.AnimatedColumnReorderingTranslationProperty );
       Cell.ParentColumnTranslationBinding.Mode = BindingMode.OneWay;
       Cell.ParentColumnTranslationBinding.RelativeSource = new RelativeSource( RelativeSourceMode.Self );
 
       Cell.ParentColumnIsBeingDraggedBinding = new Binding();
-      Cell.ParentColumnIsBeingDraggedBinding.Path =
-        new PropertyPath( "ParentColumn.(0)",
-                          TableflowView.IsBeingDraggedAnimatedProperty );
+      Cell.ParentColumnIsBeingDraggedBinding.Path = new PropertyPath( "ParentColumn.(0)", TableflowView.IsBeingDraggedAnimatedProperty );
       Cell.ParentColumnIsBeingDraggedBinding.Mode = BindingMode.OneWay;
       Cell.ParentColumnIsBeingDraggedBinding.RelativeSource = new RelativeSource( RelativeSourceMode.Self );
 
-      Row.IsTemplateCellProperty.OverrideMetadata( typeof( Cell ),
-        new FrameworkPropertyMetadata( new PropertyChangedCallback( Cell.OnIsTemplateCellChanged ) ) );
+      Cell.ParentColumnReorderingDragSourceManagerBinding = new Binding();
+      Cell.ParentColumnReorderingDragSourceManagerBinding.Path = new PropertyPath( "ParentColumn.(0)", TableflowView.ColumnReorderingDragSourceManagerProperty );
+      Cell.ParentColumnReorderingDragSourceManagerBinding.Mode = BindingMode.OneWay;
+      Cell.ParentColumnReorderingDragSourceManagerBinding.RelativeSource = new RelativeSource( RelativeSourceMode.Self );
 
       Cell.ParentRowCellContentOpacityBinding = new Binding();
+      Cell.ParentRowCellContentOpacityBinding.Path = new PropertyPath( "(0).(1)", Cell.ParentRowProperty, Row.CellContentOpacityProperty );
       Cell.ParentRowCellContentOpacityBinding.Mode = BindingMode.OneWay;
       Cell.ParentRowCellContentOpacityBinding.RelativeSource = new RelativeSource( RelativeSourceMode.TemplatedParent );
-      Cell.ParentRowCellContentOpacityBinding.Path = new PropertyPath( "(0).(1)", Cell.ParentRowProperty, Row.CellContentOpacityProperty );
 
-      EventManager.RegisterClassHandler( typeof( Cell ), FrameworkElement.RequestBringIntoViewEvent,
-        new RequestBringIntoViewEventHandler( Cell.Cell_RequestBringIntoView ) );
+      Row.IsTemplateCellProperty.OverrideMetadata( typeof( Cell ), new FrameworkPropertyMetadata( new PropertyChangedCallback( Cell.OnIsTemplateCellChanged ) ) );
+
+      EventManager.RegisterClassHandler( typeof( Cell ), FrameworkElement.RequestBringIntoViewEvent, new RequestBringIntoViewEventHandler( Cell.Cell_RequestBringIntoView ) );
     }
 
     public Cell()
@@ -168,8 +162,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region ReadOnly Property
 
-    public static readonly DependencyProperty ReadOnlyProperty =
-        DataGridControl.ReadOnlyProperty.AddOwner( typeof( Cell ) );
+    public static readonly DependencyProperty ReadOnlyProperty = DataGridControl.ReadOnlyProperty.AddOwner( typeof( Cell ) );
 
     public bool ReadOnly
     {
@@ -214,7 +207,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion IsCurrent Read-Only Property
 
-    #region IsSelected Read-only Property
+    #region IsSelected Read-Only Property
 
     private static readonly DependencyPropertyKey IsSelectedPropertyKey =
         DependencyProperty.RegisterReadOnly( "IsSelected", typeof( bool ), typeof( Cell ), new UIPropertyMetadata( false ) );
@@ -244,12 +237,15 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion IsSelected Property
+    #endregion IsSelected Read-Only Property
 
     #region IsBeingEdited Read-Only Property
 
-    private static readonly DependencyPropertyKey IsBeingEditedPropertyKey =
-        DependencyProperty.RegisterReadOnly( "IsBeingEdited", typeof( bool ), typeof( Cell ), new PropertyMetadata( false ) );
+    private static readonly DependencyPropertyKey IsBeingEditedPropertyKey = DependencyProperty.RegisterReadOnly(
+      "IsBeingEdited",
+      typeof( bool ),
+      typeof( Cell ),
+      new PropertyMetadata( false ) );
 
     public static readonly DependencyProperty IsBeingEditedProperty;
 
@@ -282,9 +278,11 @@ namespace Xceed.Wpf.DataGrid
         CellState cellState = this.GetEditCachedState();
 
         if( cellState != null )
+        {
           cellState.SetIsBeingEdited( value );
+        }
 
-        if( !m_parentRow.IsClearingContainer )
+        if( !this.ParentRow.IsClearingContainer )
         {
           //If cell is being edited
           if( value )
@@ -304,8 +302,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region IsDirty Read-Only Property
 
-    private static readonly DependencyPropertyKey IsDirtyPropertyKey =
-        DependencyProperty.RegisterReadOnly( "IsDirty", typeof( bool ), typeof( Cell ), new PropertyMetadata( false, new PropertyChangedCallback( OnIsDirtyChanged ) ) );
+    private static readonly DependencyPropertyKey IsDirtyPropertyKey = DependencyProperty.RegisterReadOnly(
+      "IsDirty",
+      typeof( bool ),
+      typeof( Cell ),
+      new PropertyMetadata( false, new PropertyChangedCallback( Cell.OnIsDirtyChanged ) ) );
 
     public static readonly DependencyProperty IsDirtyProperty;
 
@@ -335,7 +336,9 @@ namespace Xceed.Wpf.DataGrid
         CellState cellState = this.GetEditCachedState();
 
         if( cellState != null )
+        {
           cellState.SetIsDirty( value );
+        }
       }
     }
 
@@ -343,8 +346,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region IsDirtyFromInitializingInsertionRow Read-Only Property
 
-    private static readonly DependencyPropertyKey IsDirtyFromInitializingInsertionRowPropertyKey =
-        DependencyProperty.RegisterReadOnly( "IsDirtyFromInitializingInsertionRow", typeof( bool ), typeof( Cell ), new PropertyMetadata( false ) );
+    private static readonly DependencyPropertyKey IsDirtyFromInitializingInsertionRowPropertyKey = DependencyProperty.RegisterReadOnly(
+      "IsDirtyFromInitializingInsertionRow",
+      typeof( bool ),
+      typeof( Cell ),
+      new PropertyMetadata( false ) );
 
     internal static readonly DependencyProperty IsDirtyFromInitializingInsertionRowProperty;
 
@@ -541,11 +547,28 @@ namespace Xceed.Wpf.DataGrid
         return;
       }
 
+      cell.DelayRefreshErrorStyle();
+    }
+
+    private void DelayRefreshErrorStyle()
+    {
+      if( m_delayedRefreshErrorStyleDispatcherOperation != null )
+        return;
+
       // Push on the dispatcher so that we prevent multiple affectation of Style when the binding is re-evaluated.
       // Re-evaluating a binding causes it to clear all errors, then validate and finally sets the errors.
       // By using the following strategy, we make sure of not affecting Style when it will change right afterward.
-      cell.m_delayedRefreshErrorStyleDispatcherOperation = cell.Dispatcher.BeginInvoke(
-        DispatcherPriority.Render, new Action( cell.DelayedRefreshErrorStyle ) );
+      m_delayedRefreshErrorStyleDispatcherOperation = this.Dispatcher.BeginInvoke( DispatcherPriority.Render, new Action( this.DelayedRefreshErrorStyle ) );
+    }
+
+    private void AbortRefreshErrorStyle()
+    {
+      if( m_delayedRefreshErrorStyleDispatcherOperation == null )
+        return;
+
+      Debug.Assert( m_delayedRefreshErrorStyleDispatcherOperation.Status == DispatcherOperationStatus.Pending );
+      m_delayedRefreshErrorStyleDispatcherOperation.Abort();
+      m_delayedRefreshErrorStyleDispatcherOperation = null;
     }
 
     private void DelayedRefreshErrorStyle()
@@ -612,8 +635,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region IsValidationErrorRestrictive Read-Only Property
 
-    private static readonly DependencyPropertyKey IsValidationErrorRestrictivePropertyKey =
-        DependencyProperty.RegisterReadOnly( "IsValidationErrorRestrictive", typeof( bool ), typeof( Cell ), new PropertyMetadata( false ) );
+    private static readonly DependencyPropertyKey IsValidationErrorRestrictivePropertyKey = DependencyProperty.RegisterReadOnly(
+      "IsValidationErrorRestrictive",
+      typeof( bool ),
+      typeof( Cell ),
+      new PropertyMetadata( false ) );
 
     public static readonly DependencyProperty IsValidationErrorRestrictiveProperty =
       Cell.IsValidationErrorRestrictivePropertyKey.DependencyProperty;
@@ -757,7 +783,9 @@ namespace Xceed.Wpf.DataGrid
           Row row = this.ParentRow;
 
           if( row != null )
+          {
             row.UpdateHasErrorFlags( this );
+          }
         }
       }
       finally
@@ -797,7 +825,8 @@ namespace Xceed.Wpf.DataGrid
     #region CellDisplayEditorMatchingConditions Property
 
     private static readonly DependencyProperty CellDisplayEditorMatchingConditionsProperty =
-        DependencyProperty.Register( "CellDisplayEditorMatchingConditions", typeof( CellEditorDisplayConditions ), typeof( Cell ), new UIPropertyMetadata( CellEditorDisplayConditions.None, new PropertyChangedCallback( OnMatchingDisplayEditorChanged ) ) );
+        DependencyProperty.Register( "CellDisplayEditorMatchingConditions", typeof( CellEditorDisplayConditions ), typeof( Cell ),
+                                     new UIPropertyMetadata( CellEditorDisplayConditions.None, new PropertyChangedCallback( OnMatchingDisplayEditorChanged ) ) );
 
     internal void SetDisplayEditorMatchingCondition( CellEditorDisplayConditions condition )
     {
@@ -928,10 +957,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region ParentColumn Read-Only Property
 
-    private static readonly DependencyPropertyKey ParentColumnPropertyKey =
-        DependencyProperty.RegisterReadOnly(
-          "ParentColumn", typeof( ColumnBase ), typeof( Cell ),
-          new PropertyMetadata( null ) );
+    private static readonly DependencyPropertyKey ParentColumnPropertyKey = DependencyProperty.RegisterReadOnly(
+      "ParentColumn",
+      typeof( ColumnBase ),
+      typeof( Cell ),
+      new PropertyMetadata( null ) );
 
     public static readonly DependencyProperty ParentColumnProperty;
 
@@ -939,49 +969,52 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_parentColumn;
+        return ( ColumnBase )this.GetValue( Cell.ParentColumnProperty );
       }
     }
 
-    private void SetParentColumn( ColumnBase value )
+    internal virtual void SetParentColumn( ColumnBase value )
     {
       if( value == null )
         throw new ArgumentNullException( "value" );
 
       // There is nothing to do if the parent column is the same.
-      if( value == m_parentColumn )
+      var parentColumn = this.ParentColumn;
+      if( value == parentColumn )
         return;
 
       // Unregister from the old Parent Column's event.
-      if( m_parentColumn != null )
+      if( parentColumn != null )
       {
-        CellEditorDisplayConditionsChangedEventManager.RemoveListener( m_parentColumn, this );
-        CellContentTemplateChangedEventManager.RemoveListener( m_parentColumn, this );
-        CanBeCurrentWhenReadOnlyChangedEventManager.RemoveListener( m_parentColumn, this );
+        CellEditorDisplayConditionsChangedEventManager.RemoveListener( parentColumn, this );
+        CellContentTemplateChangedEventManager.RemoveListener( parentColumn, this );
+        CanBeCurrentWhenReadOnlyChangedEventManager.RemoveListener( parentColumn, this );
+        CellContentStringFormatChangedEventManager.RemoveListener( parentColumn, this );
 
-        var editableParentColumn = m_parentColumn as Column;
-        if( editableParentColumn != null )
+        var dataBoundParentColumn = parentColumn as Column;
+        if( dataBoundParentColumn != null )
         {
-          ForeignKeyConfigurationChangedEventManager.RemoveListener( editableParentColumn, this );
+          ForeignKeyConfigurationChangedEventManager.RemoveListener( dataBoundParentColumn, this );
         }
       }
 
-      m_parentColumn = value;
       this.SetValue( Cell.ParentColumnPropertyKey, value );
-
       this.UpdateAnimatedColumnReorderingBindings( Row.GetIsTemplateCell( this ) );
 
+      Debug.Assert( value == this.ParentColumn );
+
       // Register to the new Parent Column's event.
-      if( m_parentColumn != null )
+      if( value != null )
       {
-        CellEditorDisplayConditionsChangedEventManager.AddListener( m_parentColumn, this );
-        CellContentTemplateChangedEventManager.AddListener( m_parentColumn, this );
-        CanBeCurrentWhenReadOnlyChangedEventManager.AddListener( m_parentColumn, this );
+        CellEditorDisplayConditionsChangedEventManager.AddListener( value, this );
+        CellContentTemplateChangedEventManager.AddListener( value, this );
+        CanBeCurrentWhenReadOnlyChangedEventManager.AddListener( value, this );
+        CellContentStringFormatChangedEventManager.AddListener( value, this );
 
-        var editableParentColumn = m_parentColumn as Column;
-        if( editableParentColumn != null )
+        var dataBoundParentColumn = value as Column;
+        if( dataBoundParentColumn != null )
         {
-          ForeignKeyConfigurationChangedEventManager.AddListener( editableParentColumn, this );
+          ForeignKeyConfigurationChangedEventManager.AddListener( dataBoundParentColumn, this );
         }
       }
     }
@@ -990,8 +1023,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region ParentRow Read-Only Property
 
-    private static readonly DependencyPropertyKey ParentRowPropertyKey =
-        DependencyProperty.RegisterReadOnly( "ParentRow", typeof( Row ), typeof( Cell ), new PropertyMetadata( null ) );
+    private static readonly DependencyPropertyKey ParentRowPropertyKey = DependencyProperty.RegisterReadOnly(
+      "ParentRow",
+      typeof( Row ),
+      typeof( Cell ),
+      new PropertyMetadata( null ) );
 
     public static readonly DependencyProperty ParentRowProperty;
 
@@ -999,7 +1035,7 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_parentRow;
+        return ( Row )this.GetValue( Cell.ParentRowProperty );
       }
     }
 
@@ -1008,16 +1044,9 @@ namespace Xceed.Wpf.DataGrid
       if( value == null )
         throw new ArgumentNullException( "value" );
 
-      // There is nothing to do if the parent row is the same.
-      if( value == m_parentRow )
-        return;
-
-      m_parentRow = value;
       this.SetValue( Cell.ParentRowPropertyKey, value );
     }
 
-    private Row m_parentRow; // local cache to speed up DP's Read property operations
-
     #endregion ParentRow Read-Only Property
 
     #region FieldName Property
@@ -1033,7 +1062,6 @@ namespace Xceed.Wpf.DataGrid
 
         return m_fieldName;
       }
-
       set
       {
         ColumnBase parentColumn = this.ParentColumn;
@@ -1054,9 +1082,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region CoercedContentTemplate Property
 
-    private static readonly DependencyPropertyKey CoercedContentTemplatePropertyKey
-        = DependencyProperty.RegisterReadOnly( "CoercedContentTemplate", typeof( DataTemplate ), typeof( Cell ),
-            new FrameworkPropertyMetadata( ( DataTemplate )null ) );
+    private static readonly DependencyPropertyKey CoercedContentTemplatePropertyKey = DependencyProperty.RegisterReadOnly(
+      "CoercedContentTemplate",
+      typeof( DataTemplate ),
+      typeof( Cell ),
+      new FrameworkPropertyMetadata( null ) );
 
     public static readonly DependencyProperty CoercedContentTemplateProperty;
 
@@ -1064,45 +1094,33 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_coercedContentTemplateCache;
+        return ( DataTemplate )this.GetValue( Cell.CoercedContentTemplateProperty );
       }
     }
 
-    private void SetCoercedContentTemplate( DataTemplate viewerTemplate, DataTemplate editTemplate )
+    private void SetCoercedContentTemplate( DataTemplate viewerTemplate, DataTemplate editorTemplate )
     {
-      if( ( viewerTemplate != m_coercedContentTemplateCache ) || ( editTemplate != m_coercedContentEditorTemplateCache ) )
-      {
-        m_coercedContentTemplateCache = viewerTemplate;
-        m_coercedContentEditorTemplateCache = editTemplate;
-
-        if( editTemplate != null )
-        {
-          DataTemplate combineTemplate = new DataTemplate();
-          FrameworkElementFactory grid = new FrameworkElementFactory( typeof( Grid ) );
+      var contentTemplate = this.CoercedContentTemplate;
+      var editorDataTemplate = contentTemplate as EditorDataTemplate;
 
-          FrameworkElementFactory viewerContent = new FrameworkElementFactory( typeof( InnerCellContentPresenter ) );
-          viewerContent.SetValue( InnerCellContentPresenter.VisibilityProperty, Visibility.Hidden );
-          viewerContent.SetValue( InnerCellContentPresenter.ContentTemplateProperty, viewerTemplate );
-
-          FrameworkElementFactory editorContent = new FrameworkElementFactory( typeof( InnerCellContentPresenter ) );
-          editorContent.SetValue( InnerCellContentPresenter.ContentTemplateProperty, editTemplate );
+      if( editorDataTemplate != null )
+      {
+        if( ( editorDataTemplate.Viewer == viewerTemplate ) && ( editorDataTemplate.Editor == editorTemplate ) )
+          return;
+      }
+      else if( editorTemplate == null )
+      {
+        if( contentTemplate == viewerTemplate )
+          return;
+      }
 
-          grid.AppendChild( viewerContent );
-          grid.AppendChild( editorContent );
+      var newContentTemplate = ( editorTemplate != null )
+                                 ? EditorDataTemplate.Create( viewerTemplate, editorTemplate )
+                                 : viewerTemplate;
 
-          combineTemplate.VisualTree = grid;
-          this.SetValue( CoercedContentTemplatePropertyKey, combineTemplate );
-        }
-        else
-        {
-          this.SetValue( CoercedContentTemplatePropertyKey, viewerTemplate );
-        }
-      }
+      this.SetValue( Cell.CoercedContentTemplatePropertyKey, newContentTemplate );
     }
 
-    private DataTemplate m_coercedContentTemplateCache;
-    private DataTemplate m_coercedContentEditorTemplateCache;
-
     #endregion
 
     #region ContentTemplateInternal Property (private)
@@ -1182,9 +1200,9 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region ParentColumnIsBeingDragged Property
+    #region ParentColumnIsBeingDragged Private Property
 
-    internal static readonly DependencyProperty ParentColumnIsBeingDraggedProperty = DependencyProperty.Register(
+    private static readonly DependencyProperty ParentColumnIsBeingDraggedProperty = DependencyProperty.Register(
       "ParentColumnIsBeingDragged",
       typeof( bool ),
       typeof( Cell ),
@@ -1193,7 +1211,7 @@ namespace Xceed.Wpf.DataGrid
         new PropertyChangedCallback( Cell.OnParentColumnIsBeingDraggedChanged ),
         new CoerceValueCallback( Cell.OnCoerceParentColumnIsBeingDragged ) ) );
 
-    internal bool ParentColumnIsBeingDragged
+    private bool ParentColumnIsBeingDragged
     {
       get
       {
@@ -1207,65 +1225,83 @@ namespace Xceed.Wpf.DataGrid
 
     private static void OnParentColumnIsBeingDraggedChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      Cell cell = sender as Cell;
-
-      if( cell == null )
-        return;
-
-      Row row = cell.ParentRow;
+      var self = ( Cell )sender;
+      Debug.Assert( self != null );
 
+      var row = self.ParentRow;
       if( row == null )
         return;
 
-      FixedCellPanel fixedCellPanel = row.CellsHostPanel as FixedCellPanel;
-
+      var fixedCellPanel = row.CellsHostPanel as FixedCellPanel;
       if( fixedCellPanel == null )
         return;
 
       if( ( bool )e.NewValue )
       {
-        fixedCellPanel.ChangeCellZOrder( cell, fixedCellPanel.Children.Count );
+        fixedCellPanel.ChangeCellZOrder( self, fixedCellPanel.Children.Count );
       }
       else
       {
-        fixedCellPanel.ClearCellZOrder( cell );
+        fixedCellPanel.ClearCellZOrder( self );
       }
     }
 
     private static object OnCoerceParentColumnIsBeingDragged( DependencyObject sender, object newValue )
     {
-      Cell cell = sender as Cell;
+      var self = ( Cell )sender;
+      Debug.Assert( self != null );
 
-      if( cell == null )
+      var manager = TableflowView.GetColumnReorderingDragSourceManager( self.ParentColumn );
+      if( manager == null )
         return newValue;
 
-      bool isBeingDraggedAnimated = ( bool )newValue;
+      if( ( bool )newValue )
+      {
+        self.AddDraggedColumnGhost( manager, true );
+      }
+      else
+      {
+        self.RemoveDraggedColumnGhost( manager );
+      }
+
+      return newValue;
+    }
+
+    #endregion
 
-      ColumnReorderingDragSourceManager manager =
-          TableflowView.GetColumnReorderingDragSourceManager( cell.ParentColumn );
+    #region ParentColumnReorderingDragSourceManager Property
 
-      if( manager != null )
+    internal static readonly DependencyProperty ParentColumnReorderingDragSourceManagerProperty = DependencyProperty.Register(
+      "ParentColumnReorderingDragSourceManager",
+      typeof( ColumnReorderingDragSourceManager ),
+      typeof( Cell ),
+      new FrameworkPropertyMetadata( null, new PropertyChangedCallback( Cell.OnParentColumnReorderingDragSourceManagerChanged ) ) );
+
+    internal ColumnReorderingDragSourceManager ParentColumnReorderingDragSourceManager
+    {
+      get
       {
-        // Tell the manager to add or remove an adorner for this Cell.
-        if( isBeingDraggedAnimated )
-        {
-          // Never ask for a ghost if the Cell is virtualized.
-          // We still call RemoveDraggedColumnGhost to ensure
-          // the ghost will be cleared if AutoScroll is enabled
-          if( cell.IsContainerPrepared )
-          {
-            manager.AddDraggedColumnGhost( cell );
-          }
-        }
-        else
-        {
-          manager.RemoveDraggedColumnGhost( cell );
-          // Ensure to reset opacity on the Cell
-          cell.ClearValue( Cell.OpacityProperty );
-        }
+        return ( ColumnReorderingDragSourceManager )this.GetValue( Cell.ParentColumnReorderingDragSourceManagerProperty );
+      }
+      set
+      {
+        this.SetValue( Cell.ParentColumnReorderingDragSourceManagerProperty, value );
       }
+    }
 
-      return newValue;
+    private static void OnParentColumnReorderingDragSourceManagerChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var self = sender as Cell;
+      Debug.Assert( self != null );
+
+      var oldManager = ( ColumnReorderingDragSourceManager )e.OldValue;
+      var newManager = ( ColumnReorderingDragSourceManager )e.NewValue;
+
+      if( ( oldManager != null ) && ( newManager != null ) )
+      {
+        self.RemoveDraggedColumnGhost( oldManager );
+        self.AddDraggedColumnGhost( newManager, self.ParentColumnIsBeingDragged );
+      }
     }
 
     #endregion
@@ -1282,11 +1318,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return ( Brush )this.GetValue( Row.SelectionBackgroundProperty );
+        return ( Brush )this.GetValue( Cell.SelectionBackgroundProperty );
       }
       set
       {
-        this.SetValue( Row.SelectionBackgroundProperty, value );
+        this.SetValue( Cell.SelectionBackgroundProperty, value );
       }
     }
 
@@ -1304,11 +1340,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return ( Brush )this.GetValue( Row.SelectionForegroundProperty );
+        return ( Brush )this.GetValue( Cell.SelectionForegroundProperty );
       }
       set
       {
-        this.SetValue( Row.SelectionForegroundProperty, value );
+        this.SetValue( Cell.SelectionForegroundProperty, value );
       }
     }
 
@@ -1326,11 +1362,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return ( Brush )this.GetValue( Row.InactiveSelectionBackgroundProperty );
+        return ( Brush )this.GetValue( Cell.InactiveSelectionBackgroundProperty );
       }
       set
       {
-        this.SetValue( Row.InactiveSelectionBackgroundProperty, value );
+        this.SetValue( Cell.InactiveSelectionBackgroundProperty, value );
       }
     }
 
@@ -1348,16 +1384,61 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return ( Brush )this.GetValue( Row.InactiveSelectionForegroundProperty );
+        return ( Brush )this.GetValue( Cell.InactiveSelectionForegroundProperty );
       }
       set
       {
-        this.SetValue( Row.InactiveSelectionForegroundProperty, value );
+        this.SetValue( Cell.InactiveSelectionForegroundProperty, value );
       }
     }
 
     #endregion InactiveSelectionForeground Property
 
+    #region ParentForeground Property
+
+    [Browsable( false )]
+    [EditorBrowsable( EditorBrowsableState.Never )]
+    public static readonly DependencyProperty ParentForegroundProperty = DependencyProperty.Register(
+      "ParentForeground",
+      typeof( Brush ),
+      typeof( Cell ),
+      new FrameworkPropertyMetadata( TextElement.ForegroundProperty.DefaultMetadata.DefaultValue ) );
+
+    [Browsable( false )]
+    [EditorBrowsable( EditorBrowsableState.Never )]
+    public Brush ParentForeground
+    {
+      get
+      {
+        return ( Brush )this.GetValue( Cell.ParentForegroundProperty );
+      }
+      set
+      {
+        this.SetValue( Cell.ParentForegroundProperty, value );
+      }
+    }
+
+    private void UpdateParentForeground()
+    {
+      // Use the visual parent when there is no logical parent.
+      var parent = LogicalTreeHelper.GetParent( this ) ?? VisualTreeHelper.GetParent( this );
+
+      if( parent != null )
+      {
+        var binding = new Binding();
+        binding.Path = new PropertyPath( TextElement.ForegroundProperty );
+        binding.Source = parent;
+
+        this.SetBinding( Cell.ParentForegroundProperty, binding );
+      }
+      else
+      {
+        this.ClearValue( Cell.ParentForegroundProperty );
+      }
+    }
+
+    #endregion ParentForeground Property
+
     #region IsInternalyInitialized Property
 
     internal bool IsInternalyInitialized
@@ -1428,7 +1509,23 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return !this.HasCellEditorError;
+        if( this.IsDirty || this.HasValidationError || this.HasCellEditorError )
+          return false;
+
+        if( !this.IsErrorStyleApplied )
+        {
+          // We should not recycle the cell if the user has set a style or template explicitly.
+          if( Cell.IsValueSourceHazardingCellRecycling( DependencyPropertyHelper.GetValueSource( this, Cell.StyleProperty ) )
+            || Cell.IsValueSourceHazardingCellRecycling( DependencyPropertyHelper.GetValueSource( this, Cell.TemplateProperty ) ) )
+            return false;
+        }
+        else if( m_styleBeforeError != DependencyProperty.UnsetValue )
+        {
+          // The regular style has been set by the user.
+          return false;
+        }
+
+        return true;
       }
     }
 
@@ -1663,6 +1760,11 @@ namespace Xceed.Wpf.DataGrid
     private void ResetNonTransientFlags()
     {
       m_flags = new BitVector32( m_flags.Data & ( int )( CellFlags.IsInternalyInitialized ) );
+
+      if( !this.HasPendingErrorStyleRefresh )
+      {
+        this.AbortRefreshErrorStyle();
+      }
     }
 
     #endregion
@@ -1832,7 +1934,7 @@ namespace Xceed.Wpf.DataGrid
           {
             try
             {
-              dataGridContext.SetCurrentColumnCore( null, true, false );
+              dataGridContext.SetCurrentColumnCore( null, true, false, AutoScrollCurrentItemSourceTriggers.Navigation );
             }
             catch( DataGridException )
             {
@@ -1880,30 +1982,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    protected override void OnMouseEnter( MouseEventArgs e )
-    {
-      //If the current CellEditorDisplayConditions requires display when mouse is over the Cell 
-      if( Cell.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverCell ) )
-      {
-        //Display the editors for the Row
-        this.SetDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverCell );
-      }
-
-      base.OnMouseEnter( e );
-    }
-
-    protected override void OnMouseLeave( MouseEventArgs e )
-    {
-      //If the current CellEditorDisplayConditions requires display when mouse is over the Cell 
-      if( Cell.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverCell ) )
-      {
-        //Display the editors for the Row
-        this.RemoveDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverCell );
-      }
-
-      base.OnMouseLeave( e );
-    }
-
     protected override void OnPreviewTextInput( TextCompositionEventArgs e )
     {
       base.OnPreviewTextInput( e );
@@ -2002,6 +2080,13 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    protected override void OnVisualParentChanged( DependencyObject oldParent )
+    {
+      base.OnVisualParentChanged( oldParent );
+
+      this.UpdateParentForeground();
+    }
+
     protected override AutomationPeer OnCreateAutomationPeer()
     {
       return new CellAutomationPeer( this );
@@ -2093,9 +2178,8 @@ namespace Xceed.Wpf.DataGrid
       if( parentColumn == null )
         throw new ArgumentNullException( "parentColumn" );
 
-      //There is nothing to be done if the cell is being reinitialized with
-      //the same parent row and the same parent column.
       if( ( this.IsInternalyInitialized )
+        && ( this.IsContainerPrepared )
         && ( parentColumn == this.ParentColumn )
         && ( parentRow == this.ParentRow ) )
         return;
@@ -2103,20 +2187,24 @@ namespace Xceed.Wpf.DataGrid
       //Mark the cell has being recycled to prevent some check to occur.
       this.IsContainerRecycled = this.IsInternalyInitialized;
 
-      //A cell that hasn't been prepare once or that has a new parent column
-      //due to recycling needs to be prepared again.
-      this.IsContainerPrepared = false;
-
-      this.InitializeCore( dataGridContext, parentRow, parentColumn );
+      try
+      {
+        //A cell that hasn't been prepare once or that has a new parent column
+        //due to recycling needs to be prepared again.
+        this.IsContainerPrepared = false;
 
-      //Set the Initialized flag to True for the Cell instance.
-      this.IsInternalyInitialized = true;
+        this.InitializeCore( dataGridContext, parentRow, parentColumn );
 
-      this.PostInitialize();
+        this.IsInternalyInitialized = true;
 
-      //From here, there is no difference between a fresh new cell and
-      //a recycled cell.
-      this.IsContainerRecycled = false;
+        this.PostInitialize();
+      }
+      finally
+      {
+        //From here, there is no difference between a fresh new cell and
+        //a recycled cell.
+        this.IsContainerRecycled = false;
+      }
     }
 
     protected internal virtual void PostInitialize()
@@ -2124,7 +2212,7 @@ namespace Xceed.Wpf.DataGrid
       if( this.ParentRow.IsBeingEdited )
       {
         // Cell was added to the row's CreatedCells.  Update the parentColumn's cell in edition state.
-        ColumnBase parentColumn = this.ParentColumn;
+        var parentColumn = this.ParentColumn;
 
         if( ( parentColumn != null ) && ( parentColumn.CurrentRowInEditionCellState == null ) )
         {
@@ -2155,43 +2243,12 @@ namespace Xceed.Wpf.DataGrid
 
       Cell.AssignDataContext( this, item, null, parentColumn, out isNewDataContext );
 
-      if( !isNewDataContext && UpdateContentBindingTargetOnPrepareContainer )
+      if( !isNewDataContext && this.UpdateContentBindingTargetOnPrepareContainer )
       {
         // The DataContext is already this item, update the cell's Content binding target in order for the validation to be once again evaluated.
         this.UpdateContentBindingTarget();
       }
 
-      if( parentColumn != null )
-      {
-        object cellVerticalContentAlignmentObject = parentColumn.ReadLocalValue( ColumnBase.CellVerticalContentAlignmentProperty );
-
-        // In case we have a BindingExpression, we need to get the resulting value.
-        if( cellVerticalContentAlignmentObject is BindingExpressionBase )
-        {
-          cellVerticalContentAlignmentObject = parentColumn.CellVerticalContentAlignment;
-        }
-
-        //If the ParentColumn has value defined
-        if( ( cellVerticalContentAlignmentObject != DependencyProperty.UnsetValue ) && ( cellVerticalContentAlignmentObject != null ) )
-        {
-          this.VerticalContentAlignment = ( VerticalAlignment )cellVerticalContentAlignmentObject;
-        }
-
-        object cellHorizontalContentAlignmentObject = parentColumn.ReadLocalValue( ColumnBase.CellHorizontalContentAlignmentProperty );
-
-        // In case we have a BindingExpression, we need to get the resulting value.
-        if( cellHorizontalContentAlignmentObject is BindingExpressionBase )
-        {
-          cellHorizontalContentAlignmentObject = parentColumn.CellHorizontalContentAlignment;
-        }
-
-        //If the ParentColumn has value defined
-        if( ( cellHorizontalContentAlignmentObject != DependencyProperty.UnsetValue ) && ( cellHorizontalContentAlignmentObject != null ) )
-        {
-          this.HorizontalContentAlignment = ( HorizontalAlignment )cellHorizontalContentAlignmentObject;
-        }
-      }
-
       Row parentRow = this.ParentRow;
       ColumnBase currentColumn = dataGridContext.CurrentColumn;
 
@@ -2208,7 +2265,6 @@ namespace Xceed.Wpf.DataGrid
       if( ( this.Content == null ) && ( !( this.GetRealDataContext() is EmptyDataItem ) ) )
       {
         this.ClearValue( Cell.CoercedContentTemplatePropertyKey );
-        m_coercedContentTemplateCache = null;
       }
 
       //Determine the default CellContentTemplate for the cell.
@@ -2230,11 +2286,17 @@ namespace Xceed.Wpf.DataGrid
       if( !this.IsContainerPrepared )
         return;
 
+      this.IsContainerPrepared = false;
+
       // In DP's PropertyChanged Callbacks, for the sake of performance, you could
       // return immediatly if the cell is in process of being cleared.
 
-      // Clear every properties related to the visual state of the Cell
-      this.ClearContainerVisualState();
+      this.ClearValue( Cell.IsCurrentPropertyKey );
+      this.ClearValue( Cell.IsBeingEditedPropertyKey );
+      this.SetIsSelected( false );
+      this.SetIsCellEditorDisplayed( false );
+      this.CurrentEditorPendingDisplayState = EditorDisplayState.None;
+      this.IsContainerVirtualized = true;
 
       // We must not clear the IsDirty flag of the Cell here since its
       // Content could have been edited and this flag is checked
@@ -2246,19 +2308,8 @@ namespace Xceed.Wpf.DataGrid
       // neither DataGridControl.CellEditorDisplayConditionsProperty since
       // both will be updated when Cell.PrepareContainer is called again
 
-      if( m_delayedRefreshErrorStyleDispatcherOperation != null )
-      {
-        System.Diagnostics.Debug.Assert( m_delayedRefreshErrorStyleDispatcherOperation.Status == DispatcherOperationStatus.Pending );
-        m_delayedRefreshErrorStyleDispatcherOperation.Abort();
-        m_delayedRefreshErrorStyleDispatcherOperation = null;
-      }
-
-      if( m_delayedHideEditTemplateDispatcherOperation != null )
-      {
-        System.Diagnostics.Debug.Assert( m_delayedHideEditTemplateDispatcherOperation.Status == DispatcherOperationStatus.Pending );
-        m_delayedHideEditTemplateDispatcherOperation.Abort();
-        m_delayedHideEditTemplateDispatcherOperation = null;
-      }
+      this.AbortRefreshErrorStyle();
+      this.AbortHideEditTemplate();
 
       if( m_loadedRoutedEventHandler != null )
       {
@@ -2281,15 +2332,14 @@ namespace Xceed.Wpf.DataGrid
 
     protected internal virtual void PrepareDefaultStyleKey( Xceed.Wpf.DataGrid.Views.ViewBase view )
     {
-      object currentThemeKey = view.GetDefaultStyleKey( typeof( Cell ) );
+      var newThemeKey = view.GetDefaultStyleKey( typeof( Cell ) );
+      if( object.Equals( this.DefaultStyleKey, newThemeKey ) )
+        return;
 
-      if( currentThemeKey.Equals( this.DefaultStyleKey ) == false )
-      {
-        this.DefaultStyleKey = currentThemeKey;
-      }
+      this.DefaultStyleKey = newThemeKey;
     }
 
-    protected internal virtual void AddContentBinding()
+    protected internal virtual void AddContentBinding( DataGridContext dataGridContext, Row parentRow, ColumnBase parentColumn )
     {
     }
 
@@ -2297,6 +2347,22 @@ namespace Xceed.Wpf.DataGrid
     {
     }
 
+    internal static Cell FindFromChildOrSelf( DataGridControl dataGridControl, DependencyObject child )
+    {
+      var cell = child as Cell;
+      if( cell != null )
+      {
+        if( dataGridControl == null )
+          return cell;
+
+        var dataGridContext = DataGridControl.GetDataGridContext( cell );
+        if( ( dataGridContext != null ) && ( dataGridContext.DataGridControl == dataGridControl ) )
+          return cell;
+      }
+
+      return Cell.FindFromChild( dataGridControl, child );
+    }
+
     internal static bool GetIsUIValidationError( CellValidationError validationError )
     {
       if( validationError == null )
@@ -2391,6 +2457,21 @@ namespace Xceed.Wpf.DataGrid
       return null;
     }
 
+    internal static bool IsValueSourceHazardingCellRecycling( ValueSource valueSource )
+    {
+      switch( valueSource.BaseValueSource )
+      {
+        case BaseValueSource.Local:
+        case BaseValueSource.ParentTemplate:
+        case BaseValueSource.ParentTemplateTrigger:
+        case BaseValueSource.Unknown:
+          return true;
+
+        default:
+          return false;
+      }
+    }
+
     internal static void AssignDataContext( Cell cell, object dataContext, UnboundDataItem unboundDataItemContext, ColumnBase parentColumn, out bool isNewDataContext )
     {
       Column column = parentColumn as Column;
@@ -2398,7 +2479,9 @@ namespace Xceed.Wpf.DataGrid
       if( ( column != null ) && ( column.IsBoundToDataGridUnboundItemProperty ) )
       {
         if( unboundDataItemContext == null )
+        {
           UnboundDataItem.GetUnboundDataItemNode( dataContext, out unboundDataItemContext );
+        }
 
         dataContext = unboundDataItemContext;
       }
@@ -2427,20 +2510,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    //Used to virtualize a Cell, but keep every associations to data item This is used to keep bindings live on the data item to allow ValidationRules to be processed correctly.
-    internal void ClearContainerVisualState()
-    {
-      this.ClearValue( Cell.IsCurrentPropertyKey );
-      this.ClearValue( Cell.IsBeingEditedPropertyKey );
-      this.SetIsSelected( false );
-
-      this.SetIsCellEditorDisplayed( false );
-
-      this.CurrentEditorPendingDisplayState = EditorDisplayState.None;
-
-      this.IsContainerVirtualized = true;
-    }
-
     //This ensures the CellEditorContext is set on the Cell to avoid problems with RelativeSource causing undesired behaviors when ComboBox is used as default CellEditor
     internal void EnsureCellEditorContext()
     {
@@ -2534,7 +2603,9 @@ namespace Xceed.Wpf.DataGrid
         BindingExpressionBase bindingExpression = this.GetContentBindingExpression();
 
         if( bindingExpression != null )
+        {
           bindingExpression.UpdateTarget();
+        }
       }
     }
 
@@ -2634,24 +2705,25 @@ namespace Xceed.Wpf.DataGrid
 
     internal CellState GetEditCachedState()
     {
-      CellState cellState = null;
-
-      Row parentRow = this.ParentRow;
+      var cellState = default( CellState );
+      var parentRow = this.ParentRow;
 
-      if( ( parentRow != null ) && ( ( parentRow.IsBeingEdited ) || ( m_parentRow.IsBeginningEdition ) ) )
+      if( ( parentRow != null ) && ( ( parentRow.IsBeingEdited ) || ( parentRow.IsBeginningEdition ) ) )
       {
-        DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
+        var dataGridContext = DataGridControl.GetDataGridContext( this );
 
         if( dataGridContext != null )
         {
-          DataGridControl dataGridControl = dataGridContext.DataGridControl;
+          var dataGridControl = dataGridContext.DataGridControl;
 
           if( ( dataGridControl != null ) && ( dataGridControl.CurrentRowInEditionState != null ) )
           {
-            ColumnBase parentColumn = this.ParentColumn;
+            var parentColumn = this.ParentColumn;
 
             if( parentColumn != null )
+            {
               cellState = parentColumn.CurrentRowInEditionCellState;
+            }
           }
         }
       }
@@ -2714,6 +2786,7 @@ namespace Xceed.Wpf.DataGrid
         // No need to enable animated Column reordering when TemplateCell is used
         BindingOperations.ClearBinding( this, Cell.RenderTransformProperty );
         BindingOperations.ClearBinding( this, Cell.ParentColumnIsBeingDraggedProperty );
+        BindingOperations.ClearBinding( this, Cell.ParentColumnReorderingDragSourceManagerProperty );
         this.AnimatedColumnReorderingBindingApplied = false;
       }
       else
@@ -2723,6 +2796,7 @@ namespace Xceed.Wpf.DataGrid
           // To enable animated Column reordering
           BindingOperations.SetBinding( this, Cell.RenderTransformProperty, Cell.ParentColumnTranslationBinding );
           BindingOperations.SetBinding( this, Cell.ParentColumnIsBeingDraggedProperty, Cell.ParentColumnIsBeingDraggedBinding );
+          BindingOperations.SetBinding( this, Cell.ParentColumnReorderingDragSourceManagerProperty, Cell.ParentColumnReorderingDragSourceManagerBinding );
           this.AnimatedColumnReorderingBindingApplied = true;
         }
       }
@@ -2731,39 +2805,32 @@ namespace Xceed.Wpf.DataGrid
     internal virtual void EnsureInVisualTree()
     {
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
       if( dataGridContext == null )
         return;
 
       TableView view = dataGridContext.DataGridControl.GetView() as TableView;
-
       if( view == null )
         return;
 
       Row parentRow = this.ParentRow;
-
       if( parentRow == null )
         return;
 
       FixedCellPanel fixedCellPanel = parentRow.CellsHostPanel as FixedCellPanel;
-
       if( fixedCellPanel == null )
         return;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager =
-        ColumnVirtualizationManager.GetColumnVirtualizationManager( dataGridContext ) as TableViewColumnVirtualizationManager;
-
+      var columnVirtualizationManager = ColumnVirtualizationManager.GetColumnVirtualizationManager( dataGridContext ) as TableViewColumnVirtualizationManagerBase;
       if( columnVirtualizationManager == null )
         return;
 
-      if( columnVirtualizationManager.FixedFieldNames.Contains( this.FieldName ) )
+      if( columnVirtualizationManager.GetFixedFieldNames( this.ParentRow.LevelCache ).Contains( this.FieldName ) )
         return;
 
       if( !fixedCellPanel.ForceScrollingCellToLayout( this ) )
         return;
 
       UIElement container = dataGridContext.GetContainerFromItem( this.GetRealDataContext() ) as UIElement;
-
       if( container == null )
         return;
 
@@ -2773,6 +2840,16 @@ namespace Xceed.Wpf.DataGrid
       container.UpdateLayout();
     }
 
+    internal virtual DataTemplate GetForeignKeyDataTemplate()
+    {
+      return null;
+    }
+
+    internal virtual DataTemplate GetCellStringFormatDataTemplate( DataTemplate contentTemplate )
+    {
+      return null;
+    }
+
     private static object OnCoerceContent( DependencyObject sender, object value )
     {
       Cell cell = sender as Cell;
@@ -2834,7 +2911,9 @@ namespace Xceed.Wpf.DataGrid
       else if( changeDuringRowIsInEdit )
       {
         if( !object.Equals( e.OldValue, e.NewValue ) )
+        {
           cell.SetIsDirty( true );
+        }
 
         if( !cell.PreventValidateAndSetAllErrors )
         {
@@ -2952,38 +3031,67 @@ namespace Xceed.Wpf.DataGrid
 
     private bool GetInheritedReadOnly()
     {
-      ColumnBase parentColumn = this.ParentColumn;
+      var isReadOnly = false;
+      var parentRow = this.ParentRow;
+      var parentColumn = this.ParentColumn;
 
-      object readOnly;
-      readOnly = this.ReadLocalValue( Cell.ReadOnlyProperty );
+      if( m_readOnlyIsInternalySet )
+      {
+        this.ClearValue( Cell.ReadOnlyProperty );
+        m_readOnlyIsInternalySet = false;
+      }
 
-      // In case we have a BindingExpression, we need to get the resulting value.
-      if( readOnly is BindingExpressionBase )
-        readOnly = this.ReadOnly;
+      var readOnlyPropertyValueSource = DependencyPropertyHelper.GetValueSource( this, Cell.ReadOnlyProperty );
+      var isDataBound = readOnlyPropertyValueSource.BaseValueSource > BaseValueSource.Inherited;
+
+      //If a value is set in any way (explicitly or implicitly) by the user on the cell, use that value.
+      if( isDataBound )
+      {
+        isReadOnly = this.ReadOnly;
+      }
 
-      if( ( readOnly == DependencyProperty.UnsetValue )
-        && ( parentColumn != null ) )
+      //If a value is set in any way (explicitly or implicitly) by the user on the row, use that value.
+      if( !isDataBound && ( parentRow != null ) )
       {
-        readOnly = parentColumn.ReadLocalValue( ColumnBase.ReadOnlyProperty );
+        readOnlyPropertyValueSource = DependencyPropertyHelper.GetValueSource( parentRow, Row.ReadOnlyProperty );
+        isDataBound = readOnlyPropertyValueSource.BaseValueSource > BaseValueSource.Inherited;
 
-        // In case we have a BindingExpression, we need to get the resulting value.
-        if( readOnly is BindingExpressionBase )
-          readOnly = parentColumn.ReadOnly;
+        if( isDataBound )
+        {
+          isReadOnly = parentRow.ReadOnly;
+          this.ReadOnly = isReadOnly;
+          m_readOnlyIsInternalySet = true;
+        }
       }
 
-      if( readOnly == DependencyProperty.UnsetValue )
-        readOnly = this.ReadOnly;
+      //If a value is set in any way (explicitly or implicitly) by the user on the column, use that value.
+      if( !isDataBound && ( parentColumn != null ) )
+      {
+        readOnlyPropertyValueSource = DependencyPropertyHelper.GetValueSource( parentColumn, ColumnBase.ReadOnlyProperty );
+        isDataBound = readOnlyPropertyValueSource.BaseValueSource > BaseValueSource.Inherited;
 
-      if( ( bool )readOnly )
-        return true;
+        if( isDataBound )
+        {
+          isReadOnly = parentColumn.ReadOnly;
+          this.ReadOnly = isReadOnly;
+          m_readOnlyIsInternalySet = true;
+        }
+      }
 
-      BindingExpressionBase contentBindingExpression = this.GetContentBindingExpression();
+      //If no value set by the user at any level, use the one set by the framework on the cell.
+      if( !isDataBound )
+      {
+        isReadOnly = this.ReadOnly;
+      }
+
+      if( ( bool )isReadOnly )
+        return true;
 
+      var contentBindingExpression = this.GetContentBindingExpression();
       if( contentBindingExpression == null )
         return false;
 
       Nullable<BindingMode> contentBindingMode = null;
-
       if( contentBindingExpression is BindingExpression )
       {
         contentBindingMode = ( ( Binding )contentBindingExpression.ParentBindingBase ).Mode;
@@ -2993,10 +3101,7 @@ namespace Xceed.Wpf.DataGrid
         contentBindingMode = ( ( MultiBinding )contentBindingExpression.ParentBindingBase ).Mode;
       }
 
-      if( ( contentBindingMode == null ) || ( contentBindingMode == BindingMode.TwoWay ) )
-        return false;
-
-      return true;
+      return ( contentBindingMode.HasValue ) && ( contentBindingMode.Value != BindingMode.TwoWay );
     }
 
     private bool ShouldInvalidateCellContentTemplateSelector()
@@ -3074,56 +3179,32 @@ namespace Xceed.Wpf.DataGrid
 
     private DataTemplate GetCoercedCellContentTemplate()
     {
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
+      var dataGridContext = DataGridControl.GetDataGridContext( this );
       if( dataGridContext == null )
         return null;
 
-      DataTemplate contentTemplate = this.ContentTemplateInternal;
+      var contentTemplate = this.ContentTemplateInternal;
+      var content = this.Content;
 
-      //If there is a ContentTemplate assigned directly on Cell, use it
-      if( contentTemplate != null )
-        return contentTemplate;
-
-      object content = this.Content;
-
-      //If none, check if there is a ContentTemplateSelector directly assigned on cell.
-      DataTemplateSelector contentTemplateSelector = this.ContentTemplateSelectorInternal;
-
-      if( contentTemplateSelector != null )
+      if( contentTemplate == null )
       {
-        //If there is one, the query it for a ContentTemplate.
-        contentTemplate = contentTemplateSelector.SelectTemplate( content, this );
+        //If none, check if there is a ContentTemplateSelector directly assigned on cell.
+        var contentTemplateSelector = this.ContentTemplateSelectorInternal;
+        if( contentTemplateSelector != null )
+        {
+          //If there is one, the query it for a ContentTemplate.
+          contentTemplate = contentTemplateSelector.SelectTemplate( content, this );
+        }
       }
 
+      var parentColumn = this.ParentColumn;
+
       //If there was no ContentTemplateSelector on Cell or if the output of the selector was Null.
       if( ( !this.OverrideColumnCellContentTemplate ) && ( contentTemplate == null ) )
       {
-        ColumnBase parentColumn = this.ParentColumn;
-
-        Column column = parentColumn as Column;
-
-        if( column != null )
-        {
-          ForeignKeyConfiguration configuration = column.ForeignKeyConfiguration;
-
-          DataTemplate foreignKeyContentTemplate = null;
-
-          // If a foreignKey CellContentTemplate was found by the configuration,
-          // it must be used even if a CellContentTemplate is defined because the 
-          // CellContentTemplate will be used by this template
-          if( configuration != null )
-          {
-            // Try to get a CellContentTemplate specific for a ForeignKeyConfiguration
-            foreignKeyContentTemplate = configuration.DefaultCellContentTemplate;
-
-            if( ( foreignKeyContentTemplate != null )
-              && ( this is DataCell ) )
-            {
-              contentTemplate = foreignKeyContentTemplate;
-            }
-          }
-        }
+        contentTemplate = this.GetForeignKeyDataTemplate();
+        if( contentTemplate != null )
+          return contentTemplate;
 
         if( contentTemplate == null )
         {
@@ -3133,8 +3214,7 @@ namespace Xceed.Wpf.DataGrid
           //if it doesn't, then check for a selector on Column
           if( contentTemplate == null )
           {
-            contentTemplateSelector = parentColumn.CellContentTemplateSelector;
-
+            var contentTemplateSelector = parentColumn.CellContentTemplateSelector;
             if( contentTemplateSelector != null )
             {
               //If a selector exists on Column, then use it.
@@ -3147,7 +3227,19 @@ namespace Xceed.Wpf.DataGrid
       //After all of this, if there is still no ContentTemplate found, then use the default basic one.
       if( contentTemplate == null )
       {
-        contentTemplate = Column.GenericContentTemplateSelector.Instance.SelectTemplate( content, this );
+        contentTemplate = GenericContentTemplateSelector.Instance.SelectTemplate( content, this );
+      }
+
+      if( contentTemplate != null )
+      {
+        if( ( parentColumn != null ) && !string.IsNullOrEmpty( parentColumn.CellContentStringFormat ) )
+        {
+          var newContentTemplate = this.GetCellStringFormatDataTemplate( contentTemplate );
+          if( newContentTemplate != null )
+          {
+            contentTemplate = newContentTemplate;
+          }
+        }
       }
 
       return contentTemplate;
@@ -3212,12 +3304,7 @@ namespace Xceed.Wpf.DataGrid
 
     private void ShowEditTemplate()
     {
-      if( m_delayedHideEditTemplateDispatcherOperation != null )
-      {
-        System.Diagnostics.Debug.Assert( m_delayedHideEditTemplateDispatcherOperation.Status == DispatcherOperationStatus.Pending );
-        m_delayedHideEditTemplateDispatcherOperation.Abort();
-        m_delayedHideEditTemplateDispatcherOperation = null;
-      }
+      this.AbortHideEditTemplate();
 
       // The editor is not pending showing
       if( this.CurrentEditorPendingDisplayState != EditorDisplayState.PendingShow )
@@ -3257,6 +3344,16 @@ namespace Xceed.Wpf.DataGrid
         new Action( this.HideEditTemplate ), DispatcherPriority.DataBind );
     }
 
+    private void AbortHideEditTemplate()
+    {
+      if( m_delayedHideEditTemplateDispatcherOperation == null )
+        return;
+
+      Debug.Assert( m_delayedHideEditTemplateDispatcherOperation.Status == DispatcherOperationStatus.Pending );
+      m_delayedHideEditTemplateDispatcherOperation.Abort();
+      m_delayedHideEditTemplateDispatcherOperation = null;
+    }
+
     private void HideEditTemplate()
     {
       m_delayedHideEditTemplateDispatcherOperation = null;
@@ -3281,6 +3378,26 @@ namespace Xceed.Wpf.DataGrid
       Cell.ClearCellEditorContext( this );
     }
 
+    private void AddDraggedColumnGhost( ColumnReorderingDragSourceManager manager, bool isBeingDraggedAnimated )
+    {
+      if( !isBeingDraggedAnimated || !this.IsContainerPrepared || manager.ContainsDraggedColumnGhost( this ) )
+        return;
+
+      this.ClearValue( Cell.OpacityProperty );
+
+      manager.AddDraggedColumnGhost( this );
+    }
+
+    private void RemoveDraggedColumnGhost( ColumnReorderingDragSourceManager manager )
+    {
+      if( !manager.ContainsDraggedColumnGhost( this ) )
+        return;
+
+      manager.RemoveDraggedColumnGhost( this );
+
+      this.ClearValue( Cell.OpacityProperty );
+    }
+
     private void UpdateMatchingDisplayConditions()
     {
       CellEditorDisplayConditions newEffectiveValue = CellEditorDisplayConditions.None;
@@ -3320,7 +3437,7 @@ namespace Xceed.Wpf.DataGrid
       {
         DataGridCollectionView dataGridCollectionView = dataGridControl.ItemsSource as DataGridCollectionView;
 
-        if( dataGridCollectionView != null )
+        if( ( dataGridCollectionView != null ) && ( dataGridCollectionView.StatFunctions.Count > 0 ) )
         {
           int currentIndex;
 
@@ -3389,7 +3506,7 @@ namespace Xceed.Wpf.DataGrid
       this.Loaded -= m_loadedRoutedEventHandler;
       m_loadedRoutedEventHandler = null;
 
-      this.Dispatcher.BeginInvoke( DispatcherPriority.Render, new Action( this.DelayedRefreshErrorStyle ) );
+      this.DelayRefreshErrorStyle();
     }
 
     private void Cell_LayoutUpdated( object sender, EventArgs e )
@@ -3622,7 +3739,7 @@ namespace Xceed.Wpf.DataGrid
 
       // If there is no dataItem mapped to this container, we don't want to
       // enter in edition
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
+      var dataGridContext = DataGridControl.GetDataGridContext( this );
 
       if( dataGridContext != null )
       {
@@ -3634,7 +3751,7 @@ namespace Xceed.Wpf.DataGrid
 
       Debug.Assert( this.IsContainerPrepared, "Can't edit a cell that has not been prepared." );
 
-      Row parentRow = this.ParentRow;
+      var parentRow = this.ParentRow;
 
       try
       {
@@ -3661,20 +3778,29 @@ namespace Xceed.Wpf.DataGrid
         {
           dataGridContext.SetCurrent(
             dataGridContext.GetItemFromContainer( parentRow ),
-            parentRow, DataGridVirtualizingPanel.GetItemIndex( parentRow ),
-            this.ParentColumn, false, true, dataGridContext.DataGridControl.SynchronizeSelectionWithCurrent );
+            parentRow,
+            DataGridVirtualizingPanel.GetItemIndex( parentRow ),
+            this.ParentColumn,
+            false,
+            true,
+            dataGridContext.DataGridControl.SynchronizeSelectionWithCurrent,
+            AutoScrollCurrentItemSourceTriggers.Editing );
         }
 
-        if( ( !m_parentRow.IsBeingEdited ) && ( !m_parentRow.IsBeginningEdition ) )
-          m_parentRow.BeginEdit();
+        if( ( !parentRow.IsBeingEdited ) && ( !parentRow.IsBeginningEdition ) )
+        {
+          parentRow.BeginEdit();
+        }
 
         this.SetIsBeingEdited( true );
-        CellState cellState = this.GetEditCachedState();
+        var cellState = this.GetEditCachedState();
 
         if( cellState != null )
         {
           if( cellState.ContentBeforeCellEdition == DependencyProperty.UnsetValue )
+          {
             cellState.SetContentBeforeCellEdition( this.Content );
+          }
 
           cellState.SetIsDirtyBeforeEdition( this.IsDirty );
         }
@@ -3682,7 +3808,9 @@ namespace Xceed.Wpf.DataGrid
         this.OnEditBegun();
 
         if( parentRow.IsBeginningEditFromCell )
+        {
           parentRow.OnEditBegun();
+        }
       }
       finally
       {
@@ -3716,7 +3844,9 @@ namespace Xceed.Wpf.DataGrid
         // We delay the set focus on the cell to prevent the lost focus from being raised for the editor.
         // This is to prevent execution of some validation code that may be in the LostFocus of the editor.
         if( dataGridContext != null )
-          dataGridContext.DelayBringIntoViewAndFocusCurrent();
+        {
+          dataGridContext.DelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.Editing );
+        }
       }
 
       CellState cellState = this.GetEditCachedState();
@@ -3830,7 +3960,7 @@ namespace Xceed.Wpf.DataGrid
             {
               // We want to try to focus the Cell before we continue the EndEdit to ensure 
               // any validation or process in the lost focus is done
-              if( !dataGridContext.DataGridControl.SetFocusHelper( m_parentRow, m_parentColumn, false, false ) )
+              if( !dataGridContext.DataGridControl.SetFocusHelper( this.ParentRow, this.ParentColumn, false, false ) )
                 throw new DataGridFocusException( "Unable to set focus on the Cell." );
             }
           }
@@ -3941,7 +4071,11 @@ namespace Xceed.Wpf.DataGrid
         "We should never be calling ValidateAndSetAllErrors with a request to start cascade validation if we are currently cascading validation." );
 
       if( this.IsInCascadingValidation && cascadeValidate )
-        throw new DataGridInternalException();
+      {
+        throw new DataGridInternalException(
+              "We should never be calling ValidateAndSetAllErrors with a request to start cascade validation if we are currently cascading validation.",
+              DataGridControl.GetDataGridContext( this ).DataGridControl );
+      }
 
       ValidationResult result = ValidationResult.ValidResult;
       exception = null;
@@ -3962,8 +4096,9 @@ namespace Xceed.Wpf.DataGrid
 
       // Validate CellValidationRules against the cell's Content property.
       if( validateUIRules )
+      {
         result = this.ValidateCellRules( out exception, out ruleInError );
-
+      }
 
       if( result.IsValid )
       {
@@ -4230,21 +4365,27 @@ namespace Xceed.Wpf.DataGrid
 
     #region INotifyPropertyChanged Members
 
+    public event PropertyChangedEventHandler PropertyChanged;
+
     private void OnPropertyChanged( string propertyName )
     {
-      if( this.PropertyChanged != null )
-      {
-        this.PropertyChanged( this, new PropertyChangedEventArgs( propertyName ) );
-      }
-    }
+      var handler = this.PropertyChanged;
+      if( handler == null )
+        return;
 
-    public event PropertyChangedEventHandler PropertyChanged;
+      handler.Invoke( this, new PropertyChangedEventArgs( propertyName ) );
+    }
 
     #endregion
 
     #region IWeakEventListener Members
 
     bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      return this.OnReceivedWeakEvent( managerType, sender, e );
+    }
+
+    protected internal virtual bool OnReceivedWeakEvent( Type managerType, object sender, EventArgs e )
     {
       bool retval = false;
 
@@ -4272,7 +4413,16 @@ namespace Xceed.Wpf.DataGrid
 
         if( this.ProcessEvent( column, out retval ) )
         {
-          this.OnParentColumnCellContentTemplateChanged();
+          this.OnParentColumnCellContentTemplateChanged( false );
+        }
+      }
+      else if( managerType == typeof( CellContentStringFormatChangedEventManager ) )
+      {
+        ColumnBase column = sender as ColumnBase;
+
+        if( this.ProcessEvent( column, out retval ) )
+        {
+          this.OnParentColumnCellContentTemplateChanged( true );
         }
       }
       else if( managerType == typeof( ForeignKeyConfigurationChangedEventManager ) )
@@ -4290,12 +4440,9 @@ namespace Xceed.Wpf.DataGrid
 
     private bool ProcessEvent( ColumnBase column, out bool handled )
     {
-      handled = ( column != null )
-             && ( column.DataGridControl != null );
+      handled = ( column != null ) && ( column.DataGridControl != null );
 
-      return ( handled )
-          && ( this.IsContainerPrepared )
-          && ( !this.IsContainerVirtualized );
+      return ( handled ) && ( this.IsContainerPrepared ) && ( !this.IsContainerVirtualized );
     }
 
     private void OnParentColumnCanBeCurrentWhenReadOnlyChanged( ColumnBase column )
@@ -4307,7 +4454,7 @@ namespace Xceed.Wpf.DataGrid
       {
         try
         {
-          dataGridContext.SetCurrentColumnCore( null, false, dataGridControl.SynchronizeSelectionWithCurrent );
+          dataGridContext.SetCurrentColumnCore( null, false, dataGridControl.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CurrentColumnChanged );
         }
         catch( DataGridException )
         {
@@ -4346,7 +4493,7 @@ namespace Xceed.Wpf.DataGrid
       this.UpdateMatchingDisplayConditions();
     }
 
-    private void OnParentColumnCellContentTemplateChanged()
+    private void OnParentColumnCellContentTemplateChanged( bool ignoreTemplateConditions )
     {
       //If the editor is displayed, I want to take no actions for this event.
       if( ( this.CurrentEditorPendingDisplayState == EditorDisplayState.PendingShow ) || ( this.IsCellEditorDisplayed ) )
@@ -4354,7 +4501,8 @@ namespace Xceed.Wpf.DataGrid
 
       //If there is no local value for the ContentTemplate and ContentTemplateSelector properties, then it is possible that
       //the template to use changed.
-      if( ( this.ContentTemplateInternal == null ) && ( this.ContentTemplateSelectorInternal == null ) )
+      if( ignoreTemplateConditions
+        || ( ( this.ContentTemplateInternal == null ) && ( this.ContentTemplateSelectorInternal == null ) ) )
       {
         //force a re-evaluation of the CellContentTemplate.
         this.SetCoercedContentTemplate( this.GetCoercedCellContentTemplate(), null );
@@ -4374,8 +4522,7 @@ namespace Xceed.Wpf.DataGrid
     private KeyActivationGesture m_keyGesture; // = null
     private TextCompositionEventArgs m_textInputArgs; // = null
     private string m_fieldName; // = string.Empty
-    private ColumnBase m_parentColumn; // = null
-    private object m_styleBeforeError; // = null
+    private object m_styleBeforeError = DependencyProperty.UnsetValue;
 
     private RoutedEventHandler m_loadedRoutedEventHandler; // = null;
     private DispatcherOperation m_delayedRefreshErrorStyleDispatcherOperation; // = null
@@ -4386,11 +4533,15 @@ namespace Xceed.Wpf.DataGrid
     // Binding used by the animated Column reordering feature
     private static Binding ParentColumnTranslationBinding;
     private static Binding ParentColumnIsBeingDraggedBinding;
+    private static Binding ParentColumnReorderingDragSourceManagerBinding;
 
     private static Binding ParentRowCellContentOpacityBinding;
     private ContentPresenter m_cellContentPresenter;
 
     private int m_preventMakeVisibleCount; // = 0;
+    private bool m_readOnlyIsInternalySet;
+
+    #region CellFlags Private Type
 
     [Flags]
     private enum CellFlags
@@ -4416,6 +4567,10 @@ namespace Xceed.Wpf.DataGrid
       IsContainerRecycled = 262144
     }
 
+    #endregion
+
+    #region EditorDisplayState Private Type
+
     private enum EditorDisplayState
     {
       None = 0,
@@ -4423,6 +4578,10 @@ namespace Xceed.Wpf.DataGrid
       PendingHide
     }
 
+    #endregion
+
+    #region PreventMakeVisibleDisposable Private Class
+
     private class PreventMakeVisibleDisposable : IDisposable
     {
       public PreventMakeVisibleDisposable( Cell cell )
@@ -4435,10 +4594,6 @@ namespace Xceed.Wpf.DataGrid
         m_cell.m_preventMakeVisibleCount++;
       }
 
-      private Cell m_cell;
-
-      #region IDisposable Members
-
       public void Dispose()
       {
         if( m_cell == null )
@@ -4452,7 +4607,63 @@ namespace Xceed.Wpf.DataGrid
         m_cell = null;
       }
 
-      #endregion
+      private Cell m_cell;
     }
+
+    #endregion
+
+    #region EditorDataTemplate Private Class
+
+    private sealed class EditorDataTemplate : DataTemplate
+    {
+      private EditorDataTemplate( DataTemplate viewer, DataTemplate editor )
+      {
+        Debug.Assert( editor != null );
+
+        m_viewer = viewer;
+        m_editor = editor;
+      }
+
+      internal DataTemplate Viewer
+      {
+        get
+        {
+          return m_viewer;
+        }
+      }
+
+      internal DataTemplate Editor
+      {
+        get
+        {
+          return m_editor;
+        }
+      }
+
+      internal static EditorDataTemplate Create( DataTemplate viewer, DataTemplate editor )
+      {
+        var viewerContent = new FrameworkElementFactory( typeof( InnerCellContentPresenter ) );
+        viewerContent.SetValue( InnerCellContentPresenter.VisibilityProperty, Visibility.Hidden );
+        viewerContent.SetValue( InnerCellContentPresenter.ContentTemplateProperty, viewer );
+
+        var editorContent = new FrameworkElementFactory( typeof( InnerCellContentPresenter ) );
+        editorContent.SetValue( InnerCellContentPresenter.ContentTemplateProperty, editor );
+
+        var grid = new FrameworkElementFactory( typeof( Grid ) );
+        grid.AppendChild( viewerContent );
+        grid.AppendChild( editorContent );
+
+        var template = new EditorDataTemplate( viewer, editor );
+        template.VisualTree = grid;
+        template.Seal();
+
+        return template;
+      }
+
+      private readonly DataTemplate m_viewer;
+      private readonly DataTemplate m_editor;
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CellContentStringFormatChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CellContentStringFormatChangedEventManager.cs
new file mode 100644
index 00000000..c3414964
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CellContentStringFormatChangedEventManager.cs
@@ -0,0 +1,74 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class CellContentStringFormatChangedEventManager : WeakEventManager
+  {
+    private CellContentStringFormatChangedEventManager()
+    {
+    }
+
+    public static void AddListener( ColumnBase source, IWeakEventListener listener )
+    {
+      CellContentStringFormatChangedEventManager.CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( ColumnBase source, IWeakEventListener listener )
+    {
+      CellContentStringFormatChangedEventManager.CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var column = ( ColumnBase )source;
+
+      column.CellContentStringFormatChanged += new EventHandler( this.OnCellContentStringFormatChanged );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var column = ( ColumnBase )source;
+
+      column.CellContentStringFormatChanged -= new EventHandler( this.OnCellContentStringFormatChanged );
+    }
+
+    private static CellContentStringFormatChangedEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( CellContentStringFormatChangedEventManager );
+        var currentManager = ( CellContentStringFormatChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new CellContentStringFormatChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    private void OnCellContentStringFormatChanged( object sender, EventArgs args )
+    {
+      this.DeliverEvent( sender, args );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridCheckBox.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CheckBox.cs
similarity index 95%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridCheckBox.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CheckBox.cs
index d66814cd..135783f2 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridCheckBox.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CheckBox.cs
@@ -83,6 +83,8 @@ namespace Xceed.Wpf.DataGrid
     public override void OnApplyTemplate()
     {
       base.OnApplyTemplate();
+
+      ChildCheckBox.Background = new System.Windows.Media.SolidColorBrush( System.Windows.Media.Colors.Blue );
     }
 
     public static readonly RoutedEvent CheckedEvent;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ChildColumnVisibilityChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ChildColumnVisibilityChangedEventManager.cs
new file mode 100644
index 00000000..cbec599a
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ChildColumnVisibilityChangedEventManager.cs
@@ -0,0 +1,75 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class ChildColumnVisibilityChangedEventManager : WeakEventManager
+  {
+    private ChildColumnVisibilityChangedEventManager()
+    {
+    }
+
+    internal static void AddListener( ObservableColumnCollection source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    internal static void RemoveListener( ObservableColumnCollection source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var columnCollection = ( ObservableColumnCollection )source;
+      columnCollection.ColumnVisibilityChanged += new EventHandler( this.OnColumnVisibilityChanged );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var columnCollection = ( ObservableColumnCollection )source;
+      columnCollection.ColumnVisibilityChanged -= new EventHandler( this.OnColumnVisibilityChanged );
+    }
+
+    private static ChildColumnVisibilityChangedEventManager CurrentManager
+    {
+      get
+      {
+        Type managerType = typeof( ChildColumnVisibilityChangedEventManager );
+        ChildColumnVisibilityChangedEventManager currentManager = ( ChildColumnVisibilityChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ChildColumnVisibilityChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    private void OnColumnVisibilityChanged( object sender, EventArgs args )
+    {
+      this.DeliverEvent( sender, args );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.GenericContentTemplateSelectorResources.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.GenericContentTemplateSelectorResources.xaml
index 991b0bf2..7ced3878 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.GenericContentTemplateSelectorResources.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.GenericContentTemplateSelectorResources.xaml
@@ -20,9 +20,7 @@
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
-                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:s="clr-namespace:System;assembly=mscorlib"
-                    xmlns:sxml="clr-namespace:System.Xml;assembly=System.Xml">
+                    xmlns:s="clr-namespace:System;assembly=mscorlib">
 
    <conv:ImageConverter x:Key="imageConverter" />
    <conv:NullToBooleanConverter x:Key="nullToBooleanConverter" />
@@ -64,7 +62,10 @@
 
    </DataTemplate>
 
-   <DataTemplate x:Key="foreignKeyDistinctValueItemDefaultContentTemplate">
+   <DataTemplate x:Key="commonDefaultContentTemplate">
+
+      <TextBlock Text="{Binding Mode=OneWay}" />
+
    </DataTemplate>
 
 </ResourceDictionary>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.cs
index 477497cc..d6574901 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Column.cs
@@ -15,20 +15,11 @@
   ***********************************************************************************/
 
 using System;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
 using System.Collections;
 using System.ComponentModel;
-using System.Collections.ObjectModel;
 using System.Diagnostics;
-using System.Windows.Media;
-using Xceed.Wpf.DataGrid.ValidationRules;
-using System.Collections.Generic;
-using System.Windows.Controls.Primitives;
-using Xceed.Utils.Collections;
-using System.Collections.Specialized;
-using Xceed.Wpf.DataGrid.Converters;
+using System.Windows;
+using System.Windows.Data;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -42,13 +33,18 @@ namespace Xceed.Wpf.DataGrid
     [Obsolete( "The DisplayMemberBinding property is obsolete and has been replaced by the DisplayMemberBindingInfo property.", false )]
     public Column( string fieldName, object title, BindingBase displayMemberBinding )
       : base( fieldName, title )
+    {
+      this.SetDisplayMemberBinding( displayMemberBinding );
+    }
+
+    internal static Column Create( string fieldName, object title, BindingBase displayMemberBinding )
     {
       // Disable warning for DisplayMemberBinding when internaly used
 #pragma warning disable 618
-
-      this.DisplayMemberBinding = displayMemberBinding;
-
+      var column = new Column( fieldName, title, displayMemberBinding );
 #pragma warning restore 618
+
+      return column;
     }
 
     #region DisplayMemberBinding Property
@@ -67,14 +63,33 @@ namespace Xceed.Wpf.DataGrid
 
       set
       {
-        if( value != m_displayMemberBinding )
-        {
-          m_displayMemberBinding = value;
-          this.OnPropertyChanged( new PropertyChangedEventArgs( "DisplayMemberBinding" ) );
-        }
+        if( value == m_displayMemberBinding )
+          return;
+
+        m_displayMemberBinding = value;
+
+        this.OnPropertyChanged( new PropertyChangedEventArgs( "DisplayMemberBinding" ) );
       }
     }
 
+    internal BindingBase GetDisplayMemberBinding()
+    {
+      // Disable warning for DisplayMemberBinding when internaly used
+#pragma warning disable 618
+      var value = this.DisplayMemberBinding;
+#pragma warning restore 618
+
+      return value;
+    }
+
+    internal void SetDisplayMemberBinding( BindingBase value )
+    {
+      // Disable warning for DisplayMemberBinding when internaly used
+#pragma warning disable 618
+      this.DisplayMemberBinding = value;
+#pragma warning restore 618
+    }
+
     #endregion DisplayMemberBinding Property
 
     #region DisplayMemberBindingInfo Property
@@ -93,7 +108,6 @@ namespace Xceed.Wpf.DataGrid
         if( value != m_displayMemberBindingInfo )
         {
           m_displayMemberBindingInfo = value;
-
           m_displayMemberBinding = m_displayMemberBindingInfo.GetBinding();
 
           this.OnPropertyChanged( new PropertyChangedEventArgs( "DisplayMemberBindingInfo" ) );
@@ -195,7 +209,9 @@ namespace Xceed.Wpf.DataGrid
       "ForeignKeyConfiguration",
       typeof( ForeignKeyConfiguration ),
       typeof( Column ),
-      new FrameworkPropertyMetadata( null, new PropertyChangedCallback( Column.OnForeignKeyConfigurationChanged ) ) );
+      new FrameworkPropertyMetadata(
+        null,
+        new PropertyChangedCallback( Column.OnForeignKeyConfigurationChanged ) ) );
 
     public ForeignKeyConfiguration ForeignKeyConfiguration
     {
@@ -228,10 +244,10 @@ namespace Xceed.Wpf.DataGrid
     private void RaiseForeignKeyConfigurationChanged()
     {
       var handler = this.ForeignKeyConfigurationChanged;
-      if( handler != null )
-      {
-        handler( this, EventArgs.Empty );
-      }
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, EventArgs.Empty );
     }
 
     #endregion
@@ -242,24 +258,38 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_bindingAutoCreated;
+        return m_isBindingAutoCreated;
       }
       set
       {
-        m_bindingAutoCreated = value;
+        m_isBindingAutoCreated = value;
       }
     }
 
+    private bool m_isBindingAutoCreated; //false
+
     #endregion
 
     #region IsBoundToDataGridUnboundItemProperty Property
 
     internal bool IsBoundToDataGridUnboundItemProperty
     {
-      get;
-      set;
+      get
+      {
+        return m_isBoundToDataGridUnboundItemProperty;
+      }
+      set
+      {
+        if( value == m_isBoundToDataGridUnboundItemProperty )
+          return;
+
+        m_isBoundToDataGridUnboundItemProperty = value;
+        this.ResetDefaultCellRecyclingGroup();
+      }
     }
 
+    private bool m_isBoundToDataGridUnboundItemProperty; //false
+
     #endregion
 
 #if DEBUG
@@ -274,6 +304,48 @@ namespace Xceed.Wpf.DataGrid
     }
 #endif
 
-    private bool m_bindingAutoCreated; // = false
+    internal override object CreateDefaultCellRecyclingGroup()
+    {
+      var key = base.CreateDefaultCellRecyclingGroup();
+
+      if( !this.IsBoundToDataGridUnboundItemProperty )
+        return key;
+
+      return new UnboundColumnCellRecyclingGroupKey( key );
+    }
+
+    #region UnboundColumnCellRecyclingGroupKey Private Nested Type
+
+    private sealed class UnboundColumnCellRecyclingGroupKey
+    {
+      internal UnboundColumnCellRecyclingGroupKey( object key )
+      {
+        m_key = key;
+      }
+
+      public override int GetHashCode()
+      {
+        if( m_key != null )
+          return m_key.GetHashCode();
+
+        return 0;
+      }
+
+      public override bool Equals( object obj )
+      {
+        UnboundColumnCellRecyclingGroupKey key = obj as UnboundColumnCellRecyclingGroupKey;
+        if( key == null )
+          return false;
+
+        if( key == this )
+          return true;
+
+        return object.Equals( key.m_key, m_key );
+      }
+
+      private readonly object m_key;
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnAddGroupCommand.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnAddGroupCommand.cs
new file mode 100644
index 00000000..9b4660e5
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnAddGroupCommand.cs
@@ -0,0 +1,116 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class ColumnAddGroupCommand : ColumnGroupCommand
+  {
+    #region GroupDescriptions Protected Property
+
+    protected abstract ObservableCollection<GroupDescription> GroupDescriptions
+    {
+      get;
+    }
+
+    #endregion
+
+    public bool CanExecute( ColumnBase column )
+    {
+      return this.CanExecute( column, -1 );
+    }
+
+    public bool CanExecute( ColumnBase column, int index )
+    {
+      return ( column != null )
+          && ( this.CanExecuteCore( column, index ) );
+    }
+
+    public void Execute( ColumnBase column )
+    {
+      this.Execute( column, -1 );
+    }
+
+    public void Execute( ColumnBase column, int index )
+    {
+      if( !this.CanExecute( column, index ) )
+        return;
+
+      this.ExecuteCore( column, index );
+    }
+
+    protected virtual string GetColumnName( ColumnBase column )
+    {
+      return column.FieldName;
+    }
+
+    protected virtual GroupDescription GetGroupDescription( ColumnBase column )
+    {
+      return column.GroupDescription;
+    }
+
+    protected virtual GroupConfiguration GetGroupConfiguration( ColumnBase column )
+    {
+      return column.GroupConfiguration;
+    }
+
+    protected virtual bool CanExecuteCore( ColumnBase column, int index )
+    {
+      return ( this.GroupDescriptions != null )
+          && ( !string.IsNullOrEmpty( this.GetColumnName( column ) ) );
+    }
+
+    protected virtual void ExecuteCore( ColumnBase column, int index )
+    {
+      var groupDescriptions = this.GroupDescriptions;
+      if( groupDescriptions == null )
+        return;
+
+      GroupDescription groupDescription = this.GetGroupDescription( column );
+      if( groupDescription == null )
+      {
+        groupDescription = new DataGridGroupDescription( this.GetColumnName( column ) );
+      }
+
+      var dataGridGroupDescription = groupDescription as DataGridGroupDescription;
+      if( ( dataGridGroupDescription != null ) && ( dataGridGroupDescription.GroupConfiguration == null ) )
+      {
+        dataGridGroupDescription.GroupConfiguration = this.GetGroupConfiguration( column );
+      }
+
+      if( index < 0 )
+      {
+        groupDescriptions.Add( groupDescription );
+      }
+      else
+      {
+        groupDescriptions.Insert( index, groupDescription );
+      }
+    }
+
+    protected sealed override bool CanExecuteImpl( object parameter )
+    {
+      return this.CanExecute( parameter as ColumnBase );
+    }
+
+    protected sealed override void ExecuteImpl( object parameter )
+    {
+      this.Execute( parameter as ColumnBase );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnBase.cs
index f7d76a08..b230fc38 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnBase.cs
@@ -15,25 +15,23 @@
   ***********************************************************************************/
 
 using System;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
 using System.Collections;
-using System.ComponentModel;
 using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Diagnostics;
-using System.Windows.Media;
-using Xceed.Wpf.DataGrid.ValidationRules;
-using System.Collections.Generic;
-using System.Windows.Controls.Primitives;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
 using Xceed.Utils.Collections;
-using System.Collections.Specialized;
-using Xceed.Wpf.DataGrid.Converters;
+using Xceed.Wpf.DataGrid.ValidationRules;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
   [DebuggerDisplay( "FieldName = {FieldName}" )]
-  public abstract class ColumnBase : Freezable, INotifyPropertyChanged
+  public abstract class ColumnBase : Freezable, INotifyPropertyChanged, IWeakEventListener
   {
     static ColumnBase()
     {
@@ -68,7 +66,7 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_cellContentTemplate;
+        return ( DataTemplate )this.GetValue( ColumnBase.CellContentTemplateProperty );
       }
       set
       {
@@ -76,8 +74,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private DataTemplate m_cellContentTemplate;
-
     #endregion CellContentTemplate Property
 
     #region CellContentTemplateSelector Property
@@ -87,14 +83,15 @@ namespace Xceed.Wpf.DataGrid
         "CellContentTemplateSelector",
         typeof( DataTemplateSelector ),
         typeof( ColumnBase ),
-        new FrameworkPropertyMetadata( GenericContentTemplateSelector.Instance,
+        new FrameworkPropertyMetadata(
+          GenericContentTemplateSelector.Instance,
           new PropertyChangedCallback( ColumnBase.OnCellContentTemplateSelectorChanged ) ) );
 
     public DataTemplateSelector CellContentTemplateSelector
     {
       get
       {
-        return m_cellContentTemplateSelector;
+        return ( DataTemplateSelector )this.GetValue( ColumnBase.CellContentTemplateSelectorProperty );
       }
       set
       {
@@ -102,8 +99,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private DataTemplateSelector m_cellContentTemplateSelector = GenericContentTemplateSelector.Instance;
-
     #endregion CellContentTemplateSelector Property
 
     #region CellHorizontalContentAlignment Property
@@ -150,29 +145,46 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion CellVerticalContentAlignment
 
+    #region CellContentStringFormat Property
+
+    //StringFormat to use when in ViewMode (not editing)
+    public static readonly DependencyProperty CellContentStringFormatProperty =
+        DependencyProperty.Register( "CellContentStringFormat",
+        typeof( string ),
+        typeof( ColumnBase ),
+        new FrameworkPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnCellContentStringFormatChanged ) ) );
+
+    public string CellContentStringFormat
+    {
+      get
+      {
+        return ( string )this.GetValue( ColumnBase.CellContentStringFormatProperty );
+      }
+      set
+      {
+        this.SetValue( ColumnBase.CellContentStringFormatProperty, value );
+      }
+    }
+
+    internal event EventHandler CellContentStringFormatChanged;
+
+    #endregion CellContentStringFormat Property
+
     #region Title Property
 
     public static readonly DependencyProperty TitleProperty = DependencyProperty.Register(
       "Title",
       typeof( object ),
       typeof( ColumnBase ),
-      new UIPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnTitleChanged ) ) );
-
-    private static void OnTitleChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = ( ColumnBase )sender;
-
-      column.m_title = e.NewValue;
-
-      if( column.TitleChanged != null )
-        column.TitleChanged( column, EventArgs.Empty );
-    }
+      new UIPropertyMetadata(
+        null,
+        new PropertyChangedCallback( ColumnBase.OnTitleChanged ) ) );
 
     public object Title
     {
       get
       {
-        return m_title;
+        return this.GetValue( ColumnBase.TitleProperty );
       }
       set
       {
@@ -180,33 +192,34 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private static void OnTitleChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var column = ( ColumnBase )sender;
+      var handler = column.TitleChanged;
+
+      if( handler != null )
+      {
+        handler.Invoke( column, EventArgs.Empty );
+      }
+    }
+
     internal event EventHandler TitleChanged;
-    private object m_title;
 
     #endregion Title Property
 
     #region TitleTemplate Property
 
-    public static readonly DependencyProperty TitleTemplateProperty =
-        DependencyProperty.Register( "TitleTemplate", typeof( DataTemplate ), typeof( ColumnBase ), new UIPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnTitleTemplateChanged ) ) );
-
-    private DataTemplate m_titleTemplate;
-
-    private static void OnTitleTemplateChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_titleTemplate = e.NewValue as DataTemplate;
-    }
+    public static readonly DependencyProperty TitleTemplateProperty = DependencyProperty.Register(
+      "TitleTemplate",
+      typeof( DataTemplate ),
+      typeof( ColumnBase ),
+      new UIPropertyMetadata( null ) );
 
     public DataTemplate TitleTemplate
     {
       get
       {
-        return m_titleTemplate;
+        return ( DataTemplate )this.GetValue( ColumnBase.TitleTemplateProperty );
       }
       set
       {
@@ -218,26 +231,17 @@ namespace Xceed.Wpf.DataGrid
 
     #region TitleTemplateSelector Property
 
-    public static readonly DependencyProperty TitleTemplateSelectorProperty =
-        DependencyProperty.Register( "TitleTemplateSelector", typeof( DataTemplateSelector ), typeof( ColumnBase ), new UIPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnTitleTemplateSelectorChanged ) ) );
-
-    private DataTemplateSelector m_titleTemplateSelector;
-
-    private static void OnTitleTemplateSelectorChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_titleTemplateSelector = e.NewValue as DataTemplateSelector;
-    }
+    public static readonly DependencyProperty TitleTemplateSelectorProperty = DependencyProperty.Register(
+      "TitleTemplateSelector",
+      typeof( DataTemplateSelector ),
+      typeof( ColumnBase ),
+      new UIPropertyMetadata( null ) );
 
     public DataTemplateSelector TitleTemplateSelector
     {
       get
       {
-        return m_titleTemplateSelector;
+        return ( DataTemplateSelector )this.GetValue( ColumnBase.TitleTemplateSelectorProperty );
       }
       set
       {
@@ -249,33 +253,42 @@ namespace Xceed.Wpf.DataGrid
 
     #region ActualWidth Property
 
-    private static readonly DependencyPropertyKey ActualWidthPropertyKey =
-      DependencyProperty.RegisterReadOnly( "ActualWidth", typeof( double ), typeof( ColumnBase ), new PropertyMetadata( ColumnBase.OnActualWidthChanged ) );
+    private static readonly DependencyPropertyKey ActualWidthPropertyKey = DependencyProperty.RegisterReadOnly(
+      "ActualWidth",
+      typeof( double ),
+      typeof( ColumnBase ),
+      new PropertyMetadata( ColumnBase.OnActualWidthChanged ) );
 
     public static readonly DependencyProperty ActualWidthProperty = ColumnBase.ActualWidthPropertyKey.DependencyProperty;
 
-    private static void OnActualWidthChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    public double ActualWidth
     {
-      ColumnBase column = o as ColumnBase;
+      get
+      {
+        return ( double )this.GetValue( ColumnBase.ActualWidthProperty );
+      }
+    }
 
+    private static void OnActualWidthChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    {
+      var column = o as ColumnBase;
       if( column == null )
         return;
 
-      if( column.ActualWidthChanged != null )
+      var handler = column.ActualWidthChanged;
+      if( handler != null )
       {
-        Debug.Assert( e.NewValue != null );
-        Debug.Assert( e.OldValue != null );
-        column.m_actualWidth = ( double )e.NewValue;
-        column.ActualWidthChanged( column, new ColumnActualWidthChangedEventArgs( column, ( double )e.OldValue, ( double )e.NewValue ) );
+        handler.Invoke( column, new ColumnActualWidthChangedEventArgs( column, ( double )e.OldValue, ( double )e.NewValue ) );
       }
     }
 
     private void UpdateActualWidth()
     {
-      double actualWidth = ( ( this.Width.UnitType == ColumnWidthUnitType.Pixel ) ? this.Width.Value : ( ( ColumnWidth )WidthProperty.DefaultMetadata.DefaultValue ).Value );
-      double maxWidth = this.MaxWidth;
-      double minWidth = this.MinWidth;
-      bool useDesiredWidth = false;
+      var width = this.Width;
+      var actualWidth = ( ( width.UnitType == ColumnWidthUnitType.Pixel ) ? width.Value : ( ( ColumnWidth )ColumnBase.WidthProperty.DefaultMetadata.DefaultValue ).Value );
+      var maxWidth = this.MaxWidth;
+      var minWidth = this.MinWidth;
+      var useDesiredWidth = false;
 
       if( this.DesiredWidth >= 0d )
       {
@@ -284,19 +297,22 @@ namespace Xceed.Wpf.DataGrid
       }
 
       if( actualWidth > maxWidth )
+      {
         actualWidth = maxWidth;
+      }
 
       // If Width is set to a value lesser than MinWidth or, if MaxWidth is inferior to
       // MinWidth, ActualWidth will become equal to MinWidth.
       if( actualWidth < minWidth )
+      {
         actualWidth = minWidth;
+      }
 
       this.SetValue( ColumnBase.ActualWidthPropertyKey, actualWidth );
-      m_actualWidth = actualWidth;
 
       if( ( minWidth >= maxWidth ) || ( useDesiredWidth ) )
       {
-        this.SetHasFixedWidth( true );
+        this.HasFixedWidth = true;
       }
       else
       {
@@ -304,16 +320,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public double ActualWidth
-    {
-      get
-      {
-        return m_actualWidth;
-      }
-    }
-
-    private double m_actualWidth;
-
     #endregion ActualWidth Property
 
     #region Width Property
@@ -338,12 +344,12 @@ namespace Xceed.Wpf.DataGrid
 
     private static void WidthChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      ColumnBase column = ( ColumnBase )sender;
+      var column = ( ColumnBase )sender;
 
       if( e.Property == ColumnBase.WidthProperty )
       {
-        ColumnWidth oldValue = ( ColumnWidth )e.OldValue;
-        ColumnWidth newValue = ( ColumnWidth )e.NewValue;
+        var oldValue = ( ColumnWidth )e.OldValue;
+        var newValue = ( ColumnWidth )e.NewValue;
 
         if( ( oldValue.UnitType == ColumnWidthUnitType.Star ) &&
             ( newValue.UnitType == ColumnWidthUnitType.Pixel ) )
@@ -358,7 +364,7 @@ namespace Xceed.Wpf.DataGrid
           // to force a new Measure pass. Mandatory, for instance, when the old star
           // value was limited by a MaxValue and the new star value would give a 
           // smaller value to DesiredWidth.
-          double oldActualWidth = column.ActualWidth;
+          var oldActualWidth = column.ActualWidth;
 
           if( column.ActualWidth > column.MinWidth )
           {
@@ -439,26 +445,13 @@ namespace Xceed.Wpf.DataGrid
       "TextTrimming",
       typeof( TextTrimming ),
       typeof( ColumnBase ),
-      new UIPropertyMetadata( TextTrimming.CharacterEllipsis, new PropertyChangedCallback( ColumnBase.OnTextTrimmingPropertyChanged ) ) );
-
-    private TextTrimming m_textTrimming = TextTrimming.CharacterEllipsis;
-
-    private static void OnTextTrimmingPropertyChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      if( e.NewValue != null )
-        column.m_textTrimming = ( TextTrimming )e.NewValue;
-    }
+      new UIPropertyMetadata( TextTrimming.CharacterEllipsis ) );
 
     public TextTrimming TextTrimming
     {
       get
       {
-        return m_textTrimming;
+        return ( TextTrimming )this.GetValue( ColumnBase.TextTrimmingProperty );
       }
       set
       {
@@ -474,26 +467,13 @@ namespace Xceed.Wpf.DataGrid
       "TextWrapping",
       typeof( TextWrapping ),
       typeof( ColumnBase ),
-      new UIPropertyMetadata( TextWrapping.NoWrap, new PropertyChangedCallback( ColumnBase.OnTextWrappingChanged ) ) );
-
-    private TextWrapping m_textWrapping = TextWrapping.NoWrap;
-
-    private static void OnTextWrappingChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      if( e.NewValue != null )
-        column.m_textWrapping = ( TextWrapping )e.NewValue;
-    }
+      new UIPropertyMetadata( TextWrapping.NoWrap ) );
 
     public TextWrapping TextWrapping
     {
       get
       {
-        return m_textWrapping;
+        return ( TextWrapping )this.GetValue( ColumnBase.TextWrappingProperty );
       }
       set
       {
@@ -505,35 +485,24 @@ namespace Xceed.Wpf.DataGrid
 
     #region HasFixedWidth Read-Only Property
 
-    private static readonly DependencyPropertyKey HasFixedWidthPropertyKey =
-      DependencyProperty.RegisterReadOnly( "HasFixedWidth", typeof( bool ), typeof( ColumnBase ), new PropertyMetadata( false, new PropertyChangedCallback( ColumnBase.OnHasFixedWidthChanged ) ) );
-
-    public static readonly DependencyProperty HasFixedWidthProperty =
-      ColumnBase.HasFixedWidthPropertyKey.DependencyProperty;
-
-    private bool m_hasFixedWidth = false;
-
-    private static void OnHasFixedWidthChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
+    private static readonly DependencyPropertyKey HasFixedWidthPropertyKey = DependencyProperty.RegisterReadOnly(
+      "HasFixedWidth",
+      typeof( bool ),
+      typeof( ColumnBase ),
+      new PropertyMetadata( false ) );
 
-      column.m_hasFixedWidth = ( bool )e.NewValue;
-    }
+    public static readonly DependencyProperty HasFixedWidthProperty = ColumnBase.HasFixedWidthPropertyKey.DependencyProperty;
 
     public bool HasFixedWidth
     {
       get
       {
-        return m_hasFixedWidth;
+        return ( bool )this.GetValue( ColumnBase.HasFixedWidthProperty );
+      }
+      private set
+      {
+        this.SetValue( ColumnBase.HasFixedWidthPropertyKey, value );
       }
-    }
-
-    private void SetHasFixedWidth( bool value )
-    {
-      this.SetValue( ColumnBase.HasFixedWidthPropertyKey, value );
     }
 
     #endregion HasFixedWidth Read-Only Property
@@ -545,16 +514,13 @@ namespace Xceed.Wpf.DataGrid
       "VisiblePosition",
       typeof( int ),
       typeof( ColumnBase ),
-      new UIPropertyMetadata(
-        int.MaxValue,
-        new PropertyChangedCallback( ColumnBase.OnVisibilePositionChanged ),
-        new CoerceValueCallback( ColumnBase.OnCoerceVisiblePosition ) ) );
+      new UIPropertyMetadata( int.MaxValue, new PropertyChangedCallback( ColumnBase.OnVisiblePositionChanged ), new CoerceValueCallback( ColumnBase.OnCoerceVisiblePosition ) ) );
 
     public int VisiblePosition
     {
       get
       {
-        return m_visiblePosition;
+        return ( int )this.GetValue( ColumnBase.VisiblePositionProperty );
       }
       set
       {
@@ -565,20 +531,41 @@ namespace Xceed.Wpf.DataGrid
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly" )]
     private static object OnCoerceVisiblePosition( DependencyObject sender, object value )
     {
-      if( ( int )value < 0 )
+      var newValue = ( int )value;
+      if( newValue < 0 )
         throw new ArgumentOutOfRangeException( "VisiblePosition", "VisiblePosition must be greater than or equal to zero." );
 
+      var column = ( ColumnBase )sender;
+
+      if( !column.m_inhibitVisiblePositionChanging.IsSet )
+      {
+        var oldValue = column.VisiblePosition;
+
+        if( newValue != oldValue )
+        {
+          var handler = column.VisiblePositionChanging;
+          if( handler != null )
+          {
+            handler.Invoke( sender, EventArgs.Empty );
+          }
+        }
+      }
+
       return value;
     }
 
-    private static void OnVisibilePositionChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    private static void OnVisiblePositionChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
       ColumnBase column = ( ColumnBase )sender;
 
-      column.m_visiblePosition = ( int )e.NewValue;
+      int oldValue = ( int )e.OldValue;
+      int newValue = ( int )e.NewValue;
 
-      if( column.VisiblePositionChanged != null )
-        column.VisiblePositionChanged( column, new ColumnVisiblePositionChangedEventArgs( column, ( int )e.OldValue, ( int )e.NewValue ) );
+      var handler = column.VisiblePositionChanged;
+      if( handler != null )
+      {
+        handler.Invoke( column, new ColumnVisiblePositionChangedEventArgs( column, oldValue, newValue ) );
+      }
 
       // Invalidate own PreviousVisibleColumnProperty
       column.InvalidatePreviousVisibleColumnProperty();
@@ -592,35 +579,33 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    internal IDisposable InhibitVisiblePositionChanging()
+    {
+      return m_inhibitVisiblePositionChanging.Set();
+    }
+
+    internal event EventHandler VisiblePositionChanging;
     internal event EventHandler VisiblePositionChanged;
-    private int m_visiblePosition = Int32.MaxValue;
+
+    private readonly AutoResetFlag m_inhibitVisiblePositionChanging = AutoResetFlagFactory.Create( false );
 
     #endregion VisiblePosition Property
 
     #region IsFirstVisible Read-Only Property
 
-    private static readonly DependencyPropertyKey IsFirstVisiblePropertyKey =
-        DependencyProperty.RegisterReadOnly( "IsFirstVisible", typeof( bool ), typeof( ColumnBase ), new PropertyMetadata( false, new PropertyChangedCallback( ColumnBase.OnIsFirstVisibleChanged ) ) );
+    private static readonly DependencyPropertyKey IsFirstVisiblePropertyKey = DependencyProperty.RegisterReadOnly(
+      "IsFirstVisible",
+      typeof( bool ),
+      typeof( ColumnBase ),
+      new PropertyMetadata( false ) );
 
     public static readonly DependencyProperty IsFirstVisibleProperty;
 
-    private bool m_isFirstVisible; // = false;
-
-    private static void OnIsFirstVisibleChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_isFirstVisible = ( bool )e.NewValue;
-    }
-
     public bool IsFirstVisible
     {
       get
       {
-        return m_isFirstVisible;
+        return ( bool )this.GetValue( ColumnBase.IsFirstVisibleProperty );
       }
     }
 
@@ -632,35 +617,25 @@ namespace Xceed.Wpf.DataGrid
     internal void ClearIsFirstVisible()
     {
       this.ClearValue( ColumnBase.IsFirstVisiblePropertyKey );
-      m_isFirstVisible = false;
     }
 
     #endregion IsFirstVisible Read-Only Property
 
     #region IsLastVisible Read-Only Property
 
-    private static readonly DependencyPropertyKey IsLastVisiblePropertyKey =
-        DependencyProperty.RegisterReadOnly( "IsLastVisible", typeof( bool ), typeof( ColumnBase ), new PropertyMetadata( false, new PropertyChangedCallback( ColumnBase.OnIsLastVisibleChanged ) ) );
+    private static readonly DependencyPropertyKey IsLastVisiblePropertyKey = DependencyProperty.RegisterReadOnly(
+      "IsLastVisible",
+      typeof( bool ),
+      typeof( ColumnBase ),
+      new PropertyMetadata( false ) );
 
     public static readonly DependencyProperty IsLastVisibleProperty;
 
-    private bool m_isLastVisible; // = false;
-
-    private static void OnIsLastVisibleChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_isLastVisible = ( bool )e.NewValue;
-    }
-
     public bool IsLastVisible
     {
       get
       {
-        return m_isLastVisible;
+        return ( bool )this.GetValue( ColumnBase.IsLastVisibleProperty );
       }
     }
 
@@ -678,36 +653,20 @@ namespace Xceed.Wpf.DataGrid
 
     #region FieldName Property
 
-    public static readonly DependencyProperty FieldNameProperty =
-        DependencyProperty.Register( "FieldName", typeof( string ), typeof( ColumnBase ), new UIPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnFieldNameChanged ), new CoerceValueCallback( ColumnBase.OnCoerceFieldName ) ) );
-
-    private string m_fieldName; // = null;
-
-    private static void OnFieldNameChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_fieldName = ( string )e.NewValue;
-    }
-
-    private static object OnCoerceFieldName( DependencyObject sender, object requestedValue )
-    {
-      ColumnBase column = sender as ColumnBase;
-
-      if( ( column.m_containingCollection != null ) && ( !DesignerProperties.GetIsInDesignMode( column ) ) )
-        throw new InvalidOperationException( "An attempt was made to change the FieldName of a column that is contained in a grid." );
-
-      return requestedValue;
-    }
+    public static readonly DependencyProperty FieldNameProperty = DependencyProperty.Register(
+      "FieldName",
+      typeof( string ),
+      typeof( ColumnBase ),
+      new UIPropertyMetadata(
+        null,
+        null,
+        new CoerceValueCallback( ColumnBase.OnCoerceFieldName ) ) );
 
     public string FieldName
     {
       get
       {
-        return m_fieldName;
+        return ( string )this.GetValue( ColumnBase.FieldNameProperty );
       }
       set
       {
@@ -715,6 +674,15 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private static object OnCoerceFieldName( DependencyObject sender, object requestedValue )
+    {
+      var column = sender as ColumnBase;
+      if( ( column.m_containingCollection != null ) && ( !DesignerProperties.GetIsInDesignMode( column ) ) )
+        throw new InvalidOperationException( "An attempt was made to change the FieldName of a column that is contained in a grid." );
+
+      return requestedValue;
+    }
+
     #endregion FieldName Property
 
     #region Visible Property
@@ -723,13 +691,13 @@ namespace Xceed.Wpf.DataGrid
       "Visible",
       typeof( bool ),
       typeof( ColumnBase ),
-      new UIPropertyMetadata( true, new PropertyChangedCallback( ColumnBase.OnVisiblePropertyChanged ) ) );
+      new UIPropertyMetadata( true, new PropertyChangedCallback( ColumnBase.OnVisibilityChanged ) ) );
 
     public bool Visible
     {
       get
       {
-        return m_visible;
+        return ( bool )this.GetValue( ColumnBase.VisibleProperty );
       }
       set
       {
@@ -737,18 +705,18 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private static void OnVisiblePropertyChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    private static void OnVisibilityChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      ColumnBase column = ( ColumnBase )sender;
-
-      column.m_visible = ( bool )e.NewValue;
+      var column = ( ColumnBase )sender;
 
-      if( column.VisibleChanged != null )
-        column.VisibleChanged( column, EventArgs.Empty );
+      var handler = column.VisibleChanged;
+      if( handler != null )
+      {
+        handler.Invoke( column, EventArgs.Empty );
+      }
     }
 
     internal event EventHandler VisibleChanged;
-    private bool m_visible = true;
 
     #endregion Visible Property
 
@@ -848,26 +816,17 @@ namespace Xceed.Wpf.DataGrid
 
     #region GroupValueTemplate Property
 
-    public static readonly DependencyProperty GroupValueTemplateProperty =
-        DependencyProperty.Register( "GroupValueTemplate", typeof( DataTemplate ), typeof( ColumnBase ), new FrameworkPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnGroupValueTemplateChanged ) ) );
-
-    private DataTemplate m_groupValueTemplate;
-
-    private static void OnGroupValueTemplateChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_groupValueTemplate = e.NewValue as DataTemplate;
-    }
+    public static readonly DependencyProperty GroupValueTemplateProperty = DependencyProperty.Register(
+      "GroupValueTemplate",
+      typeof( DataTemplate ),
+      typeof( ColumnBase ),
+      new FrameworkPropertyMetadata( null ) );
 
     public DataTemplate GroupValueTemplate
     {
       get
       {
-        return m_groupValueTemplate;
+        return ( DataTemplate )this.GetValue( ColumnBase.GroupValueTemplateProperty );
       }
       set
       {
@@ -879,38 +838,47 @@ namespace Xceed.Wpf.DataGrid
 
     #region GroupValueTemplateSelector Property
 
-    public static readonly DependencyProperty GroupValueTemplateSelectorProperty =
-        DependencyProperty.Register( "GroupValueTemplateSelector",
-        typeof( DataTemplateSelector ),
-        typeof( ColumnBase ),
-        new FrameworkPropertyMetadata( null,
-          new PropertyChangedCallback( ColumnBase.OnGroupValueTemplateSelectorChanged ) ) );
-
-    private DataTemplateSelector m_groupValueTemplateSelector; // = null;
+    public static readonly DependencyProperty GroupValueTemplateSelectorProperty = DependencyProperty.Register(
+      "GroupValueTemplateSelector",
+      typeof( DataTemplateSelector ),
+      typeof( ColumnBase ),
+      new FrameworkPropertyMetadata( null ) );
 
-    private static void OnGroupValueTemplateSelectorChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    public DataTemplateSelector GroupValueTemplateSelector
     {
-      ColumnBase column = o as ColumnBase;
+      get
+      {
+        return ( DataTemplateSelector )this.GetValue( ColumnBase.GroupValueTemplateSelectorProperty );
+      }
+      set
+      {
+        this.SetValue( ColumnBase.GroupValueTemplateSelectorProperty, value );
+      }
+    }
 
-      if( column == null )
-        return;
+    #endregion GroupValueTemplateSelector Property
 
-      column.m_groupValueTemplateSelector = e.NewValue as DataTemplateSelector;
-    }
+    #region GroupValueStringFormat Property
 
-    public DataTemplateSelector GroupValueTemplateSelector
+    public static readonly DependencyProperty GroupValueStringFormatProperty = DependencyProperty.Register(
+      "GroupValueStringFormat",
+      typeof( string ),
+      typeof( ColumnBase ),
+      new FrameworkPropertyMetadata( null ) );
+
+    public string GroupValueStringFormat
     {
       get
       {
-        return m_groupValueTemplateSelector;
+        return ( string )this.GetValue( ColumnBase.GroupValueStringFormatProperty );
       }
       set
       {
-        this.SetValue( ColumnBase.GroupValueTemplateSelectorProperty, value );
+        this.SetValue( ColumnBase.GroupValueStringFormatProperty, value );
       }
     }
 
-    #endregion GroupValueTemplateSelector Property
+    #endregion GroupValueStringFormat Property
 
     #region CellEditor Property
 
@@ -918,25 +886,13 @@ namespace Xceed.Wpf.DataGrid
       "CellEditor",
       typeof( CellEditor ),
       typeof( ColumnBase ),
-      new UIPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnCellEditorChanged ) ) );
-
-    private CellEditor m_cellEditor = null;
-
-    private static void OnCellEditorChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_cellEditor = e.NewValue as CellEditor;
-    }
+      new UIPropertyMetadata( null ) );
 
     public CellEditor CellEditor
     {
       get
       {
-        return m_cellEditor;
+        return ( CellEditor )this.GetValue( ColumnBase.CellEditorProperty );
       }
       set
       {
@@ -979,7 +935,7 @@ namespace Xceed.Wpf.DataGrid
 
       if( column.CellEditorDisplayConditionsChanged != null )
       {
-        column.CellEditorDisplayConditionsChanged( column, new EventArgs() );
+        column.CellEditorDisplayConditionsChanged( column, EventArgs.Empty );
       }
     }
 
@@ -1037,14 +993,13 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_canBeCurrentWhenReadOnly;
+        return ( bool )this.GetValue( ColumnBase.CanBeCurrentWhenReadOnlyProperty );
       }
       set
       {
         this.SetValue( ColumnBase.CanBeCurrentWhenReadOnlyProperty, value );
       }
     }
-    private bool m_canBeCurrentWhenReadOnly = true;
 
     private static void OnCanBeCurrentWhenReadOnlyChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
@@ -1053,11 +1008,9 @@ namespace Xceed.Wpf.DataGrid
       if( column == null )
         return;
 
-      column.m_canBeCurrentWhenReadOnly = ( bool )e.NewValue;
-
       if( column.CanBeCurrentWhenReadOnlyChanged != null )
       {
-        column.CanBeCurrentWhenReadOnlyChanged( sender, new EventArgs() );
+        column.CanBeCurrentWhenReadOnlyChanged( sender, EventArgs.Empty );
       }
     }
 
@@ -1065,30 +1018,19 @@ namespace Xceed.Wpf.DataGrid
 
     #region HasValidationError Property
 
-    private static readonly DependencyPropertyKey HasValidationErrorPropertyKey =
-        DependencyProperty.RegisterReadOnly( "HasValidationError", typeof( bool ), typeof( ColumnBase ), new UIPropertyMetadata( false, new PropertyChangedCallback( ColumnBase.OnHasValidationErrorChanged ) ) );
-
-    public static readonly DependencyProperty HasValidationErrorProperty =
-      HasValidationErrorPropertyKey.DependencyProperty;
-
-    private bool m_hasValidationError;
-
-    private static void OnHasValidationErrorChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
+    private static readonly DependencyPropertyKey HasValidationErrorPropertyKey = DependencyProperty.RegisterReadOnly(
+      "HasValidationError",
+      typeof( bool ),
+      typeof( ColumnBase ),
+      new UIPropertyMetadata( false ) );
 
-      if( e.NewValue != null )
-        column.m_hasValidationError = ( bool )e.NewValue;
-    }
+    public static readonly DependencyProperty HasValidationErrorProperty = ColumnBase.HasValidationErrorPropertyKey.DependencyProperty;
 
     public bool HasValidationError
     {
       get
       {
-        return m_hasValidationError;
+        return ( bool )this.GetValue( ColumnBase.HasValidationErrorProperty );
       }
     }
 
@@ -1111,29 +1053,19 @@ namespace Xceed.Wpf.DataGrid
 
     #region SortDirection Property
 
-    private static readonly DependencyPropertyKey SortDirectionPropertyKey =
-        DependencyProperty.RegisterReadOnly( "SortDirection", typeof( SortDirection ), typeof( ColumnBase ), new PropertyMetadata( SortDirection.None, new PropertyChangedCallback( ColumnBase.OnSortDirectionChanged ) ) );
-
-    public static readonly DependencyProperty SortDirectionProperty =
-      ColumnBase.SortDirectionPropertyKey.DependencyProperty;
-
-    private SortDirection m_sortDirection = SortDirection.None;
-
-    private static void OnSortDirectionChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
+    private static readonly DependencyPropertyKey SortDirectionPropertyKey = DependencyProperty.RegisterReadOnly(
+      "SortDirection",
+      typeof( SortDirection ),
+      typeof( ColumnBase ),
+      new PropertyMetadata( SortDirection.None ) );
 
-      column.m_sortDirection = ( SortDirection )e.NewValue;
-    }
+    public static readonly DependencyProperty SortDirectionProperty = ColumnBase.SortDirectionPropertyKey.DependencyProperty;
 
     public SortDirection SortDirection
     {
       get
       {
-        return m_sortDirection;
+        return ( SortDirection )this.GetValue( ColumnBase.SortDirectionProperty );
       }
     }
 
@@ -1153,29 +1085,19 @@ namespace Xceed.Wpf.DataGrid
 
     #region SortIndex Read-Only Property
 
-    private static readonly DependencyPropertyKey SortIndexPropertyKey =
-        DependencyProperty.RegisterReadOnly( "SortIndex", typeof( int ), typeof( ColumnBase ), new PropertyMetadata( -1, new PropertyChangedCallback( ColumnBase.OnSortIndexChanged ) ) );
-
-    public static readonly DependencyProperty SortIndexProperty =
-      ColumnBase.SortIndexPropertyKey.DependencyProperty;
-
-    private int m_sortIndex = -1;
-
-    private static void OnSortIndexChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = o as ColumnBase;
-
-      if( column == null )
-        return;
+    private static readonly DependencyPropertyKey SortIndexPropertyKey = DependencyProperty.RegisterReadOnly(
+      "SortIndex",
+      typeof( int ),
+      typeof( ColumnBase ),
+      new PropertyMetadata( -1 ) );
 
-      column.m_sortIndex = ( int )e.NewValue;
-    }
+    public static readonly DependencyProperty SortIndexProperty = ColumnBase.SortIndexPropertyKey.DependencyProperty;
 
     public int SortIndex
     {
       get
       {
-        return m_sortIndex;
+        return ( int )this.GetValue( ColumnBase.SortIndexProperty );
       }
     }
 
@@ -1235,7 +1157,7 @@ namespace Xceed.Wpf.DataGrid
 
     private Nullable<bool> m_isMainColumn = null;
 
-    public bool IsMainColumn
+    public virtual bool IsMainColumn
     {
       get
       {
@@ -1248,31 +1170,36 @@ namespace Xceed.Wpf.DataGrid
       }
       set
       {
-        ColumnCollection containingCollection = this.ContainingCollection;
+        this.SetIsMainColumnInternal( value );
+      }
+    }
 
-        if( containingCollection == null )
+    internal virtual void SetIsMainColumnInternal( bool value )
+    {
+      ColumnCollection containingCollection = this.ContainingCollection;
+
+      if( containingCollection == null )
+      {
+        if( ( !m_isMainColumn.HasValue ) || ( m_isMainColumn.Value != value ) )
         {
-          if( ( !m_isMainColumn.HasValue ) || ( m_isMainColumn.Value != value ) )
-          {
-            m_isMainColumn = value;
-            this.OnPropertyChanged( new PropertyChangedEventArgs( "IsMainColumn" ) );
-          }
+          m_isMainColumn = value;
+          this.OnPropertyChanged( new PropertyChangedEventArgs( "IsMainColumn" ) );
         }
-        else
+      }
+      else
+      {
+        ColumnBase oldMainColumn = containingCollection.MainColumn;
+
+        if( oldMainColumn != this )
         {
-          ColumnBase oldMainColumn = containingCollection.MainColumn;
+          containingCollection.MainColumn = this;
+          // These two PropertyChanged are done in this order to be consistent with
+          // the events' order when adding a Column already "IsMainColumn".
+          this.OnPropertyChanged( new PropertyChangedEventArgs( "IsMainColumn" ) );
 
-          if( oldMainColumn != this )
+          if( oldMainColumn != null )
           {
-            containingCollection.MainColumn = this;
-            // These two PropertyChanged are done in this order to be consistent with
-            // the events' order when adding a Column already "IsMainColumn".
-            this.OnPropertyChanged( new PropertyChangedEventArgs( "IsMainColumn" ) );
-
-            if( oldMainColumn != null )
-            {
-              oldMainColumn.OnPropertyChanged( new PropertyChangedEventArgs( "IsMainColumn" ) );
-            }
+            oldMainColumn.OnPropertyChanged( new PropertyChangedEventArgs( "IsMainColumn" ) );
           }
         }
       }
@@ -1282,8 +1209,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region ReadOnly Property
 
-    public static readonly DependencyProperty ReadOnlyProperty =
-        DataGridControl.ReadOnlyProperty.AddOwner( typeof( ColumnBase ) );
+    public static readonly DependencyProperty ReadOnlyProperty = DependencyProperty.Register(
+      "ReadOnly",
+      typeof( bool ),
+      typeof( ColumnBase ),
+      new FrameworkPropertyMetadata( false ) );
 
     public virtual bool ReadOnly
     {
@@ -1297,7 +1227,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion ReadOnly Property
+    #endregion
 
     #region OverrideReadOnlyForInsertion Property
 
@@ -1324,7 +1254,7 @@ namespace Xceed.Wpf.DataGrid
     #region PreviousVisibleColumn Property
 
     [EditorBrowsable( EditorBrowsableState.Never )]
-    public ColumnBase PreviousVisibleColumn
+    public virtual ColumnBase PreviousVisibleColumn
     {
       get
       {
@@ -1360,7 +1290,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region NextVisibleColumn Property
 
-    private ColumnBase NextVisibleColumn
+    internal virtual ColumnBase NextVisibleColumn
     {
       get
       {
@@ -1371,7 +1301,12 @@ namespace Xceed.Wpf.DataGrid
         var columnsByVisiblePosition =
           ( this.ParentDetailConfiguration != null ) ? this.ParentDetailConfiguration.ColumnsByVisiblePosition : this.DataGridControl.ColumnsByVisiblePosition;
 
-        var nextColumnNode = columnsByVisiblePosition.Find( this ).Next;
+        var nextColumnNode = columnsByVisiblePosition.Find( this );
+
+        if( nextColumnNode != null )
+        {
+          nextColumnNode = nextColumnNode.Next;
+        }
 
         while( nextColumnNode != null )
         {
@@ -1395,23 +1330,13 @@ namespace Xceed.Wpf.DataGrid
       "CellRecyclingGroup",
       typeof( object ),
       typeof( ColumnBase ),
-      new FrameworkPropertyMetadata( null, new PropertyChangedCallback( ColumnBase.OnCellRecyclingGroupChanged ) ) );
-
-    private static void OnCellRecyclingGroupChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = sender as ColumnBase;
-
-      if( column == null )
-        return;
-
-      column.m_cellRecyclingGroup = e.NewValue;
-    }
+      new FrameworkPropertyMetadata( null ) );
 
     public object CellRecyclingGroup
     {
       get
       {
-        return m_cellRecyclingGroup;
+        return this.GetValue( ColumnBase.CellRecyclingGroupProperty );
       }
       set
       {
@@ -1422,22 +1347,73 @@ namespace Xceed.Wpf.DataGrid
     internal object GetCellRecyclingGroupOrDefault()
     {
       //Always return the one assigned by the client application
-      if( m_cellRecyclingGroup != null )
-        return m_cellRecyclingGroup;
+      var recyclingGroup = this.CellRecyclingGroup;
+      if( recyclingGroup != null )
+        return recyclingGroup;
+
+      var defaultCellRecyclingGroup = this.DefaultCellRecyclingGroup;
+      Debug.Assert( defaultCellRecyclingGroup != null );
+
+      return defaultCellRecyclingGroup;
+    }
 
-      //If not assigned, then generate and return the default.
-      if( m_defaultCellRecyclingGroup == null )
+    #endregion CellRecyclingGroup Property
+
+    #region DefaultCellRecyclingGroupDataType Internal Property
+
+    internal Type DefaultCellRecyclingGroupDataType
+    {
+      get
       {
-        m_defaultCellRecyclingGroup = new CellRecyclingGroupKey( this );
+        return m_defaultCellRecyclingGroupDataType;
       }
+      set
+      {
+        if( value == m_defaultCellRecyclingGroupDataType )
+          return;
+
+        Debug.Assert( value != null );
 
-      return m_defaultCellRecyclingGroup;
+        m_defaultCellRecyclingGroupDataType = value;
+
+        this.ResetDefaultCellRecyclingGroup();
+      }
+    }
+
+    private Type m_defaultCellRecyclingGroupDataType = typeof( object );
+
+    #endregion DefaultCellRecyclingGroupDataType Internal Property
+
+    #region DefaultCellRecyclingGroup Private Property
+
+    private object DefaultCellRecyclingGroup
+    {
+      get
+      {
+        if( m_defaultCellRecyclingGroup == null )
+        {
+          m_defaultCellRecyclingGroup = this.CreateDefaultCellRecyclingGroup();
+          if( m_defaultCellRecyclingGroup == null )
+            throw new InvalidOperationException( "CreateDefaultCellRecyclingGroup must return a non-null value." );
+        }
+
+        return m_defaultCellRecyclingGroup;
+      }
+    }
+
+    internal virtual object CreateDefaultCellRecyclingGroup()
+    {
+      return new CellRecyclingGroupKey( this.CellContentTemplate, this.DefaultCellRecyclingGroupDataType );
+    }
+
+    internal void ResetDefaultCellRecyclingGroup()
+    {
+      m_defaultCellRecyclingGroup = null;
     }
 
-    private object m_cellRecyclingGroup;
     private object m_defaultCellRecyclingGroup;
 
-    #endregion CellRecyclingGroup Property
+    #endregion DefaultCellRecyclingGroup Private Property
 
     #region CurrentRowInEditionCellState Property
 
@@ -1455,6 +1431,58 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region DisplayedValueConverter Property
+
+    public IValueConverter DisplayedValueConverter
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region DisplayedValueConverterParameter Property
+
+    public object DisplayedValueConverterParameter
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region DisplayedValueConverterCulture Property
+
+    public CultureInfo DisplayedValueConverterCulture
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region DefaultCulture Property
+
+    public static readonly DependencyProperty DefaultCultureProperty = DependencyProperty.Register(
+     "DefaultCulture",
+     typeof( CultureInfo ),
+     typeof( ColumnBase ),
+     new UIPropertyMetadata( CultureInfo.CurrentCulture ) );
+
+    public CultureInfo DefaultCulture
+    {
+      get
+      {
+        return ( CultureInfo )this.GetValue( ColumnBase.DefaultCultureProperty );
+      }
+      set
+      {
+        this.SetValue( ColumnBase.DefaultCultureProperty, value );
+      }
+    }
+
+    #endregion
+
     #region RealizedContainersRequested Event
 
     internal event RealizedContainersRequestedEventHandler RealizedContainersRequested;
@@ -1473,33 +1501,53 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region FittedWidthRequested Event
+
+    internal event FittedWidthRequestedEventHandler FittedWidthRequested;
+
+    private Nullable<double> RequestFittedWidth()
+    {
+      var handler = this.FittedWidthRequested;
+      if( handler == null )
+        return null;
+
+      var e = new FittedWidthRequestedEventArgs();
+      handler.Invoke( this, e );
+
+      return e.Value;
+    }
+
+    #endregion
+
 #if DEBUG
     public override string ToString()
     {
       string toString = base.ToString();
 
-      if( string.IsNullOrEmpty( this.FieldName ) == false )
+      if( !string.IsNullOrEmpty( this.FieldName ) )
+      {
         toString += " " + this.FieldName;
+      }
 
       return toString;
     }
 #endif
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate" )]
-    public double GetFittedWidth()
+    public virtual double GetFittedWidth()
     {
-      double fittedWidth = -1;
-
-      RealizedContainersRequestedEventArgs realizedContainers = new RealizedContainersRequestedEventArgs();
+      var fittedWidth = this.RequestFittedWidth().GetValueOrDefault( -1d );
 
+      var eventArgs = new RealizedContainersRequestedEventArgs();
       if( this.RealizedContainersRequested != null )
       {
-        this.RealizedContainersRequested( this, realizedContainers );
+        this.RealizedContainersRequested( this, eventArgs );
       }
 
-      if( realizedContainers.RealizedContainers.Count > 0 )
+      var realizedContainers = eventArgs.RealizedContainers;
+      if( realizedContainers.Count > 0 )
       {
-        fittedWidth = Math.Max( fittedWidth, this.GetElementCollectionFittedWidth( realizedContainers.RealizedContainers ) );
+        fittedWidth = Math.Max( fittedWidth, this.GetElementCollectionFittedWidth( realizedContainers ) );
       }
 
       return fittedWidth;
@@ -1526,6 +1574,21 @@ namespace Xceed.Wpf.DataGrid
       return false;
     }
 
+    internal virtual void SetIsBeingDraggedAnimated( bool value )
+    {
+      TableflowView.SetIsBeingDraggedAnimated( this, value );
+    }
+
+    internal virtual void SetColumnReorderingDragSourceManager( ColumnReorderingDragSourceManager value )
+    {
+      TableflowView.SetColumnReorderingDragSourceManager( this, value );
+    }
+
+    internal virtual void ClearColumnReorderingDragSourceManager()
+    {
+      TableflowView.ClearColumnReorderingDragSourceManager( this );
+    }
+
     internal void AttachToContainingCollection( ColumnCollection columnCollection )
     {
       if( columnCollection == null )
@@ -1560,8 +1623,7 @@ namespace Xceed.Wpf.DataGrid
           {
             oldMainColumn.OnPropertyChanged( new PropertyChangedEventArgs( "IsMainColumn" ) );
           }
-          // The PropertyChanged of this instance has already been fired before it 
-          // was added to the collection.
+          // The PropertyChanged of this instance has already been fired before it was added to the collection.
         }
 
         m_isMainColumn = null;
@@ -1570,7 +1632,7 @@ namespace Xceed.Wpf.DataGrid
       {
         if( columnCollection.Count == 0 )
         {
-          this.IsMainColumn = true;
+          this.SetIsMainColumnInternal( true );
         }
       }
     }
@@ -1602,18 +1664,69 @@ namespace Xceed.Wpf.DataGrid
         this.DistinctValuesRequested( this, e );
     }
 
+    internal bool GetIsSettingFixedColumnCount()
+    {
+      var detailConfiguration = this.ParentDetailConfiguration;
+      if( detailConfiguration != null )
+      {
+        return detailConfiguration.IsSettingFixedColumnCount;
+      }
+
+      return this.DataGridControl.DataGridContext.IsSettingFixedColumnCount;
+    }
+
+    internal int GetFixedColumnCount()
+    {
+      var detailConfiguration = this.ParentDetailConfiguration;
+      if( detailConfiguration != null )
+      {
+        return ( int )TableView.GetFixedColumnCount( detailConfiguration );
+      }
+
+      return ( int )TableView.GetFixedColumnCount( this.DataGridControl.DataGridContext );
+    }
+
+    internal void SetFixedColumnCountInfo( FixedColumnUpdateType updateType )
+    {
+      FixedColumnCountInfoEventArgs infoEventArgs = new FixedColumnCountInfoEventArgs( this, updateType );
+
+      var detailConfiguration = this.ParentDetailConfiguration;
+      if( detailConfiguration != null )
+      {
+        detailConfiguration.RaiseFixedColumnCountChanged( infoEventArgs );
+        return;
+      }
+
+      TableViewColumnVirtualizationManagerBase columnVirtualizationManager =
+                                         this.DataGridControl.DataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManagerBase;
+      columnVirtualizationManager.UpdateFixedColumnCountInfo( infoEventArgs );
+    }
+
+    internal CultureInfo GetCulture( CultureInfo value )
+    {
+      if( value != null )
+        return value;
+
+      return this.GetCulture();
+    }
+
+    internal CultureInfo GetCulture()
+    {
+      var culture = this.DefaultCulture;
+      if( culture != null )
+        return culture;
+
+      return CultureInfo.CurrentCulture;
+    }
+
     private double GetElementCollectionFittedWidth( IEnumerable collection )
     {
       if( collection == null )
         throw new ArgumentNullException( "collection" );
 
-      // Ensure to use the FieldName of the
-      // Cell instead of the visible position
-      // since a lookup dictionary is used underneath
-      // and if the Indexer is used, the Cells are returned
-      // in the order they were added, not visible position.
+      // Ensure to use the FieldName of the Cell instead of the visible position since a lookup dictionary is used underneath
+      // and if the Indexer is used, the Cells are returned in the order they were added, not visible position.
       double fittedWidth = -1;
-      string fieldName = this.FieldName;
 
       foreach( object item in collection )
       {
@@ -1629,190 +1742,162 @@ namespace Xceed.Wpf.DataGrid
           }
         }
 
-        if( row == null )
-          continue;
-
-        Cell cell = row.Cells[ fieldName ];
-
-        if( cell == null )
+        double cellFittedWidth;
+        if( !this.TryGetCellFittedWidth( row, out cellFittedWidth ) )
           continue;
 
-        fittedWidth = Math.Max( fittedWidth, cell.GetFittedWidth() );
+        fittedWidth = Math.Max( fittedWidth, cellFittedWidth );
       }
 
       return fittedWidth;
     }
 
-    private static void OnCellContentTemplateChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    private bool TryGetCellFittedWidth( Row row, out double fittedWidth )
     {
-      ColumnBase column = sender as ColumnBase;
-      Debug.Assert( column != null );
+      fittedWidth = -1;
 
-      if( column != null )
-      {
-        column.m_cellContentTemplate = e.NewValue as DataTemplate;
+      if( row == null )
+        return false;
 
-        //Make sure cells pertaining to this group are assigned to the correct recycle bin.
-        //The recycle bin based on the previous key value will be clean up later by the FixedCellPanel, if no other column uses it.
-        column.m_defaultCellRecyclingGroup = new CellRecyclingGroupKey( column );
+      Cell cell;
+      CellCollection cells = row.Cells;
+      VirtualizingCellCollection virtualCells = cells as VirtualizingCellCollection;
+      bool releaseCell = false;
 
-        if( column.CellContentTemplateChanged != null )
+      if( virtualCells != null )
+      {
+        if( !virtualCells.TryGetCell( this, out cell ) )
         {
-          column.CellContentTemplateChanged( sender, new EventArgs() );
-        }
-      }
-    }
+          releaseCell = true;
+          cell = virtualCells[ this ];
 
-    private static void OnCellContentTemplateSelectorChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ColumnBase column = sender as ColumnBase;
-      Debug.Assert( column != null );
+          Debug.Assert( cell != null );
 
-      if( column != null )
-      {
-        column.m_cellContentTemplateSelector = e.NewValue as DataTemplateSelector;
-
-        if( column.CellContentTemplateChanged != null )
-        {
-          column.CellContentTemplateChanged( sender, new EventArgs() );
+          if( !cell.IsMeasureValid )
+          {
+            cell.Measure( Size.Empty );
+          }
         }
       }
-    }
-
-    #region INotifyPropertyChanged Members
+      else
+      {
+        cell = cells[ this ];
+      }
 
-    public event PropertyChangedEventHandler PropertyChanged;
+      Debug.Assert( cell != null );
+      fittedWidth = cell.GetFittedWidth();
 
-    #endregion INotifyPropertyChanged Members
+      // A cell that was created or recycled to calculate the fitted width must be released
+      // in order to minimize the number of cells created overall.
+      if( releaseCell )
+      {
+        Debug.Assert( virtualCells != null );
+        virtualCells.Release( cell );
+      }
 
-    private ColumnCollection m_containingCollection; // = null
-    private CellState m_currentRowInEditionCellState;
+      return true;
+    }
 
-    internal partial class GenericContentTemplateSelector : DataTemplateSelector
+    private void SetIsSettingFixedColumnCount()
     {
-      static GenericContentTemplateSelector()
+      var detailConfiguration = this.ParentDetailConfiguration;
+      if( detailConfiguration != null )
       {
-        // We need to initalize the ResourceDictionary before accessing since we access
-        // it in a static constructor and will be called before the Layout was performed
-        GenericContentTemplateSelector.GenericContentTemplateResources.InitializeComponent();
-
-        GenericContentTemplateSelector.BoolTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "booleanDefaultContentTemplate" ] as DataTemplate;
-        Debug.Assert( GenericContentTemplateSelector.BoolTemplate != null );
-        GenericContentTemplateSelector.BoolTemplate.Seal();
-
-        GenericContentTemplateSelector.ImageTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "imageDefaultContentTemplate" ] as DataTemplate;
-        Debug.Assert( GenericContentTemplateSelector.ImageTemplate != null );
-        GenericContentTemplateSelector.ImageTemplate.Seal();
-
-        GenericContentTemplateSelector.ForeignKeyDistinctValueItemContentTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "foreignKeyDistinctValueItemDefaultContentTemplate" ] as DataTemplate;
-        Debug.Assert( GenericContentTemplateSelector.ForeignKeyDistinctValueItemContentTemplate != null );
-        GenericContentTemplateSelector.ForeignKeyDistinctValueItemContentTemplate.Seal();
-
-        GenericContentTemplateSelector.ForeignKeyCellContentTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "foreignKeyDefaultContentTemplate" ] as DataTemplate;
-        Debug.Assert( GenericContentTemplateSelector.ForeignKeyCellContentTemplate != null );
-        GenericContentTemplateSelector.ForeignKeyCellContentTemplate.Seal();
-
-        GenericContentTemplateSelector.ForeignKeyGroupValueTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "foreignKeyGroupValueDefaultContentTemplate" ] as DataTemplate;
-        Debug.Assert( GenericContentTemplateSelector.ForeignKeyGroupValueTemplate != null );
-        GenericContentTemplateSelector.ForeignKeyGroupValueTemplate.Seal();
-
-        GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "foreignKeyScrollTipDefaultContentTemplate" ] as DataTemplate;
-        Debug.Assert( GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate != null );
-        GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate.Seal();
-
+        detailConfiguration.IsSettingFixedColumnCount = true;
+        return;
       }
 
-      #region Singleton Pattern
+      this.DataGridControl.DataGridContext.IsSettingFixedColumnCount = true;
+    }
 
-      private GenericContentTemplateSelector()
+    private void SetFixedColumnCountInfo()
+    {
+      FixedColumnUpdateType updateType;
+      if( this.Visible )
       {
+        updateType = FixedColumnUpdateType.Show;
       }
-
-      public static GenericContentTemplateSelector Instance
+      else
       {
-        get
-        {
-          return m_instance;
-        }
+        updateType = FixedColumnUpdateType.Hide;
       }
 
-      private static GenericContentTemplateSelector m_instance = new GenericContentTemplateSelector();
+      this.SetFixedColumnCountInfo( updateType );
+    }
+
+    private static void OnCellContentStringFormatChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      ColumnBase column = ( ColumnBase )sender;
 
-      #endregion
+      if( string.IsNullOrEmpty( ( string )e.OldValue ) && string.IsNullOrEmpty( ( string )e.NewValue ) )
+        return;
 
-      public override DataTemplate SelectTemplate( object item, DependencyObject container )
+      if( column.CellContentStringFormatChanged != null )
       {
-        DataTemplate template = null;
-        bool useImageTemplate = false;
+        column.CellContentStringFormatChanged( sender, EventArgs.Empty );
+      }
+    }
 
-        if( ( item is byte[] ) || ( item is System.Drawing.Image ) )
-        {
-          ImageConverter converter = new ImageConverter();
-          object convertedValue = null;
+    private static void OnCellContentTemplateChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var column = ( ColumnBase )sender;
 
-          try
-          {
-            convertedValue = converter.Convert( item, typeof( ImageSource ), null, System.Globalization.CultureInfo.CurrentCulture );
-          }
-          catch( NotSupportedException )
-          {
-            //suppress the exception, the byte[] is not an image. convertedValue will remain null
-          }
+      //Make sure cells pertaining to this group are assigned to the correct recycle bin.
+      //The recycle bin based on the previous key value will be clean up later by the FixedCellPanel, if no other column uses it.
+      column.ResetDefaultCellRecyclingGroup();
 
-          if( convertedValue != null )
-            useImageTemplate = true;
-        }
-        else if( item is ImageSource )
-        {
-          useImageTemplate = true;
-        }
-        else if( item is bool )
-        {
-          template = GenericContentTemplateSelector.BoolTemplate;
-        }
-
-        if( useImageTemplate )
-        {
-          template = GenericContentTemplateSelector.ImageTemplate;
+      var handler = column.CellContentTemplateChanged;
+      if( handler != null )
+      {
+        handler.Invoke( column, EventArgs.Empty );
+      }
+    }
 
-          DataGridContext dataGridContext = DataGridControl.GetDataGridContext( container );
+    private static void OnCellContentTemplateSelectorChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var column = ( ColumnBase )sender;
+      var handler = column.CellContentTemplateChanged;
 
-          DataGridControl parentGrid = ( dataGridContext != null )
-            ? dataGridContext.DataGridControl
-            : null;
-        }
+      if( handler != null )
+      {
+        handler.Invoke( column, EventArgs.Empty );
+      }
+    }
 
-        if( template == null )
-          template = base.SelectTemplate( item, container );
+    #region INotifyPropertyChanged Members
 
-        return template;
-      }
+    public event PropertyChangedEventHandler PropertyChanged;
 
-      private static GenericContentTemplateSelectorResources GenericContentTemplateResources = new GenericContentTemplateSelectorResources();
+    #endregion INotifyPropertyChanged Members
 
-      private static readonly DataTemplate BoolTemplate;
-      private static readonly DataTemplate ImageTemplate;
+    #region IWeakEventListener Members
 
-      internal static readonly DataTemplate ForeignKeyDistinctValueItemContentTemplate;
-      internal static readonly DataTemplate ForeignKeyCellContentTemplate;
-      internal static readonly DataTemplate ForeignKeyGroupValueTemplate;
-      internal static readonly DataTemplate ForeignKeyScrollTipContentTemplate;
+    bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      return false;
     }
 
+    #endregion
+
+    private ColumnCollection m_containingCollection; // = null
+    private CellState m_currentRowInEditionCellState;
+
     private sealed class CellRecyclingGroupKey
     {
-      internal CellRecyclingGroupKey( ColumnBase column )
+      internal CellRecyclingGroupKey( DataTemplate contentTemplate, Type dataType )
       {
         //This is a value that is cached at the cell level and that is costly to update, thus basing the recycling on it optimizes performance.
-        m_cellContentTemplate = column.CellContentTemplate;
+        m_contentTemplate = contentTemplate;
+        m_dataType = dataType;
       }
 
       public override int GetHashCode()
       {
-        if( m_cellContentTemplate != null )
-        {
-          return m_cellContentTemplate.GetHashCode();
-        }
+        if( m_contentTemplate != null )
+          return m_contentTemplate.GetHashCode();
+
+        if( m_dataType != null )
+          return m_dataType.GetHashCode();
 
         return 0;
       }
@@ -1826,10 +1911,14 @@ namespace Xceed.Wpf.DataGrid
         if( key == this )
           return true;
 
-        return object.Equals( key.m_cellContentTemplate, m_cellContentTemplate );
+        if( ( key.m_contentTemplate == null ) && ( m_contentTemplate == null ) )
+          return ( key.m_dataType == m_dataType );
+
+        return ( key.m_contentTemplate == m_contentTemplate );
       }
 
-      private readonly DataTemplate m_cellContentTemplate;
+      private readonly DataTemplate m_contentTemplate;
+      private readonly Type m_dataType;
     }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCollection.cs
index 9bec1e01..a265445e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCollection.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCollection.cs
@@ -15,17 +15,12 @@
   ***********************************************************************************/
 
 using System;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Controls.Primitives;
-using System.Windows.Data;
-using System.Text;
-using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.ComponentModel;
 using System.Collections.Specialized;
-using System.Diagnostics;
+using System.ComponentModel;
+using System.Windows.Threading;
+using System.Threading;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -39,20 +34,6 @@ namespace Xceed.Wpf.DataGrid
       this.ParentDetailConfiguration = parentDetailConfiguration;
     }
 
-    public ColumnBase this[ string fieldName ]
-    {
-      get
-      {
-        ColumnBase column = null;
-
-        m_fieldNameToColumns.TryGetValue( fieldName, out column );
-
-        return column;
-      }
-    }
-
-    // PUBLIC PROPERTIES
-
     #region MainColumn Property
 
     public ColumnBase MainColumn
@@ -75,11 +56,9 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    // INTERNAL PROPERTIES
-
     #region FieldNameToColumnDictionary Property
 
-    internal Dictionary<string,ColumnBase> FieldNameToColumnDictionary
+    internal Dictionary<string, ColumnBase> FieldNameToColumnDictionary
     {
       get
       {
@@ -97,7 +76,6 @@ namespace Xceed.Wpf.DataGrid
       {
         return m_dataGridControl;
       }
-
       set
       {
         m_dataGridControl = value;
@@ -125,86 +103,58 @@ namespace Xceed.Wpf.DataGrid
 
     #region ProcessingVisibleColumnsUpdate Property
 
-    internal bool ProcessingVisibleColumnsUpdate
+    internal AutoResetFlag ProcessingVisibleColumnsUpdate
     {
       get
       {
         return m_processingVisibleColumnsUpdate;
       }
-      set
-      {
-        m_processingVisibleColumnsUpdate = value;
-      }
     }
 
-    private bool m_processingVisibleColumnsUpdate; // = false
+    private readonly AutoResetFlag m_processingVisibleColumnsUpdate = AutoResetFlagFactory.Create();
 
     #endregion
 
-    #region VisibleColumnsUpdateDelayed Property
-
-    internal bool VisibleColumnsUpdateDelayed
+    public ColumnBase this[ string fieldName ]
     {
       get
       {
-        return m_visibleColumnsUpdateDelayed;
-      }
-      set
-      {
-        m_visibleColumnsUpdateDelayed = value;
-      }
-    }
-
-    private bool m_visibleColumnsUpdateDelayed; // = false
-
-    #endregion
+        ColumnBase column = null;
 
-    #region Column Event Handlers
+        m_fieldNameToColumns.TryGetValue( fieldName, out column );
 
-    private void RegisterColumnChangedEvent( ColumnBase column )
-    {
-      column.TitleChanged += new EventHandler( this.OnColumnValueChanged );
-      column.VisiblePositionChanged += new EventHandler( this.OnColumnValueChanged );
-      column.VisiblePositionChanged += new EventHandler( this.OnColumnVisibilityChanged );
-      column.VisibleChanged += new EventHandler( this.OnColumnVisibilityChanged );
+        return column;
+      }
     }
 
-    private void UnregisterColumnChangedEvent( ColumnBase column )
-    {
-      column.TitleChanged -= new EventHandler( this.OnColumnValueChanged );
-      column.VisiblePositionChanged -= new EventHandler( this.OnColumnValueChanged );
-      column.VisiblePositionChanged -= new EventHandler( this.OnColumnVisibilityChanged );
-      column.VisibleChanged -= new EventHandler( this.OnColumnVisibilityChanged );
-    }
+    #region IsDeferVisibleColumnsUpdate Internal Property
 
-    private void OnColumnVisibilityChanged( object sender, EventArgs e )
+    internal bool IsDeferVisibleColumnsUpdate
     {
-      if( this.ColumnVisibilityChanged != null )
-        this.ColumnVisibilityChanged( this, new WrappedEventEventArgs( sender, e ) );
+      get
+      {
+        return ( m_deferVisibleColumnsUpdateCount > 0 );
+      }
     }
 
-    internal event EventHandler ColumnVisibilityChanged;
-
+    #endregion
 
-    private void OnColumnValueChanged( object sender, EventArgs e )
+    public IDisposable DeferVisibleColumnsUpdate()
     {
+      return new DeferedColumnsVisibleUpdateDisposable( this );
     }
 
-    #endregion Column Event Handlers
-
-    // PROTECTED METHODS
-
     protected override void RemoveItem( int index )
     {
       ColumnBase column = this[ index ];
 
       if( column != null )
       {
-        m_fieldNameToColumns.Remove( column.FieldName );
-
         this.UnregisterColumnChangedEvent( column );
 
         column.DetachFromContainingCollection();
+
+        m_fieldNameToColumns.Remove( column.FieldName );
       }
 
       base.RemoveItem( index );
@@ -215,17 +165,15 @@ namespace Xceed.Wpf.DataGrid
       if( item != null )
       {
         if( ( string.IsNullOrEmpty( item.FieldName ) == true ) && ( !DesignerProperties.GetIsInDesignMode( item ) ) )
-        {
           throw new ArgumentException( "A column must have a fieldname.", "item" );
-        }
-
-        item.AttachToContainingCollection( this );
 
         if( m_fieldNameToColumns.ContainsKey( item.FieldName ) )
           throw new DataGridException( "A column with same field name already exists in collection." );
 
         m_fieldNameToColumns.Add( item.FieldName, item );
 
+        item.AttachToContainingCollection( this );
+
         this.RegisterColumnChangedEvent( item );
       }
 
@@ -249,37 +197,37 @@ namespace Xceed.Wpf.DataGrid
     protected override void SetItem( int index, ColumnBase item )
     {
       if( ( item != null ) && ( string.IsNullOrEmpty( item.FieldName ) == true ) )
-      {
         throw new ArgumentException( "A column must have a fieldname.", "item" );
-      }
+
+      if( m_fieldNameToColumns.ContainsKey( item.FieldName ) )
+        throw new DataGridException( "A column with same field name already exists in collection." );
 
       ColumnBase column = this[ index ];
 
       if( ( column != null ) && ( column != item ) )
       {
-        m_fieldNameToColumns.Remove( column.FieldName );
-
         this.UnregisterColumnChangedEvent( column );
 
         column.DetachFromContainingCollection();
+
+        m_fieldNameToColumns.Remove( column.FieldName );
       }
 
       if( ( item != null ) && ( column != item ) )
       {
+        m_fieldNameToColumns.Add( item.FieldName, item );
+
         item.AttachToContainingCollection( this );
 
         this.RegisterColumnChangedEvent( item );
-
-        m_fieldNameToColumns.Add( item.FieldName, item );
       }
 
       base.SetItem( index, item );
     }
 
-    protected override void OnCollectionChanged( System.Collections.Specialized.NotifyCollectionChangedEventArgs e )
+    protected override void OnCollectionChanged( NotifyCollectionChangedEventArgs e )
     {
-      if( ( m_columnAdditionMessagesDeferedCount > 0 )
-        && ( e.Action == NotifyCollectionChangedAction.Add ) && ( e.NewStartingIndex == ( this.Count - e.NewItems.Count ) ) )
+      if( ( m_columnAdditionMessagesDeferedCount > 0 ) && ( e.Action == NotifyCollectionChangedAction.Add ) && ( e.NewStartingIndex == ( this.Count - e.NewItems.Count ) ) )
       {
         if( m_deferedColumnAdditionMessageStartIndex == -1 )
         {
@@ -297,8 +245,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    // INTERNAL METHODS
-
     internal IDisposable DeferColumnAdditionMessages()
     {
       return new DeferedColumnAdditionMessageDisposable( this );
@@ -314,11 +260,19 @@ namespace Xceed.Wpf.DataGrid
 
     internal event EventHandler VisibleColumnsUpdating;
 
-    internal void NotifyVisibleColumnsUpdated()
+    internal void DispatchNotifyVisibleColumnsUpdated()
     {
-      if( this.VisibleColumnsUpdated != null )
+      //In all cases, make sure the ColumnVitualizationManager is flaged as outdate, but prevent to make updates to FixedCellPanels right away.
+      this.NotifyVisibleColumnsUpdated( true );
+
+      //In all cases, make sure we dipatch an operation to update the FixedCellPanels in case the update is not tiggered by other means (e.g. no scrolling, no DataRow in the grid).
+      if( m_visibleColumnsUpdatedDispatcherOperation == null && m_dataGridControl != null )
       {
-        this.VisibleColumnsUpdated( this, EventArgs.Empty );
+        ////# Will be null at first in the case of a detail, so process directly
+
+        //This permits less updates = better performance.
+        m_visibleColumnsUpdatedDispatcherOperation =
+          m_dataGridControl.Dispatcher.BeginInvoke( DispatcherPriority.Render, new Action<bool>( this.NotifyVisibleColumnsUpdated ), false );
       }
     }
 
@@ -354,10 +308,83 @@ namespace Xceed.Wpf.DataGrid
 
     internal event ColumnActualWidthChangedHandler ActualWidthChanged;
 
+    internal event EventHandler ColumnVisibilityChanging;
+    internal event EventHandler ColumnVisibilityChanged;
+
+    private void RegisterColumnChangedEvent( ColumnBase column )
+    {
+      column.PropertyChanged += new PropertyChangedEventHandler( this.OnColumnPropertyChanged );
+      column.TitleChanged += new EventHandler( this.OnColumnValueChanged );
+      column.VisiblePositionChanging += new EventHandler( this.OnColumnVisibilityChanging );
+      column.VisiblePositionChanged += new EventHandler( this.OnColumnValueChanged );
+      column.VisiblePositionChanged += new EventHandler( this.OnColumnVisibilityChanged );
+      column.VisibleChanged += new EventHandler( this.OnColumnVisibilityChanged );
+    }
+
+    private void UnregisterColumnChangedEvent( ColumnBase column )
+    {
+      column.PropertyChanged -= new PropertyChangedEventHandler( this.OnColumnPropertyChanged );
+      column.TitleChanged -= new EventHandler( this.OnColumnValueChanged );
+      column.VisiblePositionChanging -= new EventHandler( this.OnColumnVisibilityChanging );
+      column.VisiblePositionChanged -= new EventHandler( this.OnColumnValueChanged );
+      column.VisiblePositionChanged -= new EventHandler( this.OnColumnVisibilityChanged );
+      column.VisibleChanged -= new EventHandler( this.OnColumnVisibilityChanged );
+    }
+
+    private void OnColumnPropertyChanged( object sender, PropertyChangedEventArgs e )
+    {
+      if( string.IsNullOrEmpty( e.PropertyName ) || e.PropertyName == "IsMainColumn" )
+      {
+        // The ColumnBase.IsMainColumn property impacts the columns visibility when details are flatten.
+        var dataGridControl = this.DataGridControl;
+        if( ( dataGridControl != null ) && ( dataGridControl.AreDetailsFlatten ) )
+        {
+          this.OnColumnVisibilityChanged( sender, EventArgs.Empty );
+        }
+      }
+    }
+
+    private void OnColumnVisibilityChanging( object sender, EventArgs e )
+    {
+      if( this.ColumnVisibilityChanging != null )
+      {
+        this.ColumnVisibilityChanging( this, new WrappedEventEventArgs( sender, e ) );
+      }
+    }
+
+    private void OnColumnVisibilityChanged( object sender, EventArgs e )
+    {
+      if( this.ColumnVisibilityChanged != null )
+      {
+        this.ColumnVisibilityChanged( this, new WrappedEventEventArgs( sender, e ) );
+      }
+    }
+
+    private void OnColumnValueChanged( object sender, EventArgs e )
+    {
+      ColumnBase column = ( ColumnBase )sender;
+    }
+
+    private void NotifyVisibleColumnsUpdated( bool onlyIncrementFlag )
+    {
+      if( this.VisibleColumnsUpdated != null )
+      {
+        this.VisibleColumnsUpdated( this, new VisibleColumnsUpdatedEventArgs( onlyIncrementFlag ) );
+      }
+
+      //If only updating the flag, don't reset the DispatcherOperation, since if it is still alive, another call will be made which will reset it.
+      if( onlyIncrementFlag )
+        return;
+
+      m_visibleColumnsUpdatedDispatcherOperation = null;
+    }
+
     private int m_columnAdditionMessagesDeferedCount = 0;
+    private int m_deferVisibleColumnsUpdateCount = 0;
     private int m_deferedColumnAdditionMessageStartIndex = -1;
     private List<ColumnBase> m_deferedColumns = new List<ColumnBase>();
     private Dictionary<string, ColumnBase> m_fieldNameToColumns = new Dictionary<string, ColumnBase>(); // To optimize indexing speed for FieldName
+    private DispatcherOperation m_visibleColumnsUpdatedDispatcherOperation;
 
     private sealed class DeferedColumnAdditionMessageDisposable : IDisposable
     {
@@ -374,6 +401,14 @@ namespace Xceed.Wpf.DataGrid
       #region IDisposable Members
 
       public void Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      #endregion
+
+      private void Dispose( bool disposing )
       {
         m_columns.m_columnAdditionMessagesDeferedCount--;
 
@@ -389,8 +424,49 @@ namespace Xceed.Wpf.DataGrid
         }
       }
 
+      ~DeferedColumnAdditionMessageDisposable()
+      {
+        this.Dispose( false );
+      }
+
+      private ColumnCollection m_columns; // = null
+    }
+
+    private sealed class DeferedColumnsVisibleUpdateDisposable : IDisposable
+    {
+      public DeferedColumnsVisibleUpdateDisposable( ColumnCollection columns )
+      {
+        if( columns == null )
+          throw new ArgumentNullException( "columns" );
+
+        m_columns = columns;
+
+        Interlocked.Increment( ref m_columns.m_deferVisibleColumnsUpdateCount );
+      }
+
+      #region IDisposable Members
+
+      public void Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
       #endregion
 
+      private void Dispose( bool disposing )
+      {
+        if( Interlocked.Decrement( ref m_columns.m_deferVisibleColumnsUpdateCount ) != 0 )
+          return;
+
+        m_columns.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+      }
+
+      ~DeferedColumnsVisibleUpdateDisposable()
+      {
+        this.Dispose( false );
+      }
+
       private ColumnCollection m_columns; // = null
     }
 
@@ -408,8 +484,17 @@ namespace Xceed.Wpf.DataGrid
         this.WrappedEventArgs = eventArgs;
       }
 
-      public object WrappedSender { get; private set; }
-      public object WrappedEventArgs { get; private set; }
+      public object WrappedSender
+      {
+        get;
+        private set;
+      }
+
+      public object WrappedEventArgs
+      {
+        get;
+        private set;
+      }
     }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCommand.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCommand.cs
new file mode 100644
index 00000000..a8ce1c39
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnCommand.cs
@@ -0,0 +1,62 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Diagnostics;
+using System.Windows.Input;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class ColumnCommand : ICommand
+  {
+    #region Validation Methods
+
+    protected static void ThrowIfNull( object value, string paramName )
+    {
+      if( value == null )
+        throw new ArgumentNullException( paramName );
+    }
+
+    #endregion
+
+    protected abstract bool CanExecuteImpl( object parameter );
+    protected abstract void ExecuteImpl( object parameter );
+
+    #region ICommand Members
+
+    event EventHandler ICommand.CanExecuteChanged
+    {
+      add
+      {
+      }
+      remove
+      {
+      }
+    }
+
+    bool ICommand.CanExecute( object parameter )
+    {
+      return this.CanExecuteImpl( parameter );
+    }
+
+    void ICommand.Execute( object parameter )
+    {
+      this.ExecuteImpl( parameter );
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnGroupCommand.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnGroupCommand.cs
new file mode 100644
index 00000000..676448be
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnGroupCommand.cs
@@ -0,0 +1,26 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Diagnostics;
+using System.Windows.Input;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class ColumnGroupCommand : ColumnCommand
+  {
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerCell.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerCell.cs
index c746db14..7474089a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerCell.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerCell.cs
@@ -17,19 +17,15 @@
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Windows;
+using System.Windows.Automation.Peers;
 using System.Windows.Controls.Primitives;
 using System.Windows.Data;
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
 using Xceed.Utils.Wpf.DragDrop;
-using Xceed.Wpf.DataGrid.Views;
-using System.Collections;
-using Xceed.Utils.Collections;
-using System.Collections.Specialized;
-using System;
-using System.Windows.Automation.Peers;
 using Xceed.Wpf.DataGrid.Automation;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -42,11 +38,9 @@ namespace Xceed.Wpf.DataGrid
       FocusableProperty.OverrideMetadata( typeof( ColumnManagerCell ), new FrameworkPropertyMetadata( false ) );
       ReadOnlyProperty.OverrideMetadata( typeof( ColumnManagerCell ), new FrameworkPropertyMetadata( true ) );
 
-      ColumnManagerCell.IsPressedProperty =
-        ColumnManagerCell.IsPressedPropertyKey.DependencyProperty;
+      ColumnManagerCell.IsPressedProperty = ColumnManagerCell.IsPressedPropertyKey.DependencyProperty;
 
-      ColumnManagerCell.IsBeingDraggedProperty =
-        ColumnManagerCell.IsBeingDraggedPropertyKey.DependencyProperty;
+      ColumnManagerCell.IsBeingDraggedProperty = ColumnManagerCell.IsBeingDraggedPropertyKey.DependencyProperty;
     }
 
     public ColumnManagerCell()
@@ -98,14 +92,12 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion IsBeingDragged Read-Only Property
 
-    #region DataGridContext Property
+    #region DataGridContext Internal Read-Only Property
 
-    private DataGridContext DataGridContext
+    internal DataGridContext DataGridContext
     {
       get
       {
-        Debug.Assert( m_dataGridContext != null );
-
         return m_dataGridContext;
       }
     }
@@ -126,11 +118,44 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region ShowResizeCursor Property
+
+    internal bool ShowResizeCursor
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region AllowResize Internal Read-Only Property
+
+    internal virtual bool AllowResize
+    {
+      get
+      {
+        if( this.ParentColumn == null )
+          return false;
+
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return false;
+
+        // When details are flatten, only the column at the master level may be resized.
+        if( dataGridContext.IsAFlattenDetail )
+          return false;
+
+        return true;
+      }
+    }
+
+    #endregion
+
     #region ColumnReordering Internal Event
 
     internal static readonly RoutedEvent ColumnReorderingEvent =
           EventManager.RegisterRoutedEvent( "ColumnReordering",
-               RoutingStrategy.Bubble,
+             RoutingStrategy.Bubble,
              typeof( ColumnReorderingEventHandler ),
              typeof( ColumnManagerCell ) );
 
@@ -147,9 +172,9 @@ namespace Xceed.Wpf.DataGrid
     {
       base.InitializeCore( dataGridContext, parentRow, parentColumn );
 
-      this.SetContent( parentColumn );
-      this.SetContentTemplate( parentColumn );
-      this.SetContentTemplateSelector( parentColumn );
+      this.SetColumnBinding( ColumnManagerCell.ContentProperty, parentColumn, ColumnBase.TitleProperty );
+      this.SetColumnBinding( ColumnManagerCell.ContentTemplateProperty, parentColumn, ColumnBase.TitleTemplateProperty );
+      this.SetColumnBinding( ColumnManagerCell.ContentTemplateSelectorProperty, parentColumn, ColumnBase.TitleTemplateSelectorProperty );
     }
 
     protected override AutomationPeer OnCreateAutomationPeer()
@@ -159,12 +184,11 @@ namespace Xceed.Wpf.DataGrid
 
     protected internal override void PrepareDefaultStyleKey( ViewBase view )
     {
-      object currentThemeKey = view.GetDefaultStyleKey( typeof( ColumnManagerCell ) );
+      var newThemeKey = view.GetDefaultStyleKey( typeof( ColumnManagerCell ) );
+      if( object.Equals( this.DefaultStyleKey, newThemeKey ) )
+        return;
 
-      if( currentThemeKey.Equals( this.DefaultStyleKey ) == false )
-      {
-        this.DefaultStyleKey = currentThemeKey;
-      }
+      this.DefaultStyleKey = newThemeKey;
     }
 
     protected internal override void PrepareContainer( DataGridContext dataGridContext, object item )
@@ -201,9 +225,7 @@ namespace Xceed.Wpf.DataGrid
             // Update the DropOutsideCursor since it is defined on the View
             UIViewBase uiViewBase = dataGridContext.DataGridControl.GetView() as UIViewBase;
 
-            m_dragSourceManager.DropOutsideCursor = ( uiViewBase != null )
-             ? uiViewBase.CannotDropDraggedElementCursor
-             : UIViewBase.DefaultCannotDropDraggedElementCursor;
+            m_dragSourceManager.DropOutsideCursor = ( uiViewBase != null ) ? uiViewBase.CannotDropDraggedElementCursor : UIViewBase.DefaultCannotDropDraggedElementCursor;
 
             m_dragSourceManager.ProcessMouseLeftButtonDown( e );
           }
@@ -242,8 +264,7 @@ namespace Xceed.Wpf.DataGrid
 
     protected override void OnMouseLeftButtonUp( MouseButtonEventArgs e )
     {
-      // m_dragSourceManager.ProcessMouseLeftButtonUp() will release the capture,
-      // so we need to check the IsMouseCaptured and IsPressed states before calling it.
+      // m_dragSourceManager.ProcessMouseLeftButtonUp() will release the capture, so we need to check the IsMouseCaptured and IsPressed states before calling it.
       bool isMouseCaptured = this.IsMouseCaptured;
       bool isPressed = this.IsPressed;
 
@@ -290,7 +311,9 @@ namespace Xceed.Wpf.DataGrid
     protected override void OnLostMouseCapture( MouseEventArgs e )
     {
       if( m_dragSourceManager != null )
+      {
         m_dragSourceManager.ProcessLostMouseCapture( e );
+      }
 
       if( this.IsPressed )
       {
@@ -303,7 +326,6 @@ namespace Xceed.Wpf.DataGrid
     internal bool CanDoSort()
     {
       ColumnManagerRow parentRow = this.ParentRow as ColumnManagerRow;
-
       if( parentRow != null )
       {
         if( !parentRow.AllowSort )
@@ -311,10 +333,13 @@ namespace Xceed.Wpf.DataGrid
       }
 
       DataGridContext dataGridContext = this.DataGridContext;
-
       if( dataGridContext == null )
         return false;
 
+      // When details are flatten, only the ColumnManagerCell at the master level may do the sort.
+      if( dataGridContext.IsAFlattenDetail )
+        return false;
+
       if( dataGridContext.SourceDetailConfiguration == null )
       {
         if( !dataGridContext.Items.CanSort )
@@ -325,7 +350,6 @@ namespace Xceed.Wpf.DataGrid
         return false;
 
       ColumnBase parentColumn = this.ParentColumn;
-
       if( ( parentColumn == null ) || ( !parentColumn.AllowSort ) )
         return false;
 
@@ -338,159 +362,83 @@ namespace Xceed.Wpf.DataGrid
         return;
 
       DataGridContext dataGridContext = this.DataGridContext;
+      ColumnBase column = this.ParentColumn;
 
       Debug.Assert( dataGridContext != null );
 
-      SortingHelper.ToggleColumnSort(
-        dataGridContext, dataGridContext.Items.SortDescriptions,
-        dataGridContext.Columns, this.ParentColumn, shiftUnpressed );
+      var toggleColumnSortCommand = dataGridContext.ToggleColumnSortCommand;
+      if( !toggleColumnSortCommand.CanExecute( column, shiftUnpressed ) )
+        return;
+
+      toggleColumnSortCommand.Execute( column, shiftUnpressed );
     }
 
-    internal void DoResize( double newWidth )
+    internal void DoResize( double newWidth, ColumnBase parentColumn )
     {
       if( !this.IsEnabled )
         return;
 
-      ColumnBase parentColumn = this.ParentColumn;
-
-      if( parentColumn == null )
-        return;
-
       if( !parentColumn.HasFixedWidth )
       {
         if( newWidth < MIN_WIDTH )
+        {
           newWidth = MIN_WIDTH;
+        }
 
         if( newWidth < parentColumn.MinWidth )
+        {
           newWidth = parentColumn.MinWidth;
+        }
 
         if( newWidth > parentColumn.MaxWidth )
+        {
           newWidth = parentColumn.MaxWidth;
+        }
 
         parentColumn.Width = newWidth;
       }
     }
 
-    private void SetContent( ColumnBase parentColumn )
-    {
-      Binding binding = new Binding();
-      binding.Path = new PropertyPath( ColumnBase.TitleProperty );
-      binding.Mode = BindingMode.OneWay;
-      binding.Source = parentColumn;
-      binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
-      BindingOperations.SetBinding( this, ColumnManagerCell.ContentProperty, binding );
-    }
-
-    private void SetContentTemplate( ColumnBase parentColumn )
-    {
-      Binding binding = new Binding();
-      binding.Path = new PropertyPath( ColumnBase.TitleTemplateProperty );
-      binding.Mode = BindingMode.OneWay;
-      binding.Source = parentColumn;
-      binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
-      BindingOperations.SetBinding( this, ColumnManagerCell.ContentTemplateProperty, binding );
-    }
-
-    private void SetContentTemplateSelector( ColumnBase parentColumn )
+    internal virtual void OnColumnResizerThumbDragStarted( DragStartedEventArgs e )
     {
-      Binding binding = new Binding();
-      binding.Path = new PropertyPath( ColumnBase.TitleTemplateSelectorProperty );
-      binding.Mode = BindingMode.OneWay;
-      binding.Source = parentColumn;
-      binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
-      BindingOperations.SetBinding( this, ColumnManagerCell.ContentTemplateSelectorProperty, binding );
-    }
-
-    private void SetupDragManager()
-    {
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
-      // We do not support DragDrop when there are no AdornerLayer because there wouldn't 
-      // be any visual feedback for the operation.
-      AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer( this );
-
-      if( adornerLayer == null )
-      {
-        // When virtualizing, the Cell is not yet in the VisualTree because it is
-        // the ParentRow's CellsHost which is reponsible of putting them in the 
-        // VisualTree. We try to get the adorner from the ParentRow instead
-        if( this.ParentRow != null )
-          adornerLayer = AdornerLayer.GetAdornerLayer( this.ParentRow );
-
-        if( adornerLayer == null )
-          return;
-      }
-
-      // Can be null in design-time (edition of a style TargetType ColumnManagerCell).
-      if( dataGridContext == null )
-        return;
-
-      DataGridControl dataGridControl = dataGridContext.DataGridControl;
-
-      if( dataGridControl == null )
-        return;
+      var parentColumn = this.ParentColumn;
+      Debug.Assert( parentColumn != null );
 
+      var dataGridContext = this.DataGridContext;
+      Debug.Assert( dataGridContext != null );
 
-      if( m_dragSourceManager != null )
-      {
-        m_dragSourceManager.PropertyChanged -= this.DragSourceManager_PropertyChanged;
-      }
+      m_originalWidth = parentColumn.ActualWidth;
 
-      // The DataGridControl's AdornerDecoratorForDragAndDrop must be used for dragging in order to include the 
-      // RenderTransform the DataGridControl may performs. This AdornerDecorator is defined in the ControlTemplate
-      // as PART_DragDropAdornerDecorator
-      if( ( dataGridControl.DragDropAdornerDecorator != null )
-          && ( dataGridControl.DragDropAdornerDecorator.AdornerLayer != null ) )
-      {
-        m_dragSourceManager = new ColumnReorderingDragSourceManager( this,
-                                                                     dataGridControl.DragDropAdornerDecorator.AdornerLayer,
-                                                                     dataGridControl );
-      }
-      else
+      if( TableView.GetRemoveColumnStretchingOnResize( dataGridContext ) )
       {
-        m_dragSourceManager = new ColumnReorderingDragSourceManager( this,
-                                                                     null,
-                                                                     dataGridControl );
+        dataGridContext.ColumnStretchingManager.DisableColumnStretching();
       }
+    }
 
-      m_dragSourceManager.PropertyChanged += this.DragSourceManager_PropertyChanged;
-
-      // Create bindings to ViewProperties for AutoScroll Properties
-      Binding binding = new Binding();
-      binding.Path = new PropertyPath( "(0).(1)",
-        DataGridControl.DataGridContextProperty,
-        TableView.AutoScrollIntervalProperty );
-
-      binding.Mode = BindingMode.OneWay;
-      binding.Source = this;
-
-      BindingOperations.SetBinding( m_dragSourceManager, DragSourceManager.AutoScrollIntervalProperty, binding );
-
-      binding = new Binding();
-      binding.Path = new PropertyPath( "(0).(1)", DataGridControl.DataGridContextProperty, TableView.AutoScrollTresholdProperty );
-      binding.Mode = BindingMode.OneWay;
-      binding.Source = this;
+    internal virtual void OnColumnResizerThumbDragDelta( DragDeltaEventArgs e )
+    {
+      var parentColumn = this.ParentColumn;
+      Debug.Assert( parentColumn != null );
 
-      BindingOperations.SetBinding( m_dragSourceManager, DragSourceManager.AutoScrollTresholdProperty, binding );
+      this.DoResize( parentColumn.ActualWidth + e.HorizontalChange, parentColumn );
     }
 
-    private void DragSourceManager_PropertyChanged( object sender, PropertyChangedEventArgs e )
+    internal virtual void OnColumnResizerThumbDragCompleted( DragCompletedEventArgs e )
     {
-      if( e.PropertyName == "IsDragging" )
+      if( e.Canceled )
       {
-        this.SetIsBeingDragged( m_dragSourceManager.IsDragging );
+        this.ParentColumn.Width = m_originalWidth;
       }
+
+      m_originalWidth = -1d;
     }
 
-    private void ShowDropMark( Point mousePosition )
+    internal void ShowDropMark( Point mousePosition )
     {
       if( m_dropMarkAdorner == null )
       {
-        DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
-        DataGridControl grid = ( dataGridContext != null )
-          ? dataGridContext.DataGridControl
-          : null;
+        var dataGridContext = this.DataGridContext;
+        var grid = ( dataGridContext != null ) ? dataGridContext.DataGridControl : null;
 
         Pen pen = UIViewBase.GetDropMarkPen( this );
 
@@ -513,20 +461,24 @@ namespace Xceed.Wpf.DataGrid
         AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer( this );
 
         if( adornerLayer != null )
+        {
           adornerLayer.Add( m_dropMarkAdorner );
+        }
       }
 
       m_dropMarkAdorner.UpdateAlignment( mousePosition );
     }
 
-    private void HideDropMark()
+    internal void HideDropMark()
     {
       if( m_dropMarkAdorner != null )
       {
         AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer( this );
 
         if( adornerLayer != null )
+        {
           adornerLayer.Remove( m_dropMarkAdorner );
+        }
 
         m_dropMarkAdorner = null;
       }
@@ -536,22 +488,22 @@ namespace Xceed.Wpf.DataGrid
     {
       if( m_columnResizerThumb != null )
       {
-        m_columnResizerThumb.DragStarted -= new DragStartedEventHandler( ColumnResizerThumb_DragStarted );
-        m_columnResizerThumb.DragDelta -= new DragDeltaEventHandler( ColumnResizerThumb_DragDelta );
-        m_columnResizerThumb.DragCompleted -= new DragCompletedEventHandler( ColumnResizerThumb_DragCompleted );
-        m_columnResizerThumb.QueryCursor -= new QueryCursorEventHandler( ColumnResizerThumb_QueryCursor );
-        m_columnResizerThumb.MouseDoubleClick -= new MouseButtonEventHandler( ColumnResizerThumb_MouseDoubleClick );
+        m_columnResizerThumb.DragStarted -= new DragStartedEventHandler( this.ColumnResizerThumb_DragStarted );
+        m_columnResizerThumb.DragDelta -= new DragDeltaEventHandler( this.ColumnResizerThumb_DragDelta );
+        m_columnResizerThumb.DragCompleted -= new DragCompletedEventHandler( this.ColumnResizerThumb_DragCompleted );
+        m_columnResizerThumb.QueryCursor -= new QueryCursorEventHandler( this.ColumnResizerThumb_QueryCursor );
+        m_columnResizerThumb.MouseDoubleClick -= new MouseButtonEventHandler( this.ColumnResizerThumb_MouseDoubleClick );
 
         m_columnResizerThumb = null;
       }
 
       if( m_columnResizerThumbLeft != null )
       {
-        m_columnResizerThumbLeft.DragStarted -= new DragStartedEventHandler( ColumnResizerThumbLeft_DragStarted );
-        m_columnResizerThumbLeft.DragDelta -= new DragDeltaEventHandler( ColumnResizerThumbLeft_DragDelta );
-        m_columnResizerThumbLeft.DragCompleted -= new DragCompletedEventHandler( ColumnResizerThumbLeft_DragCompleted );
-        m_columnResizerThumbLeft.QueryCursor -= new QueryCursorEventHandler( ColumnResizerThumbLeft_QueryCursor );
-        m_columnResizerThumbLeft.MouseDoubleClick -= new MouseButtonEventHandler( ColumnResizerThumbLeft_MouseDoubleClick );
+        m_columnResizerThumbLeft.DragStarted -= new DragStartedEventHandler( this.ColumnResizerThumbLeft_DragStarted );
+        m_columnResizerThumbLeft.DragDelta -= new DragDeltaEventHandler( this.ColumnResizerThumbLeft_DragDelta );
+        m_columnResizerThumbLeft.DragCompleted -= new DragCompletedEventHandler( this.ColumnResizerThumbLeft_DragCompleted );
+        m_columnResizerThumbLeft.QueryCursor -= new QueryCursorEventHandler( this.ColumnResizerThumbLeft_QueryCursor );
+        m_columnResizerThumbLeft.MouseDoubleClick -= new MouseButtonEventHandler( this.ColumnResizerThumbLeft_MouseDoubleClick );
 
         m_columnResizerThumbLeft = null;
       }
@@ -561,120 +513,157 @@ namespace Xceed.Wpf.DataGrid
 
       if( m_columnResizerThumb != null )
       {
-        m_columnResizerThumb.DragStarted += new DragStartedEventHandler( ColumnResizerThumb_DragStarted );
-        m_columnResizerThumb.DragDelta += new DragDeltaEventHandler( ColumnResizerThumb_DragDelta );
-        m_columnResizerThumb.DragCompleted += new DragCompletedEventHandler( ColumnResizerThumb_DragCompleted );
-        m_columnResizerThumb.QueryCursor += new QueryCursorEventHandler( ColumnResizerThumb_QueryCursor );
-        m_columnResizerThumb.MouseDoubleClick += new MouseButtonEventHandler( ColumnResizerThumb_MouseDoubleClick );
+        m_columnResizerThumb.DragStarted += new DragStartedEventHandler( this.ColumnResizerThumb_DragStarted );
+        m_columnResizerThumb.DragDelta += new DragDeltaEventHandler( this.ColumnResizerThumb_DragDelta );
+        m_columnResizerThumb.DragCompleted += new DragCompletedEventHandler( this.ColumnResizerThumb_DragCompleted );
+        m_columnResizerThumb.QueryCursor += new QueryCursorEventHandler( this.ColumnResizerThumb_QueryCursor );
+        m_columnResizerThumb.MouseDoubleClick += new MouseButtonEventHandler( this.ColumnResizerThumb_MouseDoubleClick );
       }
 
       if( m_columnResizerThumbLeft != null )
       {
-        m_columnResizerThumbLeft.DragStarted += new DragStartedEventHandler( ColumnResizerThumbLeft_DragStarted );
-        m_columnResizerThumbLeft.DragDelta += new DragDeltaEventHandler( ColumnResizerThumbLeft_DragDelta );
-        m_columnResizerThumbLeft.DragCompleted += new DragCompletedEventHandler( ColumnResizerThumbLeft_DragCompleted );
-        m_columnResizerThumbLeft.QueryCursor += new QueryCursorEventHandler( ColumnResizerThumbLeft_QueryCursor );
-        m_columnResizerThumbLeft.MouseDoubleClick += new MouseButtonEventHandler( ColumnResizerThumbLeft_MouseDoubleClick );
+        m_columnResizerThumbLeft.DragStarted += new DragStartedEventHandler( this.ColumnResizerThumbLeft_DragStarted );
+        m_columnResizerThumbLeft.DragDelta += new DragDeltaEventHandler( this.ColumnResizerThumbLeft_DragDelta );
+        m_columnResizerThumbLeft.DragCompleted += new DragCompletedEventHandler( this.ColumnResizerThumbLeft_DragCompleted );
+        m_columnResizerThumbLeft.QueryCursor += new QueryCursorEventHandler( this.ColumnResizerThumbLeft_QueryCursor );
+        m_columnResizerThumbLeft.MouseDoubleClick += new MouseButtonEventHandler( this.ColumnResizerThumbLeft_MouseDoubleClick );
       }
     }
 
-    private void ColumnResizerThumb_MouseDoubleClick( object sender, MouseButtonEventArgs e )
+    private void SetupDragManager()
     {
-      ColumnBase parentColumn = this.ParentColumn;
-
-      if( parentColumn == null )
+      var dataGridContext = this.DataGridContext;
+      // Can be null in design-time (edition of a style TargetType ColumnManagerCell).
+      if( dataGridContext == null )
         return;
 
-      e.Handled = true;
-
-      double fittedWidth = parentColumn.GetFittedWidth();
-
-      if( fittedWidth != -1 )
+      // We do not support DragDrop when there are no AdornerLayer because there wouldn't be any visual feedback for the operation.
+      AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer( this );
+      if( adornerLayer == null )
       {
-        parentColumn.Width = fittedWidth;
-      }
-    }
+        // When virtualizing, the Cell is not yet in the VisualTree because it is the ParentRow's CellsHost which
+        // is reponsible of putting them in the VisualTree. We try to get the adorner from the ParentRow instead
+        if( this.ParentRow != null )
+        {
+          adornerLayer = AdornerLayer.GetAdornerLayer( this.ParentRow );
+        }
 
-    private void ColumnResizerThumb_QueryCursor( object sender, QueryCursorEventArgs e )
-    {
-      ColumnBase parentColumn = this.ParentColumn;
+        if( adornerLayer == null )
+          return;
+      }
 
-      if( parentColumn == null )
+      var dataGridControl = dataGridContext.DataGridControl;
+      if( dataGridControl == null )
         return;
 
-      DataGridContext dataGridContext = this.DataGridContext;
-
-      bool showResizeCursor = !parentColumn.HasFixedWidth;
-
-      if( !showResizeCursor )
+      if( m_dragSourceManager != null )
       {
-        // Don't disable resizing if ColumnStretching can be disabled by an end-user resize.
-        showResizeCursor = ( dataGridContext != null ) && ( TableView.GetRemoveColumnStretchingOnResize( dataGridContext ) );
+        m_dragSourceManager.PropertyChanged -= this.DragSourceManager_PropertyChanged;
       }
 
-      if( showResizeCursor )
+      // The DataGridControl's AdornerDecoratorForDragAndDrop must be used for dragging in order to include the RenderTransform
+      // the DataGridControl may performs. This AdornerDecorator is defined in the ControlTemplate as PART_DragDropAdornerDecorator
+      if( ( dataGridControl.DragDropAdornerDecorator != null ) && ( dataGridControl.DragDropAdornerDecorator.AdornerLayer != null ) )
       {
-        if( dataGridContext != null )
-        {
-          UIViewBase uiViewBase = dataGridContext.DataGridControl.GetView() as UIViewBase;
+        m_dragSourceManager = new ColumnReorderingDragSourceManager( this, dataGridControl.DragDropAdornerDecorator.AdornerLayer, dataGridControl, this.ParentRow.LevelCache );
+      }
+      else
+      {
+        m_dragSourceManager = new ColumnReorderingDragSourceManager( this, null, dataGridControl, this.ParentRow.LevelCache );
+      }
 
-          e.Cursor = ( uiViewBase != null )
-            ? uiViewBase.ColumnResizeWestEastCursor
-            : UIViewBase.DefaultColumnResizeWestEastCursor;
-        }
-        else
-        {
-          e.Cursor = UIViewBase.DefaultColumnResizeWestEastCursor;
-        }
+      m_dragSourceManager.PropertyChanged += this.DragSourceManager_PropertyChanged;
 
-        e.Handled = true;
+      // Create bindings to ViewProperties for AutoScroll Properties
+      Binding binding = new Binding();
+      binding.Path = new PropertyPath( "(0).(1)", DataGridControl.DataGridContextProperty, TableView.AutoScrollIntervalProperty );
+      binding.Mode = BindingMode.OneWay;
+      binding.Source = this;
+      BindingOperations.SetBinding( m_dragSourceManager, DragSourceManager.AutoScrollIntervalProperty, binding );
+
+      binding = new Binding();
+      binding.Path = new PropertyPath( "(0).(1)", DataGridControl.DataGridContextProperty, TableView.AutoScrollTresholdProperty );
+      binding.Mode = BindingMode.OneWay;
+      binding.Source = this;
+      BindingOperations.SetBinding( m_dragSourceManager, DragSourceManager.AutoScrollTresholdProperty, binding );
+    }
+
+    private void DragSourceManager_PropertyChanged( object sender, PropertyChangedEventArgs e )
+    {
+      if( e.PropertyName == "IsDragging" )
+      {
+        this.SetIsBeingDragged( m_dragSourceManager.IsDragging );
       }
     }
 
     private void ColumnResizerThumb_DragStarted( object sender, DragStartedEventArgs e )
     {
-      ColumnBase parentColumn = this.ParentColumn;
+      if( !this.ShowResizeCursor || !this.AllowResize )
+        return;
 
-      if( parentColumn == null )
+      this.OnColumnResizerThumbDragStarted( e );
+    }
+
+    private void ColumnResizerThumb_DragDelta( object sender, DragDeltaEventArgs e )
+    {
+      if( !this.ShowResizeCursor || !this.AllowResize )
         return;
 
-      m_originalWidth = parentColumn.ActualWidth;
+      this.OnColumnResizerThumbDragDelta( e );
+    }
 
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
+    private void ColumnResizerThumb_DragCompleted( object sender, DragCompletedEventArgs e )
+    {
+      if( !this.ShowResizeCursor || !this.AllowResize )
+        return;
 
-      if( ( dataGridContext != null ) && ( TableView.GetRemoveColumnStretchingOnResize( dataGridContext ) ) )
-      {
-        dataGridContext.ColumnStretchingManager.DisableColumnStretching();
-      }
+      this.OnColumnResizerThumbDragCompleted( e );
     }
 
-    private void ColumnResizerThumb_DragDelta( object sender, DragDeltaEventArgs e )
+    private void ColumnResizerThumb_MouseDoubleClick( object sender, MouseButtonEventArgs e )
     {
-      ColumnBase parentColumn = this.ParentColumn;
+      var parentColumn = this.ParentColumn;
+      if( ( parentColumn == null ) || !this.ShowResizeCursor || !this.AllowResize )
+        return;
+
+      e.Handled = true;
 
-      if( parentColumn != null )
+      double fittedWidth = parentColumn.GetFittedWidth();
+      if( fittedWidth != -1 )
       {
-        this.DoResize( parentColumn.ActualWidth + e.HorizontalChange );
+        parentColumn.Width = fittedWidth;
       }
     }
 
-    private void ColumnResizerThumb_DragCompleted( object sender, DragCompletedEventArgs e )
+    private void ColumnResizerThumb_QueryCursor( object sender, QueryCursorEventArgs e )
     {
-      ColumnBase parentColumn = this.ParentColumn;
-
+      var parentColumn = this.ParentColumn;
       if( parentColumn == null )
         return;
 
-      if( e.Canceled || parentColumn.HasFixedWidth )
-        parentColumn.Width = m_originalWidth;
+      var dataGridContext = this.DataGridContext;
 
-      m_originalWidth = -1d;
+      bool showResizeCursor = false;
+      if( this.AllowResize )
+      {
+        // Don't disable resizing if ColumnStretching can be disabled by an end-user resize.
+        showResizeCursor = ( !parentColumn.HasFixedWidth )
+                        || ( ( dataGridContext != null ) && TableView.GetRemoveColumnStretchingOnResize( dataGridContext ) );
+      }
+
+      this.ShowResizeCursor = showResizeCursor;
+      if( this.ShowResizeCursor )
+      {
+        UIViewBase viewBase = ( dataGridContext != null ) ? dataGridContext.DataGridControl.GetView() as UIViewBase : null;
+
+        e.Cursor = ( viewBase != null ) ? viewBase.ColumnResizeWestEastCursor : UIViewBase.DefaultColumnResizeWestEastCursor;
+        e.Handled = true;
+      }
     }
 
     private ColumnManagerCell GetPreviousVisibleColumnManagerCell()
     {
       var previousVisibleColumn = this.ParentColumn.PreviousVisibleColumn;
-
       if( previousVisibleColumn == null )
         return null;
 
@@ -684,69 +673,119 @@ namespace Xceed.Wpf.DataGrid
     private void ColumnResizerThumbLeft_QueryCursor( object sender, QueryCursorEventArgs e )
     {
       var previousColumnManagerCell = this.GetPreviousVisibleColumnManagerCell();
+      if( previousColumnManagerCell == null )
+        return;
 
-      if( previousColumnManagerCell != null )
-        previousColumnManagerCell.ColumnResizerThumb_QueryCursor( previousColumnManagerCell, e );
+      previousColumnManagerCell.ColumnResizerThumb_QueryCursor( previousColumnManagerCell, e );
     }
 
     private void ColumnResizerThumbLeft_DragStarted( object sender, DragStartedEventArgs e )
     {
       var previousColumnManagerCell = this.GetPreviousVisibleColumnManagerCell();
+      if( previousColumnManagerCell == null )
+        return;
 
-      if( previousColumnManagerCell != null )
-        previousColumnManagerCell.ColumnResizerThumb_DragStarted( previousColumnManagerCell, e );
+      previousColumnManagerCell.ColumnResizerThumb_DragStarted( previousColumnManagerCell, e );
     }
 
     private void ColumnResizerThumbLeft_MouseDoubleClick( object sender, MouseButtonEventArgs e )
     {
       var previousColumnManagerCell = this.GetPreviousVisibleColumnManagerCell();
+      if( previousColumnManagerCell == null )
+        return;
 
-      if( previousColumnManagerCell != null )
-        previousColumnManagerCell.ColumnResizerThumb_MouseDoubleClick( previousColumnManagerCell, e );
+      previousColumnManagerCell.ColumnResizerThumb_MouseDoubleClick( previousColumnManagerCell, e );
     }
 
     private void ColumnResizerThumbLeft_DragDelta( object sender, DragDeltaEventArgs e )
     {
       var previousColumnManagerCell = this.GetPreviousVisibleColumnManagerCell();
+      if( previousColumnManagerCell == null )
+        return;
 
-      if( previousColumnManagerCell != null )
-        previousColumnManagerCell.ColumnResizerThumb_DragDelta( previousColumnManagerCell, e );
+      previousColumnManagerCell.ColumnResizerThumb_DragDelta( previousColumnManagerCell, e );
     }
 
     private void ColumnResizerThumbLeft_DragCompleted( object sender, DragCompletedEventArgs e )
     {
       var previousColumnManagerCell = this.GetPreviousVisibleColumnManagerCell();
+      if( previousColumnManagerCell == null )
+        return;
+
+      previousColumnManagerCell.ColumnResizerThumb_DragCompleted( previousColumnManagerCell, e );
+    }
+
+    private void SetColumnBinding( DependencyProperty targetProperty, ColumnBase parentColumn, DependencyProperty sourceProperty )
+    {
+      if( this.HasColumnBinding( targetProperty, parentColumn, sourceProperty ) )
+        return;
+
+      var binding = ColumnManagerCell.CreateColumnBinding( parentColumn, sourceProperty );
+      if( binding != null )
+      {
+        BindingOperations.SetBinding( this, targetProperty, binding );
+      }
+      else
+      {
+        BindingOperations.ClearBinding( this, targetProperty );
+      }
+    }
+
+    private bool HasColumnBinding( DependencyProperty targetProperty, ColumnBase parentColumn, DependencyProperty sourceProperty )
+    {
+      if( parentColumn == null )
+        return false;
+
+      var binding = BindingOperations.GetBinding( this, targetProperty );
+      if( binding == null )
+        return false;
+
+      var path = binding.Path;
+      if( path == null )
+        return false;
+
+      var pathParameters = path.PathParameters;
 
-      if( previousColumnManagerCell != null )
-        previousColumnManagerCell.ColumnResizerThumb_DragCompleted( previousColumnManagerCell, e );
+      return ( binding.Source == parentColumn )
+          && ( pathParameters.Count == 1 )
+          && ( pathParameters[ 0 ] == sourceProperty );
+    }
+
+    private static Binding CreateColumnBinding( ColumnBase parentColumn, DependencyProperty sourceProperty )
+    {
+      if( parentColumn == null )
+        return null;
+
+      var binding = new Binding();
+      binding.Path = new PropertyPath( sourceProperty );
+      binding.Mode = BindingMode.OneWay;
+      binding.Source = parentColumn;
+      binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
+
+      return binding;
     }
 
     #region IDropTarget Members
 
     bool IDropTarget.CanDropElement( UIElement draggedElement )
     {
-      bool allowColumnReorder = true;
+      ColumnManagerCell draggedCell = draggedElement as ColumnManagerCell;
+      if( ( draggedCell == null ) || ( this == draggedCell ) )
+        return false;
+
       ColumnManagerRow parentRow = this.ParentRow as ColumnManagerRow;
+      if( ( parentRow == null ) || !parentRow.AllowColumnReorder )
+        return false;
 
-      if( parentRow != null )
-        allowColumnReorder = parentRow.AllowColumnReorder;
+      if( !ColumnManagerCell.CanMove( draggedCell ) || !ColumnManagerCell.CanMove( this ) )
+        return false;
 
+      DataGridContext draggedDetailContext = draggedCell.DataGridContext;
       DataGridContext sourceDetailContext = this.DataGridContext;
-      Debug.Assert( sourceDetailContext != null );
-      DetailConfiguration sourceDetailConfig = ( sourceDetailContext != null ) ? sourceDetailContext.SourceDetailConfiguration : null;
-
-      DataGridContext draggedDetailContext = DataGridControl.GetDataGridContext( draggedElement );
-      Debug.Assert( draggedDetailContext != null );
-      DetailConfiguration draggedDetailConfig = ( draggedDetailContext != null ) ? draggedDetailContext.SourceDetailConfiguration : null;
+      Debug.Assert( ( draggedDetailContext != null ) && ( sourceDetailContext != null ) );
 
-
-      return ( ( sourceDetailConfig == draggedDetailConfig ) &&
-             ( sourceDetailContext != null ) &&
-             ( draggedDetailContext != null ) &&
-             ( sourceDetailContext.GroupLevelDescriptions == draggedDetailContext.GroupLevelDescriptions ) &&
-             ( allowColumnReorder ) &&
-             ( draggedElement is ColumnManagerCell ) &&
-             ( draggedElement != this ) );
+      return ( sourceDetailContext.SourceDetailConfiguration == draggedDetailContext.SourceDetailConfiguration ) &&
+             ( sourceDetailContext.GroupLevelDescriptions == draggedDetailContext.GroupLevelDescriptions );
     }
 
     void IDropTarget.DragEnter( UIElement draggedElement )
@@ -759,8 +798,7 @@ namespace Xceed.Wpf.DataGrid
 
       if( draggedCell != null )
       {
-        ColumnReorderingDragSourceManager manager =
-          draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
+        ColumnReorderingDragSourceManager manager = draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
 
         // No need for drop mark when performing animated Column reordering
         if( ( manager != null ) && ( manager.IsAnimatedColumnReorderingEnabled ) )
@@ -776,8 +814,7 @@ namespace Xceed.Wpf.DataGrid
 
       if( draggedCell != null )
       {
-        ColumnReorderingDragSourceManager manager =
-          draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
+        ColumnReorderingDragSourceManager manager = draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
 
         // No need for drop mark when performing animated Column reordering
         if( ( manager != null ) && ( manager.IsAnimatedColumnReorderingEnabled ) )
@@ -794,6 +831,11 @@ namespace Xceed.Wpf.DataGrid
       if( draggedCell == null )
         return;
 
+      this.ProcessDrop( draggedCell );
+    }
+
+    internal void ProcessDrop( ColumnManagerCell draggedCell )
+    {
       ColumnReorderingDragSourceManager manager = null;
 
       if( draggedCell != null )
@@ -816,15 +858,6 @@ namespace Xceed.Wpf.DataGrid
 
           this.HideDropMark();
 
-          // This will force every Rows to update there layout
-
-          ColumnReorderingEventArgs e = new ColumnReorderingEventArgs(
-                    ColumnManagerCell.ColumnReorderingEvent,
-                    oldPosition,
-                    newPosition );
-
-          this.RaiseEvent( e );
-
           if( draggedCell.ParentColumn.VisiblePosition < newPosition )
           {
             if( alignment == DropMarkAlignment.Near )
@@ -847,14 +880,45 @@ namespace Xceed.Wpf.DataGrid
               draggedCell.ParentColumn.VisiblePosition = newPosition + 1;
             }
           }
+
+          // This will force every Rows to update there layout
+          ColumnReorderingEventArgs e = new ColumnReorderingEventArgs( ColumnManagerCell.ColumnReorderingEvent, oldPosition, newPosition );
+          this.RaiseEvent( e );
+
         }
       }
     }
 
+    private static bool CanMove( ColumnManagerCell cell )
+    {
+      if( cell == null )
+        return false;
+
+      var dataGridContext = cell.DataGridContext;
+      if( dataGridContext == null )
+        return false;
+
+      if( dataGridContext.AreDetailsFlatten )
+      {
+        // Column reordering is not allowed for a ColumnManagerCell that is located at a detail level
+        // when details are flatten.
+        if( dataGridContext.SourceDetailConfiguration != null )
+          return false;
+
+        // The main column is not allowed to be reordered when details are flatten.
+        var parentColumn = cell.ParentColumn;
+        if( ( parentColumn == null ) || ( parentColumn.IsMainColumn ) )
+          return false;
+      }
+
+      return true;
+    }
+
     #endregion IDropTarget Members
 
     // Will remain null when no AdornerLayer is found.
     private ColumnReorderingDragSourceManager m_dragSourceManager;
+
     private DropMarkAdorner m_dropMarkAdorner;
 
     private DataGridContext m_dataGridContext; // = null;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerRow.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerRow.cs
index 0766e5ee..210dcf62 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerRow.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnManagerRow.cs
@@ -14,12 +14,13 @@
 
   ***********************************************************************************/
 
+using System.Collections;
+using System.Diagnostics;
 using System.Windows;
-using Xceed.Wpf.DataGrid.Views;
 using System.Windows.Automation.Peers;
 using Xceed.Wpf.DataGrid.Automation;
+using Xceed.Wpf.DataGrid.Views;
 using Xceed.Utils.Wpf.DragDrop;
-using System.Diagnostics;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -36,7 +37,7 @@ namespace Xceed.Wpf.DataGrid
       this.ReadOnly = true; //This is safe to perform since there is nowhere a callback installed on the DP... 
 
       //ensure that all ColumnManagerRows are not navigable
-      this.NavigationBehavior = NavigationBehavior.None; //This is safe to perform since there is nowhere a callback installed on the DP... 
+      this.NavigationBehavior = NavigationBehavior.None; //This is safe to perform since there is nowhere a callback installed on the DP...
     }
 
     #region AllowColumnReorder Property
@@ -138,20 +139,17 @@ namespace Xceed.Wpf.DataGrid
       if( draggedCell == null )
         return false;
 
-      ColumnReorderingDragSourceManager manager =
-        draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
+      ColumnReorderingDragSourceManager manager = draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
 
       if( ( manager != null ) && ( manager.IsAnimatedColumnReorderingEnabled ) )
       {
         ColumnManagerCell cell = draggedElement as ColumnManagerCell;
 
-        if( ( cell != null )
-            && ( cell.IsBeingDragged ) )
+        if( ( cell != null ) && ( cell.IsBeingDragged ) )
         {
           DataGridContext rowDataGridContext = DataGridControl.GetDataGridContext( this );
 
-          if( ( rowDataGridContext != null )
-              && ( rowDataGridContext.Columns.Contains( cell.ParentColumn ) ) )
+          if( ( rowDataGridContext != null ) && ( rowDataGridContext.Columns.Contains( cell.ParentColumn ) ) )
           {
             canDrop = true;
           }
@@ -180,8 +178,7 @@ namespace Xceed.Wpf.DataGrid
       if( draggedCell == null )
         return;
 
-      ColumnReorderingDragSourceManager manager =
-        draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
+      ColumnReorderingDragSourceManager manager = draggedCell.DragSourceManager as ColumnReorderingDragSourceManager;
 
       if( ( manager != null ) && ( manager.IsAnimatedColumnReorderingEnabled ) )
       {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnReorderingEvent.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnReorderingEvent.cs
index dae9779d..9d9b1189 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnReorderingEvent.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnReorderingEvent.cs
@@ -17,7 +17,6 @@
 using System;
 using System.Windows;
 
-// TODO (case 117282) : Renommer ce fichier.
 namespace Xceed.Wpf.DataGrid
 {
   internal delegate void ColumnReorderingEventHandler( object sender, ColumnReorderingEventArgs e );
@@ -26,12 +25,12 @@ namespace Xceed.Wpf.DataGrid
   {
     #region Constructors
 
-    public ColumnReorderingEventArgs(RoutedEvent routedEvent, int oldVisiblePosition, int newVisiblePosition )
+    public ColumnReorderingEventArgs( RoutedEvent routedEvent, int oldVisiblePosition, int newVisiblePosition )
       : base( routedEvent )
     {
       m_oldVisiblePosition = oldVisiblePosition;
       m_newVisiblePosition = newVisiblePosition;
-    } 
+    }
 
     #endregion
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSortCommand.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSortCommand.cs
new file mode 100644
index 00000000..10ebae03
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSortCommand.cs
@@ -0,0 +1,261 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Windows.Data;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class ColumnSortCommand : ColumnCommand
+  {
+    protected SynchronizationContext StartSynchronizing( SortDescriptionsSyncContext context )
+    {
+      return new SynchronizationContext( context );
+    }
+
+    protected bool TryDeferResort( DetailConfiguration detailConfiguration, out IDisposable defer )
+    {
+      defer = null;
+
+      return ( detailConfiguration != null )
+          && ( this.TryDeferResort( detailConfiguration.SortDescriptions, out defer ) );
+    }
+
+    protected bool TryDeferResort( SortDescriptionCollection sortDescriptions, out IDisposable defer )
+    {
+      var dataGridSortDescriptions = sortDescriptions as DataGridSortDescriptionCollection;
+      if( dataGridSortDescriptions != null )
+      {
+        defer = dataGridSortDescriptions.DeferResort();
+      }
+      else
+      {
+        defer = null;
+      }
+
+      return ( defer != null );
+    }
+
+    protected IDisposable DeferResortHelper(
+      IEnumerable itemsSourceCollection,
+      CollectionView collectionView )
+    {
+      var dataGridCollectionView = itemsSourceCollection as DataGridCollectionViewBase;
+      if( dataGridCollectionView != null )
+        return dataGridCollectionView.DataGridSortDescriptions.DeferResort();
+
+      ColumnSortCommand.ThrowIfNull( collectionView, "collectionView" );
+
+      return collectionView.DeferRefresh();
+    }
+
+    #region SynchronizationContext Protected Class
+
+    protected sealed class SynchronizationContext : IDisposable
+    {
+      #region Constructor
+
+      internal SynchronizationContext( SortDescriptionsSyncContext context )
+      {
+        if( context == null )
+          throw new ArgumentNullException( "context" );
+
+        m_context = context;
+        m_isOwner = !context.ProcessingSortSynchronization;
+
+        context.ProcessingSortSynchronization = true;
+      }
+
+      #endregion
+
+      #region Own Property
+
+      public bool Own
+      {
+        get
+        {
+          var context = m_context;
+
+          return ( m_isOwner )
+              && ( context != null )
+              && ( context.ProcessingSortSynchronization );
+        }
+      }
+
+      #endregion
+
+      #region IDisposable Members
+
+      public void Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var context = m_context;
+        if( context == null )
+          return;
+
+        m_context = null;
+
+        if( m_isOwner )
+        {
+          context.ProcessingSortSynchronization = false;
+        }
+      }
+
+      ~SynchronizationContext()
+      {
+        this.Dispose( false );
+      }
+
+      #endregion
+
+      #region Private Fields
+
+      private SortDescriptionsSyncContext m_context;
+      private bool m_isOwner;
+
+      #endregion
+    }
+
+    #endregion
+
+    #region Disposer Protected Class
+
+    protected sealed class Disposer : IDisposable
+    {
+      #region Constants
+
+      private static readonly int DisposableTypeCount = Enum.GetValues( typeof( DisposableType ) ).Length;
+
+      #endregion
+
+      public Disposer()
+      {
+        m_disposable = new Stack<IDisposable>[ Disposer.DisposableTypeCount ];
+      }
+
+      public void Add( IDisposable disposable, DisposableType disposableType )
+      {
+        if( m_disposed )
+          throw new ObjectDisposedException( "Disposer" );
+
+        if( !Enum.IsDefined( typeof( DisposableType ), disposableType ) )
+          throw new ArgumentException( "disposableType" );
+
+        if( disposable == null )
+          return;
+
+        int index = Disposer.GetIndex( disposableType );
+        var collection = m_disposable[ index ];
+
+        if( collection == null )
+        {
+          collection = new Stack<IDisposable>();
+          m_disposable[ index ] = collection;
+        }
+
+        collection.Push( disposable );
+      }
+
+      private static int GetIndex( DisposableType value )
+      {
+        int index = System.Convert.ToInt32( value );
+        Debug.Assert( ( index >= 0 ) && ( index < Disposer.DisposableTypeCount ) );
+
+        return index;
+      }
+
+      #region IDisposable Members
+
+      public void Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        if( m_disposed )
+          return;
+
+        m_disposed = true;
+
+        Exception exception = null;
+
+        for( int i = m_disposable.Length - 1; i >= 0; i-- )
+        {
+          var disposable = m_disposable[ i ];
+          if( disposable == null )
+            continue;
+
+          while( disposable.Count > 0 )
+          {
+            try
+            {
+              disposable.Pop().Dispose();
+            }
+            catch( Exception e )
+            {
+              if( exception == null )
+              {
+                exception = e;
+              }
+            }
+          }
+
+          m_disposable[ i ] = null;
+        }
+
+        if( exception != null )
+          throw new DataGridInternalException( exception );
+      }
+
+      ~Disposer()
+      {
+        this.Dispose( false );
+      }
+
+      #endregion
+
+      #region Private Fields
+
+      private readonly Stack<IDisposable>[] m_disposable;
+      private bool m_disposed;
+
+      #endregion
+    }
+
+    #endregion
+
+    #region DisposableType Protected Nested Type
+
+    protected enum DisposableType
+    {
+      DeferRestoreState = 0,
+      DeferResort = 1,
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSynchronizationManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSynchronizationManager.cs
new file mode 100644
index 00000000..69198547
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ColumnSynchronizationManager.cs
@@ -0,0 +1,1097 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Windows;
+using System.Windows.Data;
+using Xceed.Wpf.DataGrid.Views;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ColumnSynchronizationManager : IWeakEventListener
+  {
+    #region Static Fields
+
+    private static readonly string DetailConfigurationDataGridControlPropertyName = "DataGridControl";
+    private static readonly string DetailConfigurationIsAttachedToDetailDescriptionPropertyName = "IsAttachedToDetailDescription";
+    private static readonly string ColumnCollectionMainColumnPropertyName = "MainColumn";
+
+    #endregion
+
+    #region Constructor
+
+    internal ColumnSynchronizationManager( DetailConfiguration configuration )
+    {
+      if( configuration == null )
+        throw new ArgumentNullException( "configuration" );
+
+      m_detailConfiguration = configuration;
+      m_itemPropertyMap = configuration.ItemPropertyMap;
+
+      PropertyChangedEventManager.AddListener( configuration, this, ColumnSynchronizationManager.DetailConfigurationDataGridControlPropertyName );
+      PropertyChangedEventManager.AddListener( configuration, this, ColumnSynchronizationManager.DetailConfigurationIsAttachedToDetailDescriptionPropertyName );
+      CollectionChangedEventManager.AddListener( ( INotifyCollectionChanged )m_itemPropertyMap, this );
+
+      using( this.DeferSynchronization() )
+      {
+        this.DataGridControl = configuration.DataGridControl;
+        this.DetailColumns = configuration.Columns;
+
+        Debug.Assert( this.DetailColumns != null );
+      }
+    }
+
+    #endregion
+
+    #region DetailConfiguration Private Property
+
+    private DetailConfiguration DetailConfiguration
+    {
+      get
+      {
+        return m_detailConfiguration;
+      }
+    }
+
+    private readonly DetailConfiguration m_detailConfiguration;
+
+    #endregion
+
+    #region DataGridControl Private Property
+
+    private DataGridControl DataGridControl
+    {
+      get
+      {
+        return m_dataGridControl;
+      }
+      set
+      {
+        if( value == m_dataGridControl )
+          return;
+
+        using( this.DeferSynchronization() )
+        {
+          if( m_dataGridControl != null )
+          {
+            ViewChangedEventManager.RemoveListener( m_dataGridControl, this );
+          }
+
+          m_dataGridControl = value;
+
+          if( m_dataGridControl != null )
+          {
+            ViewChangedEventManager.AddListener( m_dataGridControl, this );
+
+            this.MasterColumns = m_dataGridControl.Columns;
+          }
+          else
+          {
+            this.MasterColumns = null;
+          }
+
+          this.InvalidateSynchronization();
+        }
+      }
+    }
+
+    private DataGridControl m_dataGridControl;
+
+    #endregion
+
+    #region ItemPropertyMap Private Property
+
+    private FieldNameMap ItemPropertyMap
+    {
+      get
+      {
+        return m_itemPropertyMap;
+      }
+    }
+
+    private readonly FieldNameMap m_itemPropertyMap;
+
+    #endregion
+
+    #region MasterColumns Private Property
+
+    private ColumnCollection MasterColumns
+    {
+      get
+      {
+        return m_masterColumns;
+      }
+      set
+      {
+        if( value == m_masterColumns )
+          return;
+
+        if( m_masterColumns != null )
+        {
+          CollectionChangedEventManager.RemoveListener( m_masterColumns, this );
+          PropertyChangedEventManager.RemoveListener( m_masterColumns, this, ColumnSynchronizationManager.ColumnCollectionMainColumnPropertyName );
+          VisibleColumnsUpdatedEventManager.RemoveListener( m_masterColumns, this );
+        }
+
+        m_masterColumns = value;
+
+        if( m_masterColumns != null )
+        {
+          CollectionChangedEventManager.AddListener( m_masterColumns, this );
+          PropertyChangedEventManager.AddListener( m_masterColumns, this, ColumnSynchronizationManager.ColumnCollectionMainColumnPropertyName );
+          VisibleColumnsUpdatedEventManager.AddListener( m_masterColumns, this );
+        }
+      }
+    }
+
+    private ColumnCollection m_masterColumns;
+
+    #endregion
+
+    #region DetailColumns Private Property
+
+    private ColumnCollection DetailColumns
+    {
+      get
+      {
+        return m_detailColumns;
+      }
+      set
+      {
+        if( value == m_detailColumns )
+          return;
+
+        if( m_detailColumns != null )
+        {
+          CollectionChangedEventManager.RemoveListener( m_detailColumns, this );
+          VisibleColumnsUpdatedEventManager.RemoveListener( m_detailColumns, this );
+        }
+
+        m_detailColumns = value;
+
+        if( m_detailColumns != null )
+        {
+          CollectionChangedEventManager.AddListener( m_detailColumns, this );
+          VisibleColumnsUpdatedEventManager.AddListener( m_detailColumns, this );
+        }
+      }
+    }
+
+    private ColumnCollection m_detailColumns;
+
+    #endregion
+
+    #region PairedColumns Private Property
+
+    private Dictionary<SynchronizationKey, SynchronizationEntry> PairedColumns
+    {
+      get
+      {
+        return m_pairedColumns;
+      }
+    }
+
+    private readonly Dictionary<SynchronizationKey, SynchronizationEntry> m_pairedColumns = new Dictionary<SynchronizationKey, SynchronizationEntry>( 0 );
+
+    #endregion
+
+    #region IsSynchronizationReady Private Property
+
+    private bool IsSynchronizationReady
+    {
+      get
+      {
+        return ( this.MasterColumns != null )
+            && ( this.DetailConfiguration.IsAttachedToDetailDescription );
+      }
+    }
+
+    #endregion
+
+    #region IsUpdatingColumns Private Property
+
+    private bool IsUpdatingColumns
+    {
+      get
+      {
+        return m_isUpdatingColumns;
+      }
+    }
+
+    private bool m_isUpdatingColumns;
+
+    #endregion
+
+    #region AreDetailsFlatten Private Property
+
+    private bool AreDetailsFlatten
+    {
+      get
+      {
+        var dataGridControl = this.DataGridControl;
+
+        return ( dataGridControl != null )
+            && ( dataGridControl.AreDetailsFlatten );
+      }
+    }
+
+    #endregion
+
+    #region DeferSynchronization Methods
+
+    private IDisposable DeferSynchronization()
+    {
+      return new DeferSynchronizationHelper( this );
+    }
+
+    private bool IsSynchronizationDefered
+    {
+      get
+      {
+        return ( Interlocked.CompareExchange( ref m_deferSynchronizationCount, 0, 0 ) != 0 );
+      }
+    }
+
+    private bool IsSynchronizationValid
+    {
+      get
+      {
+        return m_isSynchronizationValid;
+      }
+    }
+
+    private void InvalidateSynchronization()
+    {
+      m_isSynchronizationValid = false;
+    }
+
+    private int m_deferSynchronizationCount; //0
+    private bool m_isSynchronizationValid = true;
+
+    #endregion
+
+    private void Refresh()
+    {
+      if( this.IsUpdatingColumns )
+        return;
+
+      this.InvalidateSynchronization();
+      this.UpdateColumns();
+    }
+
+    private void UpdateColumns()
+    {
+      if( this.IsSynchronizationDefered || this.IsSynchronizationValid || this.IsUpdatingColumns )
+        return;
+
+      try
+      {
+        m_isUpdatingColumns = true;
+        m_isSynchronizationValid = true;
+
+        if( this.IsSynchronizationReady && this.AreDetailsFlatten )
+        {
+          var keys = new HashSet<SynchronizationKey>( this.GetNewKeys() );
+
+          foreach( var key in this.PairedColumns.Keys.Except( keys ).ToArray() )
+          {
+            this.Desynchronize( key );
+          }
+
+          foreach( var key in keys.OrderBy( item => item.OrderKey ) )
+          {
+            this.Synchronize( key );
+          }
+
+          this.SetMainColumn();
+        }
+        else
+        {
+          this.Desynchronize();
+        }
+      }
+      finally
+      {
+        m_isUpdatingColumns = false;
+      }
+    }
+
+    private void Synchronize( SynchronizationKey key )
+    {
+      if( key == null )
+        return;
+
+      var collection = this.PairedColumns;
+
+      SynchronizationEntry pair;
+      if( !collection.TryGetValue( key, out pair ) )
+      {
+        if( key.MasterColumn != null )
+        {
+          pair = new BoundColumn( key );
+        }
+        else
+        {
+          pair = new UnboundColumn( key );
+        }
+
+        collection.Add( key, pair );
+      }
+
+      pair.Synchronize();
+    }
+
+    private void Desynchronize( SynchronizationKey key )
+    {
+      if( key == null )
+        return;
+
+      var collection = this.PairedColumns;
+
+      SynchronizationEntry pair;
+      if( !collection.TryGetValue( key, out pair ) )
+        return;
+
+      collection.Remove( key );
+      pair.Desynchronize();
+    }
+
+    private void Desynchronize()
+    {
+      var collection = this.PairedColumns;
+      while( collection.Count > 0 )
+      {
+        this.Desynchronize( collection.First().Key );
+      }
+    }
+
+    private void SetMainColumn()
+    {
+      if( !this.IsSynchronizationReady || !this.AreDetailsFlatten )
+        return;
+
+      var detailColumns = this.DetailColumns;
+      ColumnBase detailColumn = null;
+
+      var mainColumn = this.MasterColumns.MainColumn;
+      if( mainColumn != null )
+      {
+        string targetName;
+        if( this.ItemPropertyMap.TryGetItemPropertyName( mainColumn, out targetName ) )
+        {
+          detailColumn = detailColumns[ targetName ];
+        }
+      }
+
+      detailColumns.MainColumn = detailColumn;
+    }
+
+    private IEnumerable<SynchronizationKey> GetNewKeys()
+    {
+      var detailConfig = this.DetailConfiguration;
+      var map = this.ItemPropertyMap;
+
+      foreach( var detailColumn in this.DetailColumns )
+      {
+        ColumnBase masterColumn;
+        string targetName;
+
+        if( map.TryGetColumnFieldName( detailColumn, out targetName ) )
+        {
+          masterColumn = this.MasterColumns[ targetName ];
+        }
+        else
+        {
+          masterColumn = null;
+        }
+
+        yield return new SynchronizationKey( masterColumn, detailColumn, detailConfig );
+      }
+    }
+
+    private void OnViewChanged()
+    {
+      this.Refresh();
+    }
+
+    private void OnUserSettingsLoaded()
+    {
+      this.Refresh();
+    }
+
+    private void OnMasterColumnsPropertyChanged( PropertyChangedEventArgs e )
+    {
+      var propertyName = e.PropertyName;
+      bool mayHaveChanged = string.IsNullOrEmpty( propertyName );
+
+      if( mayHaveChanged || ( propertyName == ColumnSynchronizationManager.ColumnCollectionMainColumnPropertyName ) )
+      {
+        this.SetMainColumn();
+      }
+    }
+
+    private void OnDetailConfigurationPropertyChanged( PropertyChangedEventArgs e )
+    {
+      var propertyName = e.PropertyName;
+      bool mayHaveChanged = string.IsNullOrEmpty( propertyName );
+
+      if( mayHaveChanged || ( propertyName == ColumnSynchronizationManager.DetailConfigurationDataGridControlPropertyName ) )
+      {
+        this.DataGridControl = this.DetailConfiguration.DataGridControl;
+      }
+
+      if( mayHaveChanged || ( propertyName == ColumnSynchronizationManager.DetailConfigurationIsAttachedToDetailDescriptionPropertyName ) )
+      {
+        this.Refresh();
+      }
+    }
+
+    private void OnItemPropertyMapCollectionChanged( NotifyCollectionChangedEventArgs e )
+    {
+      if( e.Action == NotifyCollectionChangedAction.Move )
+        return;
+
+      this.Refresh();
+    }
+
+    private void OnMasterColumnsCollectionChanged( NotifyCollectionChangedEventArgs e )
+    {
+      if( e.Action == NotifyCollectionChangedAction.Move )
+        return;
+
+      this.Refresh();
+    }
+
+    private void OnDetailColumnsCollectionChanged( NotifyCollectionChangedEventArgs e )
+    {
+      if( e.Action == NotifyCollectionChangedAction.Move )
+        return;
+
+      this.Refresh();
+    }
+
+    private void OnMasterVisibleColumnsUpdated( EventArgs e )
+    {
+      this.Refresh();
+    }
+
+    private void OnDetailVisibleColumnsUpdated( EventArgs e )
+    {
+      this.Refresh();
+    }
+
+    #region IWeakEventListener Members
+
+    bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      if( managerType == typeof( CollectionChangedEventManager ) )
+      {
+        if( sender == this.MasterColumns )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnMasterColumnsCollectionChanged( ( NotifyCollectionChangedEventArgs )e );
+        }
+        else if( sender == this.DetailColumns )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnDetailColumnsCollectionChanged( ( NotifyCollectionChangedEventArgs )e );
+        }
+        else if( sender == this.ItemPropertyMap )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnItemPropertyMapCollectionChanged( ( NotifyCollectionChangedEventArgs )e );
+        }
+
+        return true;
+      }
+      else if( managerType == typeof( PropertyChangedEventManager ) )
+      {
+        if( sender == this.MasterColumns )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnMasterColumnsPropertyChanged( ( PropertyChangedEventArgs )e );
+        }
+        else if( sender == this.DetailConfiguration )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnDetailConfigurationPropertyChanged( ( PropertyChangedEventArgs )e );
+        }
+
+        return true;
+      }
+      else if( managerType == typeof( VisibleColumnsUpdatedEventManager ) )
+      {
+        if( sender == this.MasterColumns )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnMasterVisibleColumnsUpdated( e );
+        }
+        else if( sender == this.DetailColumns )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnDetailVisibleColumnsUpdated( e );
+        }
+
+        return true;
+      }
+      else if( managerType == typeof( ViewChangedEventManager ) )
+      {
+        if( sender == this.DataGridControl )
+        {
+          Debug.Assert( sender != null );
+
+          this.OnViewChanged();
+        }
+
+        return true;
+      }
+
+      return false;
+    }
+
+    #endregion
+
+    #region DeferSynchronizationHelper Private Class
+
+    private sealed class DeferSynchronizationHelper : IDisposable
+    {
+      internal DeferSynchronizationHelper( ColumnSynchronizationManager owner )
+      {
+        if( owner == null )
+          throw new ArgumentNullException( "owner" );
+
+        m_owner = owner;
+
+        Interlocked.Increment( ref owner.m_deferSynchronizationCount );
+      }
+
+      void IDisposable.Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        Debug.Assert( disposing );
+
+        var owner = m_owner;
+        if( Interlocked.CompareExchange<ColumnSynchronizationManager>( ref m_owner, null, owner ) == null )
+          return;
+
+        if( Interlocked.Decrement( ref owner.m_deferSynchronizationCount ) != 0 )
+          return;
+
+        owner.UpdateColumns();
+      }
+
+      ~DeferSynchronizationHelper()
+      {
+        this.Dispose( false );
+      }
+
+      #region Private Fields
+
+      private ColumnSynchronizationManager m_owner;
+
+      #endregion
+    }
+
+    #endregion
+
+    #region SynchronizationKey Private Class
+
+    private sealed class SynchronizationKey
+    {
+      internal SynchronizationKey(
+        ColumnBase masterColumn,
+        ColumnBase detailColumn,
+        DetailConfiguration detailConfig )
+      {
+        if( detailColumn == null )
+          throw new ArgumentNullException( "detailColumn" );
+
+        if( detailConfig == null )
+          throw new ArgumentNullException( "detailConfig" );
+
+        m_masterColumn = masterColumn;
+        m_detailColumn = detailColumn;
+        m_detailConfiguration = detailConfig;
+      }
+
+      #region MasterColumn Property
+
+      internal ColumnBase MasterColumn
+      {
+        get
+        {
+          return m_masterColumn;
+        }
+      }
+
+      private readonly ColumnBase m_masterColumn;
+
+      #endregion
+
+      #region DetailColumn Property
+
+      internal ColumnBase DetailColumn
+      {
+        get
+        {
+          return m_detailColumn;
+        }
+      }
+
+      private readonly ColumnBase m_detailColumn;
+
+      #endregion
+
+      #region DetailConfiguration Property
+
+      internal DetailConfiguration DetailConfiguration
+      {
+        get
+        {
+          return m_detailConfiguration;
+        }
+      }
+
+      private readonly DetailConfiguration m_detailConfiguration;
+
+      #endregion
+
+      #region OrderKey Property
+
+      internal int OrderKey
+      {
+        get
+        {
+          var column = this.MasterColumn;
+          if( column != null )
+            return column.VisiblePosition;
+
+          return int.MaxValue;
+        }
+      }
+
+      #endregion
+
+      public override int GetHashCode()
+      {
+        if( m_masterColumn == null )
+          return m_detailColumn.GetHashCode();
+
+        return ( m_masterColumn.GetHashCode() )
+             ^ ( m_detailColumn.GetHashCode() );
+      }
+
+      public override bool Equals( object obj )
+      {
+        var key = obj as SynchronizationKey;
+        if( key == null )
+          return false;
+
+        if( key == this )
+          return true;
+
+        return ( key.m_masterColumn == m_masterColumn )
+            && ( key.m_detailColumn == m_detailColumn )
+            && ( key.m_detailConfiguration == m_detailConfiguration );
+      }
+    }
+
+    #endregion
+
+    #region SynchronizationEntry Private Class
+
+    private abstract class SynchronizationEntry
+    {
+      protected SynchronizationEntry( SynchronizationKey key )
+      {
+        if( key == null )
+          throw new ArgumentNullException( "key" );
+
+        m_key = key;
+      }
+
+      #region MasterColumn Protected Property
+
+      protected ColumnBase MasterColumn
+      {
+        get
+        {
+          return m_key.MasterColumn;
+        }
+      }
+
+      #endregion
+
+      #region DetailColumn Protected Property
+
+      protected ColumnBase DetailColumn
+      {
+        get
+        {
+          return m_key.DetailColumn;
+        }
+      }
+
+      #endregion
+
+      #region DetailConfiguration Protected Property
+
+      protected DetailConfiguration DetailConfiguration
+      {
+        get
+        {
+          return m_key.DetailConfiguration;
+        }
+      }
+
+      #endregion
+
+      #region Key Private Property
+
+      private SynchronizationKey Key
+      {
+        get
+        {
+          return m_key;
+        }
+      }
+
+      private readonly SynchronizationKey m_key;
+
+      #endregion
+
+      public abstract void Synchronize();
+      public abstract void Desynchronize();
+    }
+
+    #endregion
+
+    #region BoundColumn Private Class
+
+    private sealed class BoundColumn : SynchronizationEntry
+    {
+      internal BoundColumn( SynchronizationKey key )
+        : base( key )
+      {
+        if( key.MasterColumn == null )
+          throw new ArgumentException( "The master column is not set.", "key" );
+
+        m_bindings = BoundColumn.CreateBindings( key.MasterColumn ).ToArray();
+      }
+
+      #region IsListeningEvents Private Property
+
+      private bool IsListeningEvents
+      {
+        get
+        {
+          return m_isListeningEvents;
+        }
+        set
+        {
+          m_isListeningEvents = value;
+        }
+      }
+
+      private bool m_isListeningEvents; //false
+
+      #endregion
+
+      public override void Synchronize()
+      {
+        this.SubscribeEvents();
+
+        var targetColumn = this.DetailColumn;
+
+        foreach( var entry in m_bindings )
+        {
+          var dp = entry.Key;
+          var binding = entry.Value;
+
+          // The appropriate binding is still in place.
+          var currentBinding = BindingOperations.GetBindingBase( targetColumn, dp );
+          if( currentBinding == binding )
+            continue;
+
+          if( currentBinding != null )
+          {
+            m_localValues[ dp ] = currentBinding;
+          }
+          else
+          {
+            var localValue = targetColumn.ReadLocalValue( dp );
+            if( localValue != DependencyProperty.UnsetValue )
+            {
+              m_localValues[ dp ] = localValue;
+            }
+            else
+            {
+              m_localValues.Remove( dp );
+            }
+          }
+
+          BindingOperations.SetBinding( targetColumn, dp, binding );
+        }
+
+        var visiblePosition = this.GetTargetVisiblePosition();
+        if( visiblePosition.HasValue )
+        {
+          targetColumn.VisiblePosition = visiblePosition.Value;
+        }
+        else
+        {
+          targetColumn.ClearValue( ColumnBase.VisiblePositionProperty );
+        }
+      }
+
+      public override void Desynchronize()
+      {
+        this.UnsubscribeEvents();
+
+        var targetColumn = this.DetailColumn;
+
+        foreach( var entry in m_bindings )
+        {
+          var dp = entry.Key;
+          var binding = entry.Value;
+
+          // The appropriate binding is still in place.
+          var currentBinding = BindingOperations.GetBindingBase( targetColumn, dp );
+          if( currentBinding == binding )
+          {
+            object oldValue;
+
+            if( m_localValues.TryGetValue( dp, out oldValue ) )
+            {
+              var oldBinding = oldValue as BindingBase;
+              if( oldBinding != null )
+              {
+                BindingOperations.SetBinding( targetColumn, dp, oldBinding );
+              }
+              else
+              {
+                targetColumn.SetValue( dp, oldValue );
+              }
+            }
+            else
+            {
+              BindingOperations.ClearBinding( targetColumn, dp );
+            }
+          }
+
+          m_localValues.Remove( dp );
+        }
+
+        targetColumn.ClearValue( ColumnBase.VisiblePositionProperty );
+      }
+
+      private static IEnumerable<KeyValuePair<DependencyProperty, BindingBase>> CreateBindings( ColumnBase source )
+      {
+        yield return BoundColumn.CreateBinding( ColumnBase.WidthProperty, source );
+        yield return BoundColumn.CreateBinding( ColumnBase.MinWidthProperty, source );
+        yield return BoundColumn.CreateBinding( ColumnBase.MaxWidthProperty, source );
+        yield return BoundColumn.CreateBinding( ColumnBase.DesiredWidthProperty, source );
+        yield return BoundColumn.CreateBinding( ColumnBase.VisibleProperty, source );
+        yield return BoundColumn.CreateBinding( ColumnReorderingDragSourceManager.AnimatedColumnReorderingTranslationProperty, source );
+        yield return BoundColumn.CreateBinding( TableflowView.IsBeingDraggedAnimatedProperty, source );
+        yield return BoundColumn.CreateBinding( TableflowView.ColumnReorderingDragSourceManagerProperty, source );
+      }
+
+      private static KeyValuePair<DependencyProperty, BindingBase> CreateBinding( DependencyProperty dp, ColumnBase source )
+      {
+        if( dp == null )
+          throw new ArgumentNullException( "property" );
+
+        if( source == null )
+          throw new ArgumentNullException( "source" );
+
+        var binding = new Binding();
+        binding.Path = new PropertyPath( dp );
+        binding.Source = source;
+
+        return new KeyValuePair<DependencyProperty, BindingBase>( dp, binding );
+      }
+
+      private Nullable<int> GetTargetVisiblePosition()
+      {
+        var detailConfig = this.DetailConfiguration;
+
+        var dataGridControl = detailConfig.DataGridControl;
+        if( dataGridControl == null )
+          return null;
+
+        var masterColumn = this.MasterColumn;
+        int visiblePosition = masterColumn.VisiblePosition;
+        if( visiblePosition < 0 )
+          return null;
+
+        var masterColumnNode = dataGridControl.ColumnsByVisiblePosition.Find( masterColumn );
+        if( masterColumnNode == null )
+          return null;
+
+        var map = this.DetailConfiguration.ItemPropertyMap;
+
+        // Remove master columns that are not linked to a detail column from the VisiblePosition count.
+        masterColumnNode = masterColumnNode.Previous;
+        while( masterColumnNode != null )
+        {
+          string detailColumnName;
+          if( !map.TryGetItemPropertyName( masterColumnNode.Value, out detailColumnName ) )
+          {
+            visiblePosition--;
+          }
+
+          masterColumnNode = masterColumnNode.Previous;
+        }
+
+        Debug.Assert( visiblePosition >= 0 );
+
+        return visiblePosition;
+      }
+
+      private void SubscribeEvents()
+      {
+        if( this.IsListeningEvents )
+          return;
+
+        this.MasterColumn.FittedWidthRequested += new FittedWidthRequestedEventHandler( this.OnMasterColumnFittedWidthRequested );
+        this.IsListeningEvents = true;
+      }
+
+      private void UnsubscribeEvents()
+      {
+        if( !this.IsListeningEvents )
+          return;
+
+        this.MasterColumn.FittedWidthRequested -= new FittedWidthRequestedEventHandler( this.OnMasterColumnFittedWidthRequested );
+        this.IsListeningEvents = false;
+      }
+
+      private void OnMasterColumnFittedWidthRequested( object sender, FittedWidthRequestedEventArgs e )
+      {
+        Debug.Assert( ( ColumnBase )sender == this.MasterColumn );
+
+        var fittedWidth = this.DetailColumn.GetFittedWidth();
+        if( fittedWidth < 0d )
+          return;
+
+        e.SetValue( fittedWidth );
+      }
+
+      #region Private Fields
+
+      private readonly KeyValuePair<DependencyProperty, BindingBase>[] m_bindings;
+      private readonly Dictionary<DependencyProperty, object> m_localValues = new Dictionary<DependencyProperty, object>( 0 );
+
+      #endregion
+    }
+
+    #endregion
+
+    #region UnboundColumn Private Class
+
+    private sealed class UnboundColumn : SynchronizationEntry
+    {
+      internal UnboundColumn( SynchronizationKey key )
+        : base( key )
+      {
+        if( key.MasterColumn != null )
+          throw new ArgumentException( "The master column should not be set.", "key" );
+      }
+
+      public override void Synchronize()
+      {
+        var targetColumn = this.DetailColumn;
+        var dp = ColumnBase.VisibleProperty;
+
+        var currentBinding = BindingOperations.GetBindingBase( targetColumn, dp );
+        if( currentBinding != null )
+        {
+          m_localValue = currentBinding;
+          BindingOperations.ClearBinding( targetColumn, dp );
+        }
+        else
+        {
+          var localValue = targetColumn.ReadLocalValue( dp );
+
+          // The appropriate value is still in place.
+          if( object.Equals( localValue, false ) )
+            return;
+
+          m_localValue = localValue;
+        }
+
+        // Hide the column.
+        targetColumn.SetValue( dp, false );
+      }
+
+      public override void Desynchronize()
+      {
+        var targetColumn = this.DetailColumn;
+        var dp = ColumnBase.VisibleProperty;
+        var oldLocalValue = m_localValue;
+
+        m_localValue = DependencyProperty.UnsetValue;
+
+        if( BindingOperations.GetBindingBase( targetColumn, dp ) != null )
+          return;
+
+        if( !object.Equals( targetColumn.ReadLocalValue( dp ), false ) )
+          return;
+
+        var oldBinding = oldLocalValue as BindingBase;
+        if( oldBinding != null )
+        {
+          BindingOperations.SetBinding( targetColumn, dp, oldBinding );
+        }
+        else if( oldLocalValue != DependencyProperty.UnsetValue )
+        {
+          targetColumn.SetValue( dp, oldLocalValue );
+        }
+        else
+        {
+          targetColumn.ClearValue( dp );
+        }
+      }
+
+      #region Private Fields
+
+      private object m_localValue = DependencyProperty.UnsetValue;
+
+      #endregion
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToNullableBoolConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToNullableBoolConverter.cs
deleted file mode 100644
index b3c22e07..00000000
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToNullableBoolConverter.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-/*************************************************************************************
-
-   Extended WPF Toolkit
-
-   Copyright (C) 2007-2013 Xceed Software Inc.
-
-   This program is provided to you under the terms of the Microsoft Public
-   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
-
-   For more features, controls, and fast professional support,
-   pick up the Plus Edition at http://xceed.com/wpf_toolkit
-
-   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
-
-  ***********************************************************************************/
-
-using System;
-using System.Globalization;
-using System.Windows.Data;
-
-using Xceed.Wpf.DataGrid.FilterCriteria;
-
-namespace Xceed.Wpf.DataGrid.Converters
-{
-  [ValueConversion( typeof( FilterCriterion ), typeof( Nullable<bool> ) )]
-  internal class FilterCriterionToNullableBoolConverter : IValueConverter
-  {
-    #region IValueConverter Members
-
-    public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
-    {
-      Nullable<bool> boolValue = null;
-      EqualToFilterCriterion filterCriterion = value as EqualToFilterCriterion;
-
-      if( ( filterCriterion != null ) && ( filterCriterion.Value is bool ) )
-      {
-        boolValue = ( bool )filterCriterion.Value;
-      }
-
-      return boolValue;
-    }
-
-    public object ConvertBack( object value, Type targetType, object parameter, CultureInfo culture )
-    {
-      Nullable<bool> boolValue = value as Nullable<bool>;
-
-      if( boolValue.HasValue )
-      {
-        return new EqualToFilterCriterion( value );
-      }
-      else
-      {
-        return null;
-      }
-    }
-
-    #endregion
-  }
-}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StatResultConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StatResultConverter.cs
deleted file mode 100644
index 2668c10a..00000000
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StatResultConverter.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-/*************************************************************************************
-
-   Extended WPF Toolkit
-
-   Copyright (C) 2007-2013 Xceed Software Inc.
-
-   This program is provided to you under the terms of the Microsoft Public
-   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
-
-   For more features, controls, and fast professional support,
-   pick up the Plus Edition at http://xceed.com/wpf_toolkit
-
-   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
-
-  ***********************************************************************************/
-
-using System;
-using System.Globalization;
-using System.Text;
-using System.Windows.Data;
-
-namespace Xceed.Wpf.DataGrid.Converters
-{
-  [ValueConversion( typeof( object ), typeof( string ) )]
-  public class StatResultConverter : StringFormatConverter
-  {
-    #region OverflowMessage Property
-
-    private string m_overflowMessage = "#OVER#";
-
-    public string OverflowMessage
-    {
-      get
-      {
-        return m_overflowMessage;
-      }
-      set
-      {
-        m_overflowMessage = value;
-      }
-    }
-
-    #endregion OverflowMessage Property
-
-    #region DivisionByZeroMessage Property
-
-    private string m_divisionByZeroMessage = "#DIV/0#";
-
-    public string DivisionByZeroMessage
-    {
-      get
-      {
-        return m_divisionByZeroMessage;
-      }
-      set
-      {
-        m_divisionByZeroMessage = value;
-      }
-    }
-
-    #endregion DivisionByZeroMessage Property
-
-    #region InvalidValueMessage Property
-
-    private string m_invalidValueMessage = "#VALUE#";
-
-    public string InvalidValueMessage
-    {
-      get
-      {
-        return m_invalidValueMessage;
-      }
-      set
-      {
-        m_invalidValueMessage = value;
-      }
-    }
-
-    #endregion InvalidValueMessage Property
-
-    #region IValueConverter Members
-
-    public override object Convert( object value, Type targetType, object parameter, CultureInfo culture )
-    {
-      if( ( value == null ) || ( value is DBNull ) )
-        return null;
-
-      if( value is DivideByZeroException )
-        return m_divisionByZeroMessage;
-
-      if( value is OverflowException )
-        return m_overflowMessage;
-
-      if( value is Stats.InvalidValueException )
-        return m_invalidValueMessage;
-
-      Stats.InvalidSourcePropertyNameException invalidSourcePropertyNameException = value as Stats.InvalidSourcePropertyNameException;
-
-      if( invalidSourcePropertyNameException != null )
-        return "#" + invalidSourcePropertyNameException.SourcePropertyName + "#";
-
-      Exception exception = value as Exception;
-
-      if( exception != null )
-        return exception.Message;
-
-      return base.Convert( value, targetType, parameter, culture );
-    }
-
-    #endregion
-  }
-}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatConverter.cs
index 8655f195..fdfa4f0d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatConverter.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatConverter.cs
@@ -60,7 +60,7 @@ namespace Xceed.Wpf.DataGrid.Converters
       {
         if( m_formatProvider == null )
         {
-          return string.Format( format, value );
+          return string.Format( culture, format, value );
         }
         else
         {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatMultiConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatMultiConverter.cs
new file mode 100644
index 00000000..288849a7
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/StringFormatMultiConverter.cs
@@ -0,0 +1,50 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace Xceed.Wpf.DataGrid.Converters
+{
+  public class StringFormatMultiConverter : IMultiValueConverter
+  {
+    public object Convert( object[] values, Type targetType, object parameter, CultureInfo culture )
+    {
+      if( ( values == null ) || ( values.Length <= 0 ) )
+        return null;
+
+      var data = values[ 0 ];
+
+      var format = ( values.Length > 1 ) ? values[ 1 ] as string : null;
+      if( string.IsNullOrEmpty( format ) )
+        return data;
+
+      var currentCulture = ( values.Length > 2 ) ? values[ 2 ] as CultureInfo : null;
+      if( currentCulture == null )
+      {
+        currentCulture = culture ?? CultureInfo.CurrentCulture;
+      }
+
+      return string.Format( currentCulture, format, data );
+    }
+
+    public object[] ConvertBack( object value, Type[] targetTypes, object parameter, CultureInfo culture )
+    {
+      throw new NotImplementedException();
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CurrencyManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CurrencyManager.cs
index c272ecbb..6215e1ac 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CurrencyManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/CurrencyManager.cs
@@ -147,8 +147,14 @@ namespace Xceed.Wpf.DataGrid
         // Synchronize the CurrentItem of the DataGridContext
         // with the one of the CollecitonView.
         m_dataGridContext.SetCurrent(
-          m_collectionView.CurrentItem, null, m_collectionView.CurrentPosition,
-          m_dataGridContext.CurrentColumn, false, false, this.ShouldSynchronizeSelectionWithCurrent );
+          m_collectionView.CurrentItem,
+          null,
+          m_collectionView.CurrentPosition,
+          m_dataGridContext.CurrentColumn,
+          false,
+          false,
+          this.ShouldSynchronizeSelectionWithCurrent,
+          AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged );
 
         if( m_collectionView.CurrentItem == null )
           this.ChangeCurrentDataGridContext();
@@ -163,8 +169,14 @@ namespace Xceed.Wpf.DataGrid
           m_dataGridContext.CancelEdit();
 
           m_dataGridContext.SetCurrent(
-            m_collectionView.CurrentItem, null, m_collectionView.CurrentPosition,
-            m_dataGridContext.CurrentColumn, false, false, this.ShouldSynchronizeSelectionWithCurrent );
+            m_collectionView.CurrentItem,
+            null,
+            m_collectionView.CurrentPosition,
+            m_dataGridContext.CurrentColumn,
+            false,
+            false,
+            this.ShouldSynchronizeSelectionWithCurrent,
+            AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged );
 
           if( m_collectionView.CurrentItem == null )
             this.ChangeCurrentDataGridContext();
@@ -180,9 +192,7 @@ namespace Xceed.Wpf.DataGrid
     {
       if( ( m_dataGridContext.ParentDataGridContext == null )
         || ( m_dataGridContext.ParentItem == null ) )
-      {
         return;
-      }
 
       List<DataGridContext> childContexts = this.GetParentItemChildContexts();
       int currentContextIndex = childContexts.IndexOf( m_dataGridContext );
@@ -200,7 +210,7 @@ namespace Xceed.Wpf.DataGrid
             if( childContext.Items.Count == 0 )
               continue;
 
-            childContext.SetCurrentItemCore( childContext.Items.GetItemAt( 0 ), false, this.ShouldSynchronizeSelectionWithCurrent );
+            childContext.SetCurrentItemCore( childContext.Items.GetItemAt( 0 ), false, this.ShouldSynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged );
             return;
           }
         }
@@ -216,13 +226,13 @@ namespace Xceed.Wpf.DataGrid
           if( count == 0 )
             continue;
 
-          childContext.SetCurrentItemCore( childContext.Items.GetItemAt( count - 1 ), false, this.ShouldSynchronizeSelectionWithCurrent );
+          childContext.SetCurrentItemCore( childContext.Items.GetItemAt( count - 1 ), false, this.ShouldSynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged );
           return;
         }
       }
 
       // No context after or before us have been found, we will set the CurrentItem to our ParentItem.
-      m_dataGridContext.ParentDataGridContext.SetCurrentItemCore( m_dataGridContext.ParentItem, false, this.ShouldSynchronizeSelectionWithCurrent );
+      m_dataGridContext.ParentDataGridContext.SetCurrentItemCore( m_dataGridContext.ParentItem, false, this.ShouldSynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged );
     }
 
     private List<DataGridContext> GetParentItemChildContexts()
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataCell.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataCell.cs
index 0b060d69..49232e2a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataCell.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataCell.cs
@@ -15,21 +15,15 @@
   ***********************************************************************************/
 
 using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Controls.Primitives;
 using System.Windows.Data;
-using System.Text;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Xml;
 using System.Windows.Input;
-using System.Windows.Media;
-using System.Collections.ObjectModel;
-using System.ComponentModel;
-using Xceed.Wpf.DataGrid.Views;
-using Xceed.Wpf.DataGrid.Markup;
+using System.Xml;
+using Xceed.Wpf.DataGrid.Converters;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -55,10 +49,13 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return ( m_canBeRecycled && base.CanBeRecycled );
+        return ( m_canBeRecycled )
+            && ( base.CanBeRecycled );
       }
     }
 
+    private bool m_canBeRecycled; //= false
+
     #endregion
 
     #region OverrideColumnCellContentTemplate Property
@@ -73,13 +70,36 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    protected override void OnMouseEnter( MouseEventArgs e )
+    {
+      //If the current CellEditorDisplayConditions requires display when mouse is over the Cell 
+      if( Cell.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverCell ) )
+      {
+        //Display the editors for the Row
+        this.SetDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverCell );
+      }
+
+      base.OnMouseEnter( e );
+    }
+
+    protected override void OnMouseLeave( MouseEventArgs e )
+    {
+      //If the current CellEditorDisplayConditions requires display when mouse is over the Cell 
+      if( Cell.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverCell ) )
+      {
+        //Display the editors for the Row
+        this.RemoveDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverCell );
+      }
+
+      base.OnMouseLeave( e );
+    }
+
     protected override void InitializeCore( DataGridContext dataGridContext, Row parentRow, ColumnBase parentColumn )
     {
       ColumnBase oldParentColumn = this.ParentColumn;
 
       base.InitializeCore( dataGridContext, parentRow, parentColumn );
 
-      // This is a fix for Case 106982 (could not bind to XML datasources that contained namespaces).
       //
       // For an unknown reason, when a recycled DataCell was added back to the VisualTree (added
       // to the CellsHostPanel in its ParentRow), the binding would fail to update when the XPath
@@ -122,12 +142,11 @@ namespace Xceed.Wpf.DataGrid
 
     protected internal override void PrepareDefaultStyleKey( Xceed.Wpf.DataGrid.Views.ViewBase view )
     {
-      object currentThemeKey = view.GetDefaultStyleKey( typeof( DataCell ) );
+      var newThemeKey = view.GetDefaultStyleKey( typeof( DataCell ) );
+      if( object.Equals( this.DefaultStyleKey, newThemeKey ) )
+        return;
 
-      if( currentThemeKey.Equals( this.DefaultStyleKey ) == false )
-      {
-        this.DefaultStyleKey = currentThemeKey;
-      }
+      this.DefaultStyleKey = newThemeKey;
     }
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters" )]
@@ -145,14 +164,7 @@ namespace Xceed.Wpf.DataGrid
         // If the dataContext is our ParentRow, we do not create any binding
         if( dataContext != this.ParentRow )
         {
-
-          // Disable warning for DisplayMemberBinding when internaly used
-#pragma warning disable 618
-
-          displayMemberBinding = column.DisplayMemberBinding;
-
-#pragma warning restore 618
-
+          displayMemberBinding = column.GetDisplayMemberBinding();
 
           if( displayMemberBinding == null )
           {
@@ -163,19 +175,13 @@ namespace Xceed.Wpf.DataGrid
             {
               bool isDataGridUnboundItemProperty;
 
-              displayMemberBinding = ItemsSourceHelper.AutoCreateDisplayMemberBinding(
-                column, dataGridContext, dataContext, out isDataGridUnboundItemProperty );
+              displayMemberBinding = ItemsSourceHelper.AutoCreateDisplayMemberBinding( column, dataGridContext, dataContext, out isDataGridUnboundItemProperty );
 
               column.IsBoundToDataGridUnboundItemProperty = isDataGridUnboundItemProperty;
             }
 
-            // Disable warning for DisplayMemberBinding when internaly used
-#pragma warning disable 618
-            column.DisplayMemberBinding = displayMemberBinding;
-#pragma warning restore 618
-
-            //mark the Column's Binding as AutoCreated.
             column.IsBindingAutoCreated = true;
+            column.SetDisplayMemberBinding( displayMemberBinding );
           }
         }
 
@@ -212,6 +218,11 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    internal virtual void ClearDisplayMemberBinding()
+    {
+      BindingOperations.ClearBinding( this, Cell.ContentProperty );
+    }
+
     internal override void ContentCommitted()
     {
       base.ContentCommitted();
@@ -222,6 +233,33 @@ namespace Xceed.Wpf.DataGrid
         parentRow.EnsurePosition( dataGridContext, this );
     }
 
+    internal override DataTemplate GetForeignKeyDataTemplate()
+    {
+      var column = this.ParentColumn as Column;
+      if( column == null )
+        return null;
+
+      // If a foreignKey CellContentTemplate was found by the configuration,
+      // it must be used even if a CellContentTemplate is defined because the 
+      // CellContentTemplate will be used by this template
+      var configuration = column.ForeignKeyConfiguration;
+      if( configuration == null )
+        return null;
+
+      return configuration.DefaultCellContentTemplate;
+    }
+
+    internal override DataTemplate GetCellStringFormatDataTemplate( DataTemplate contentTemplate )
+    {
+      var parentColumn = this.ParentColumn;
+      Debug.Assert( parentColumn != null );
+
+      var format = parentColumn.CellContentStringFormat;
+      Debug.Assert( !string.IsNullOrEmpty( format ) );
+
+      return StringFormatDataTemplate.Get( contentTemplate, format, parentColumn.GetCulture() );
+    }
+
     private static bool VerifyDisplayMemberBinding( BindingBase binding )
     {
       bool retval = false;
@@ -242,7 +280,5 @@ namespace Xceed.Wpf.DataGrid
 
       return retval;
     }
-
-    private bool m_canBeRecycled; // = false
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridBindingInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridBindingInfo.cs
index 79383acb..c35222d2 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridBindingInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridBindingInfo.cs
@@ -152,6 +152,23 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion FallbackValue Property
 
+    #region IsAsync Property
+
+    public bool IsAsync
+    {
+      get
+      {
+        return m_binding.IsAsync;
+      }
+
+      set
+      {
+        m_binding.IsAsync = value;
+      }
+    }
+
+    #endregion IsAsync Property
+
     #region NotifyOnSourceUpdated Property
 
     public bool NotifyOnSourceUpdated
@@ -210,7 +227,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion ReadOnly Property
 
-
     #region UpdateSourceExceptionFilter Property
 
     public UpdateSourceExceptionFilterCallback UpdateSourceExceptionFilter
@@ -257,7 +273,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion Path Property
 
-
     #region INTERNAL METHODS
 
     internal Binding GetBinding()
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridContext.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridContext.cs
index bf452dda..0914c69f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridContext.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridContext.cs
@@ -14,33 +14,31 @@
 
   ***********************************************************************************/
 
-using System.Collections.ObjectModel;
-using System.ComponentModel;
-using System.Windows;
-using System.Windows.Controls;
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Windows.Data;
+using System.Collections.ObjectModel;
 using System.Collections.Specialized;
-using System.Windows.Input;
+using System.ComponentModel;
 using System.Diagnostics;
-using System.Collections;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Windows;
+using System.Windows.Automation.Peers;
+using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
+using System.Windows.Data;
 using System.Windows.Media;
-using System.Windows.Threading;
 using Xceed.Utils.Collections;
-using Xceed.Wpf.DataGrid.Views;
-using System.Globalization;
 using Xceed.Wpf.DataGrid.Automation;
-using System.Windows.Automation.Peers;
 using Xceed.Wpf.DataGrid.Utils;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
   public sealed class DataGridContext : DependencyObject, INotifyPropertyChanged, IWeakEventListener, IDataGridContextVisitable, ICustomTypeDescriptor
   {
-    #region Constructors
-
     internal DataGridContext(
       DataGridContext parentDataGridContext,
       DataGridControl dataGridControl,
@@ -67,20 +65,36 @@ namespace Xceed.Wpf.DataGrid
 
       m_currencyManager = new CurrencyManager( this, m_items );
 
-      m_selectedItemsStore = new SelectedItemsStorage( this, 2 );
-      m_selectedCellsStore = new SelectedCellsStorage( this, 2 );
+      m_selectedItemsStore = new SelectedItemsStorage( this );
+      m_selectedCellsStore = new SelectedCellsStorage( this );
       m_selectedItemsRanges = new SelectionItemRangeCollection( m_selectedItemsStore );
       m_selectedCellRanges = new SelectionCellRangeCollection( m_selectedCellsStore );
       m_selectedItems = new SelectionItemCollection( m_selectedItemsStore );
 
       CollectionChangedEventManager.AddListener( m_items, this );
 
-      if( detailConfiguration == null )
+      var dataGridCollectionViewBase = m_items as DataGridCollectionViewBase;
+      if( dataGridCollectionViewBase != null )
       {
-        //If the detailConfiguration is null then we are in the master...
+        PreBatchCollectionChangedEventManager.AddListener( dataGridCollectionViewBase, this );
+        PostBatchCollectionChangedEventManager.AddListener( dataGridCollectionViewBase, this );
+      }
+
+      //if this is a DataGridCollectionView
+      var dataGridCollectionView = m_items as DataGridCollectionView;
+      if( dataGridCollectionView != null )
+      {
+        //Set its dataGridContext so it can propagate a DeferRefresh to details' DataGridCollectionView's
+        dataGridCollectionView.PrepareRootContextForDeferRefresh( this );
+      }
 
+      //If the detailConfiguration is null then we are in the master...
+      if( detailConfiguration == null )
+      {
         this.CreateStandaloneCollections();
-        this.SetupCollectionsChangeNotification();
+
+        CollectionChangedEventManager.AddListener( m_items.SortDescriptions, this );
+        CollectionChangedEventManager.AddListener( m_items.GroupDescriptions, this );
 
         GroupConfigurationSelectorChangedEventManager.AddListener( m_dataGridControl, this );
         AllowDetailToggleChangedEventManager.AddListener( m_dataGridControl, this );
@@ -88,17 +102,17 @@ namespace Xceed.Wpf.DataGrid
         MaxSortLevelsChangedEventManager.AddListener( m_dataGridControl, this );
         ItemsSourceChangeCompletedEventManager.AddListener( m_dataGridControl, this );
       }
+      //Detail DataGridContext
       else
       {
-        //Detail DataGridContext
-
-
         //only listen to the detail grid config current column changed if the detail grid config is synchronized.
         CurrentColumnChangedEventManager.AddListener( m_detailConfig, this );
 
         GroupConfigurationSelectorChangedEventManager.AddListener( m_detailConfig, this );
         AllowDetailToggleChangedEventManager.AddListener( m_detailConfig, this );
 
+        VisibilityChangingEventManager.AddListener( m_detailConfig.Columns, this );
+
         // Register to the VisibleColumnsChanged to update, if need be, the columns desired width
         // when column stretching is active and there's a column reordering.
         CollectionChangedEventManager.AddListener( m_detailConfig.VisibleColumns, this );
@@ -141,22 +155,38 @@ namespace Xceed.Wpf.DataGrid
       this.HookToItemPropertiesChanged();
     }
 
-    public void Items_CollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void Items_CollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+    {
+      if( m_deferSelectionChangedOnItemsCollectionChanged != null )
+      {
+        m_deferSelectionChangedOnItemsCollectionChanged.Queue( e );
+      }
+      else
+      {
+        this.UpdateSelectionAfterSourceCollectionChanged( e );
+      }
+    }
+
+    private void UpdateSelectionAfterSourceCollectionChanged( NotifyCollectionChangedEventArgs e )
     {
       if( m_dataGridControl.SelectedIndexPropertyNeedCoerce )
+      {
         m_dataGridControl.CoerceValue( DataGridControl.SelectedIndexProperty );
+      }
 
       if( m_dataGridControl.SelectedItemPropertyNeedCoerce )
+      {
         m_dataGridControl.CoerceValue( DataGridControl.SelectedItemProperty );
+      }
 
       if( this.Peer != null )
+      {
         m_dataGridControl.QueueDataGridContextPeerChlidrenRefresh( this );
+      }
 
       m_dataGridControl.SelectionChangerManager.UpdateSelectionAfterSourceCollectionChanged( this, e );
     }
 
-    #endregion
-
     internal void CleanDataGridContext()
     {
       if( m_currencyManager != null )
@@ -172,7 +202,10 @@ namespace Xceed.Wpf.DataGrid
         DataGridCollectionViewBase dataGridCollectionViewBase = this.ItemsSourceCollection as DataGridCollectionViewBase;
 
         if( dataGridCollectionViewBase != null )
-          dataGridCollectionViewBase.UnregisterChangedEvent();
+        {
+          dataGridCollectionViewBase.UnregisterChangedEvents();
+          dataGridCollectionViewBase.RemoveSourceChangedListenersForDetail();
+        }
       }
 
       //For non-master DataGridContext
@@ -184,20 +217,8 @@ namespace Xceed.Wpf.DataGrid
         MaxSortLevelsChangedEventManager.RemoveListener( m_dataGridControl, this );
         ItemsSourceChangeCompletedEventManager.RemoveListener( m_dataGridControl, this );
 
-        if( m_sortDescriptionsCollectionChangedHandler != null )
-        {
-          // Unregister for change notification of the SortDescriptions
-          INotifyCollectionChanged notify = m_items.SortDescriptions;
-          notify.CollectionChanged -= m_sortDescriptionsCollectionChangedHandler;
-          m_sortDescriptionsCollectionChangedHandler = null;
-        }
-
-        if( m_groupDescriptionsCollectionChangedHandler != null )
-        {
-          // Unregister for change notification of the GroupDescriptions
-          m_items.GroupDescriptions.CollectionChanged -= m_groupDescriptionsCollectionChangedHandler;
-          m_groupDescriptionsCollectionChangedHandler = null;
-        }
+        CollectionChangedEventManager.RemoveListener( m_items.SortDescriptions, this );
+        CollectionChangedEventManager.RemoveListener( m_items.GroupDescriptions, this );
       }
       else
       {
@@ -225,11 +246,7 @@ namespace Xceed.Wpf.DataGrid
       ViewChangedEventManager.RemoveListener( m_dataGridControl, this );
       this.UnhookToItemPropertiesChanged( m_dataGridControlItemsSource as DataGridCollectionViewBase );
 
-      // Case 124245 : Be sure to clear the ColumnVirtualizationManager before
-      // clearing the ViewProperties since it binds to the FixedColumnCount to
-      // avoid Binding Errors
       ColumnVirtualizationManager columnVirtualizationManager = this.ColumnVirtualizationManager;
-
       if( columnVirtualizationManager != null )
       {
         columnVirtualizationManager.CleanManager();
@@ -257,9 +274,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private DataGridContext m_parentDataGridContext; // = null
+    private readonly DataGridContext m_parentDataGridContext; // = null
 
-    #endregion ParentDataGridContext Read-Only Property
+    #endregion
 
     #region ParentItem Read-Only Property
 
@@ -318,7 +335,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region Columns Read-Only property
+    #region Columns Read-Only Property
 
     public ColumnCollection Columns
     {
@@ -381,13 +398,13 @@ namespace Xceed.Wpf.DataGrid
         if( m_currentColumn == value )
           return;
 
-        this.SetCurrentColumnCore( value, true, m_dataGridControl.SynchronizeSelectionWithCurrent );
+        this.SetCurrentColumnCore( value, true, m_dataGridControl.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CurrentColumnChanged );
       }
     }
 
-    internal void SetCurrentColumnCore( ColumnBase column, bool isCancelable, bool synchronizeSelectionWithCurrent )
+    internal void SetCurrentColumnCore( ColumnBase column, bool isCancelable, bool synchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers trigger )
     {
-      this.SetCurrent( this.InternalCurrentItem, null, null, column, false, isCancelable, synchronizeSelectionWithCurrent );
+      this.SetCurrent( this.InternalCurrentItem, null, null, column, false, isCancelable, synchronizeSelectionWithCurrent, trigger );
     }
 
     private ColumnBase m_currentColumn; // = null
@@ -419,13 +436,13 @@ namespace Xceed.Wpf.DataGrid
         if( value == m_currentItem )
           return;
 
-        this.SetCurrentItemCore( value, true, m_dataGridControl.SynchronizeSelectionWithCurrent );
+        this.SetCurrentItemCore( value, true, m_dataGridControl.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CurrentItemChanged );
       }
     }
 
-    internal void SetCurrentItemCore( object item, bool isCancelable, bool synchronizeSelectionWithCurrent )
+    internal void SetCurrentItemCore( object item, bool isCancelable, bool synchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers trigger )
     {
-      this.SetCurrent( item, null, null, this.CurrentColumn, false, isCancelable, synchronizeSelectionWithCurrent );
+      this.SetCurrent( item, null, null, this.CurrentColumn, false, isCancelable, synchronizeSelectionWithCurrent, trigger );
     }
 
     public int CurrentItemIndex
@@ -439,13 +456,13 @@ namespace Xceed.Wpf.DataGrid
         if( value == m_currentItemIndex )
           return;
 
-        this.SetCurrentItemIndexCore( value, true, m_dataGridControl.SynchronizeSelectionWithCurrent );
+        this.SetCurrentItemIndexCore( value, true, m_dataGridControl.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CurrentItemChanged );
       }
     }
 
-    internal void SetCurrentItemIndexCore( int index, bool isCancelable, bool synchronizeSelectionWithCurrent )
+    internal void SetCurrentItemIndexCore( int index, bool isCancelable, bool synchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers trigger )
     {
-      this.SetCurrent( this.Items.GetItemAt( index ), null, index, this.CurrentColumn, false, isCancelable, synchronizeSelectionWithCurrent );
+      this.SetCurrent( this.Items.GetItemAt( index ), null, index, this.CurrentColumn, false, isCancelable, synchronizeSelectionWithCurrent, trigger );
     }
 
     private void SetCurrentItemHelper( object dataItem, int sourceDataItemIndex )
@@ -561,7 +578,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region GroupConfigirationSelector Property
+    #region GroupConfigurationSelector Property
 
     public GroupConfigurationSelector GroupConfigurationSelector
     {
@@ -725,8 +742,6 @@ namespace Xceed.Wpf.DataGrid
 
     #region DataGridControl Read-Only Property
 
-    private DataGridControl m_dataGridControl;
-
     public DataGridControl DataGridControl
     {
       get
@@ -735,7 +750,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion DataGridControl Read-Only Property
+    private readonly DataGridControl m_dataGridControl;
+
+    #endregion
 
     #region SelectedItems Read-Only Property
 
@@ -779,11 +796,8 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion SelectedCellRanges Read-Only Property
 
-
     #region SourceDetailConfiguration Read-Only Property
 
-    private DetailConfiguration m_detailConfig;
-
     internal DetailConfiguration SourceDetailConfiguration
     {
       get
@@ -792,6 +806,8 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private readonly DetailConfiguration m_detailConfig;
+
     #endregion SourceDetailConfiguration Read-Only Property
 
     #region VisibleColumns Read-Only Property
@@ -881,6 +897,18 @@ namespace Xceed.Wpf.DataGrid
 
     //--------- INTERNAL PROPERTIES ---------
 
+    #region RootDataGridContext Read-Only Property
+
+    internal DataGridContext RootDataGridContext
+    {
+      get
+      {
+        return this.DataGridControl.DataGridContext;
+      }
+    }
+
+    #endregion
+
     #region SelectedItemsStore Read-Only Property
 
     internal SelectedItemsStorage SelectedItemsStore
@@ -925,7 +953,6 @@ namespace Xceed.Wpf.DataGrid
     private HashedLinkedList<ColumnBase> m_columnsByVisiblePosition;// = null, this variable will store the ColumnsByVisiblePosition only when
     //the DataGridContext is used "desynchronized".
 
-
     #endregion
 
     #region ColumnStretchingManager Property
@@ -1048,12 +1075,22 @@ namespace Xceed.Wpf.DataGrid
       {
         if( m_detailConfig != null )
         {
-          Dictionary<string, ItemsSourceHelper.FieldDescriptor> itemsSourceFieldDescriptors =
-            m_detailConfig.ItemsSourceFieldDescriptors;
+          Dictionary<string, ItemsSourceHelper.FieldDescriptor> itemsSourceFieldDescriptors = m_detailConfig.ItemsSourceFieldDescriptors;
 
           if( itemsSourceFieldDescriptors == null )
           {
-            itemsSourceFieldDescriptors = ItemsSourceHelper.GetFields( m_items, null );
+            if( this.AreDetailsFlatten )
+            {
+              var rootDataGridContext = this.RootDataGridContext;
+              Debug.Assert( ( rootDataGridContext != null ) && ( this != rootDataGridContext ) );
+
+              itemsSourceFieldDescriptors = ItemsSourceHelper.GetFields( rootDataGridContext.ItemsSourceFieldDescriptors, this.ItemPropertyMap, m_items, null );
+            }
+            else
+            {
+              itemsSourceFieldDescriptors = ItemsSourceHelper.GetFields( m_items, null );
+            }
+
             m_detailConfig.ItemsSourceFieldDescriptors = itemsSourceFieldDescriptors;
           }
 
@@ -1082,6 +1119,91 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region ItemPropertyMap Internal Property
+
+    internal FieldNameMap ItemPropertyMap
+    {
+      get
+      {
+        if( m_detailConfig != null )
+          return m_detailConfig.ItemPropertyMap;
+
+        if( m_itemPropertyMap == null )
+        {
+          m_itemPropertyMap = new FieldNameMap();
+        }
+
+        return m_itemPropertyMap;
+      }
+    }
+
+    private FieldNameMap m_itemPropertyMap; //null
+
+    #endregion
+
+    #region ToggleColumnSortCommand Internal Property
+
+    internal ToggleColumnSortCommand ToggleColumnSortCommand
+    {
+      get
+      {
+        if( m_toggleColumnSortCommand == null )
+        {
+          m_toggleColumnSortCommand = new DataGridContextToggleColumnSortCommand( this );
+        }
+
+        Debug.Assert( m_toggleColumnSortCommand != null );
+
+        return m_toggleColumnSortCommand;
+      }
+    }
+
+    private ToggleColumnSortCommand m_toggleColumnSortCommand;
+
+    #endregion
+
+    #region UpdateColumnSortCommand Internal Property
+
+    internal UpdateColumnSortCommand UpdateColumnSortCommand
+    {
+      get
+      {
+        if( m_updateColumnSortCommand == null )
+        {
+          m_updateColumnSortCommand = new DataGridContextUpdateColumnSortCommand( this );
+        }
+
+        Debug.Assert( m_updateColumnSortCommand != null );
+
+        return m_updateColumnSortCommand;
+      }
+    }
+
+    private UpdateColumnSortCommand m_updateColumnSortCommand;
+
+    #endregion
+
+    #region AddGroupCommand Internal Property
+
+    internal ColumnAddGroupCommand AddGroupCommand
+    {
+      get
+      {
+        if( m_addGroupCommand == null )
+        {
+          m_addGroupCommand = new DataGridContextAddGroupCommand( this );
+        }
+
+        Debug.Assert( m_addGroupCommand != null );
+
+        return m_addGroupCommand;
+      }
+    }
+
+    private ColumnAddGroupCommand m_addGroupCommand;
+
+    #endregion
+
     #region SortDescriptionsSyncContext Read-Only Property
 
     internal SortDescriptionsSyncContext SortDescriptionsSyncContext
@@ -1139,9 +1261,14 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    internal ColumnVirtualizationManager GetColumnVirtualizationManagerOrNull()
+    {
+      return ColumnVirtualizationManager.GetColumnVirtualizationManager( this );
+    }
+
     #endregion
 
-    #region FixedHeaderFooterViewPortSize
+    #region FixedHeaderFooterViewPortSize Property
 
     internal Size FixedHeaderFooterViewPortSize
     {
@@ -1238,9 +1365,16 @@ namespace Xceed.Wpf.DataGrid
 
     #region SelectionChanged Event
 
+    internal event EventHandler<SelectionChangedInternalEventArgs> SelectionChangedInternal;
+
     internal void InvokeSelectionChanged( SelectionInfo selectionInfo )
     {
 
+      if( this.SelectionChangedInternal != null )
+      {
+        this.SelectionChangedInternal( this, new SelectionChangedInternalEventArgs( selectionInfo ) );
+      }
+
       Debug.Assert( selectionInfo.DataGridContext == this );
 
       if( ( selectionInfo.RemovedItems.Count == 0 ) && ( selectionInfo.AddedItems.Count == 0 ) )
@@ -1319,6 +1453,31 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region IsAFlattenDetail Internal Property
+
+    internal bool IsAFlattenDetail
+    {
+      get
+      {
+        return ( m_detailConfig != null )
+            && ( this.AreDetailsFlatten );
+      }
+    }
+
+    #endregion
+
+    #region AreDetailsFlatten Internal Property
+
+    internal bool AreDetailsFlatten
+    {
+      get
+      {
+        return this.DataGridControl.AreDetailsFlatten;
+      }
+    }
+
+    #endregion
+
     #region AlreadySearchedForDefaultDetailConfig Private Property
 
     private bool AlreadySearchedForDefaultDetailConfig
@@ -1373,10 +1532,20 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion ItemsProperties/Column Auto update
 
+    #region IsSettingFixedColumnCount Property
+
+    internal bool IsSettingFixedColumnCount
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
     internal void SetCurrentColumnAndChangeSelection( ColumnBase newCurrentColumn )
     {
       // Since SetCurrentColumnCore can be aborted, we do it before changing the selection.
-      this.SetCurrentColumnCore( newCurrentColumn, true, false );
+      this.SetCurrentColumnCore( newCurrentColumn, true, false, AutoScrollCurrentItemSourceTriggers.Navigation );
 
       if( m_dataGridControl != null )
       {
@@ -1397,10 +1566,11 @@ namespace Xceed.Wpf.DataGrid
           rowIsBeingEdited = row.IsBeingEdited;
         }
 
+        var oldPosition = SelectionRangePoint.TryCreateFromCurrent( this );
+        var newPosition = new SelectionRangePoint( this, item, dataRowIndex, newCurrentColumn.VisiblePosition );
+
         m_dataGridControl.SelectionChangerManager.UpdateSelection(
-          this, this.CurrentItem, this.CurrentColumn,
-          this, true, rowIsBeingEdited,
-          dataRowIndex, item, newCurrentColumn.VisiblePosition,
+          oldPosition,newPosition, true, rowIsBeingEdited,
           SelectionManager.UpdateSelectionSource.Navigation );
       }
     }
@@ -1612,6 +1782,11 @@ namespace Xceed.Wpf.DataGrid
       return this.CustomItemContainerGenerator.GetChildContexts();
     }
 
+    internal IEnumerable<DataGridContext> GetChildContextsCore()
+    {
+      return this.CustomItemContainerGenerator.GetChildContextsCore();
+    }
+
     internal BindingPathValueExtractor GetBindingPathExtractorForColumn( Column column, object dataItem )
     {
       if( column == null )
@@ -1648,7 +1823,7 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        throw new DataGridInternalException( "DisplayMemberBinding is null." );
+        throw new DataGridInternalException( "DisplayMemberBinding is null.", m_dataGridControl );
       }
 
       IValueConverter converter = new Xceed.Wpf.DataGrid.Converters.SourceDataConverter( ItemsSourceHelper.IsItemSupportingDBNull( dataItem ), CultureInfo.InvariantCulture );
@@ -1918,12 +2093,11 @@ namespace Xceed.Wpf.DataGrid
       return this.CustomItemContainerGenerator.GetGroupFromItem( dataItem );
     }
 
-    internal static void HandleColumnsCollectionChanged( NotifyCollectionChangedEventArgs e,
+    internal static void HandleColumnsCollectionChanged(
+      NotifyCollectionChangedEventArgs e,
       ColumnCollection columns,
       ReadOnlyColumnCollection visibleColumns,
-      HashedLinkedList<ColumnBase> columnsByVisiblePosition,
-      SortDescriptionsSyncContext sortDescriptionsSyncContext,
-      SortDescriptionCollection sortDescriptions )
+      HashedLinkedList<ColumnBase> columnsByVisiblePosition )
     {
       if( columns == null )
         throw new ArgumentNullException( "columns" );
@@ -1934,10 +2108,6 @@ namespace Xceed.Wpf.DataGrid
       if( columnsByVisiblePosition == null )
         throw new ArgumentNullException( "columnsByVisiblePosition" );
 
-      if( sortDescriptionsSyncContext == null )
-        throw new ArgumentNullException( "sortDescriptionsSyncContext" );
-
-
       bool needGeneratorHardReset = false;
 
       if( e.OldItems != null )
@@ -1951,11 +2121,6 @@ namespace Xceed.Wpf.DataGrid
         }
       }
 
-      if( sortDescriptions != null )
-      {
-        DataGridContext.SynchronizeSortProperties( sortDescriptionsSyncContext, sortDescriptions, columns );
-      }
-
       DataGridContext.UpdateVisibleColumns( columns, visibleColumns, columnsByVisiblePosition, e.NewItems, null );
 
       // When a column is removed, we need to clear the Generator from every container to avoid problem
@@ -1966,15 +2131,24 @@ namespace Xceed.Wpf.DataGrid
         if( dataGridControl != null )
         {
           if( dataGridControl.CustomItemContainerGenerator != null )
+          {
             dataGridControl.CustomItemContainerGenerator.RemoveAllAndNotify();
+          }
 
           // We only reset the fixed region if the column is part of the master context 
           if( ( dataGridControl.DataGridContext != null ) && ( dataGridControl.DataGridContext.SourceDetailConfiguration == null ) )
+          {
             dataGridControl.ResetFixedRegions();
+          }
         }
       }
     }
 
+    internal IDisposable SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers trigger )
+    {
+      return m_dataGridControl.SetQueueBringIntoViewRestrictions( trigger );
+    }
+
     internal IDisposable InhibitQueueBringIntoView()
     {
       return m_dataGridControl.InhibitQueueBringIntoView();
@@ -1988,11 +2162,13 @@ namespace Xceed.Wpf.DataGrid
     internal void NotifyItemsSourceChanged()
     {
       this.NotifyPropertyChanged( "HasDetails" );
+
+      m_dataGridControl.QueueDataGridContextPeerChlidrenRefresh( this );
     }
 
-    internal void DelayBringIntoViewAndFocusCurrent()
+    internal void DelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers trigger )
     {
-      m_dataGridControl.DelayBringIntoViewAndFocusCurrent();
+      m_dataGridControl.DelayBringIntoViewAndFocusCurrent( trigger );
     }
 
     internal void ResetViewProperties()
@@ -2009,7 +2185,8 @@ namespace Xceed.Wpf.DataGrid
       ColumnBase column,
       bool forceFocus,
       bool isCancelable,
-      bool synchronizeSelectionWithCurrent )
+      bool synchronizeSelectionWithCurrent,
+      AutoScrollCurrentItemSourceTriggers trigger )
     {
       // sourceDataItemIndex 
       //  null = item have to be checked if it is a dataItem
@@ -2019,7 +2196,7 @@ namespace Xceed.Wpf.DataGrid
       //verify that SetCurrent is not called successively caused by actions performed within, this is to prevent
       //exceptions caused by the accessing of resources that could be "locked" (e.g., ItemsControl.Items.DeferRefresh)
       if( m_dataGridControl.IsSetCurrentInProgress )
-        throw new DataGridException( "SetCurrent cannot be invoked while another SetCurrent is in progress." );
+        throw new DataGridException( "SetCurrent cannot be invoked while another SetCurrent is in progress.", m_dataGridControl );
 
       try
       {
@@ -2049,7 +2226,7 @@ namespace Xceed.Wpf.DataGrid
           if( ( column != null )
             && ( ( ( column.ReadOnly )
             && ( !newCurrentRow.Cells[ column ].GetCalculatedCanBeCurrent() ) ) ) )
-            throw new DataGridException( "SetCurrent cannot be invoked if the column cannot be current." );
+            throw new DataGridException( "SetCurrent cannot be invoked if the column cannot be current.", m_dataGridControl );
         }
 
         //if item is not realized or if the item passed is not a Data Item (header, footer or group), then the 
@@ -2123,7 +2300,7 @@ namespace Xceed.Wpf.DataGrid
               oldCurrentRow.SetIsCurrent( true );
             }
 
-            throw new DataGridException( "The operation has been canceled." );
+            throw new DataGridException( "The operation has been canceled.", m_dataGridControl );
           }
         }
 
@@ -2200,10 +2377,10 @@ namespace Xceed.Wpf.DataGrid
               //To prevent re-entrancy of the SetCurrent fonction (since Row.BeginEdit will call Cell.BeginEdit which will call SetCurrent if not current already)
               if( this.VisibleColumns.Count > 0 )
               {
-                int firstFocusableColumn = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( this, newCurrentRow );
+                int firstFocusableColumn = NavigationHelper.GetFirstVisibleFocusableColumnIndex( this, newCurrentRow );
 
                 if( firstFocusableColumn < 0 )
-                  throw new DataGridException( "Trying to edit while no cell is focusable. " );
+                  throw new DataGridException( "Trying to edit while no cell is focusable. ", m_dataGridControl );
 
                 this.SetCurrentColumnHelper( this.VisibleColumns[ firstFocusableColumn ] );
                 newCurrentCell = newCurrentRow.Cells[ m_currentColumn ];
@@ -2257,16 +2434,17 @@ namespace Xceed.Wpf.DataGrid
           //if the container from the new Current item is realized
           if( newCurrentRow != null )
           {
-            // Call BringIntoView on the cell to ensure it is put in VisualTree if virtualized
-            if( newCurrentCell != null )
-            {
-              // Ensure the Cell is into view (this will force a bring into view of the newCurrentRow as a side effect)
-              newCurrentCell.BringIntoView();
-            }
-            else
+            if( m_dataGridControl.IsBringIntoViewAllowed( trigger ) )
             {
-              // Ensure the item is visible visible
-              newCurrentRow.BringIntoView();
+              if( newCurrentCell != null )
+              {
+                newCurrentCell.BringIntoView();
+              }
+              else
+              {
+                // Ensure the item is visible visible
+                newCurrentRow.BringIntoView();
+              }
             }
 
             using( m_dataGridControl.SelectionChangerManager.PushUpdateSelectionSource( SelectionManager.UpdateSelectionSource.None ) )
@@ -2277,7 +2455,7 @@ namespace Xceed.Wpf.DataGrid
           }
           else
           {
-            m_dataGridControl.DelayBringIntoViewAndFocusCurrent();
+            m_dataGridControl.DelayBringIntoViewAndFocusCurrent( trigger );
           }
         }
 
@@ -2357,68 +2535,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    internal static void SynchronizeSortProperties( SortDescriptionsSyncContext syncContext, SortDescriptionCollection sortDescriptions, ColumnCollection columns )
-    {
-      if( syncContext.ProcessingSortSynchronization == true )
-        return;
-
-      //if( syncContext.IsInitializing == true )
-      //{
-      //  syncContext.SynchronizeSortDelayed = true;
-      //  return;
-      //}
-
-      try
-      {
-        syncContext.ProcessingSortSynchronization = true;
-
-        SortDescription sortDescription;
-        Collection<ColumnBase> handledColumns = new Collection<ColumnBase>();
-
-        for( int i = sortDescriptions.Count - 1; i >= 0; i-- )
-        {
-          sortDescription = sortDescriptions[ i ];
-
-          foreach( ColumnBase column in columns )
-          {
-            string fieldName = column.FieldName;
-
-            if( fieldName == sortDescription.PropertyName )
-            {
-              column.SetSortIndex( i );
-
-              switch( sortDescription.Direction )
-              {
-                case ListSortDirection.Ascending:
-                  column.SetSortDirection( SortDirection.Ascending );
-                  break;
-
-                case ListSortDirection.Descending:
-                  column.SetSortDirection( SortDirection.Descending );
-                  break;
-              }
-
-              handledColumns.Add( column );
-              break;
-            }
-          }
-        }
-
-        foreach( ColumnBase column in columns )
-        {
-          if( !handledColumns.Contains( column ) )
-          {
-            column.SetSortIndex( -1 );
-            column.SetSortDirection( SortDirection.None );
-          }
-        }
-      }
-      finally
-      {
-        syncContext.ProcessingSortSynchronization = false;
-      }
-    }
-
     internal static void UpdateGroupLevelDescriptions( GroupLevelDescriptionCollection groupLevelDescriptions,
       NotifyCollectionChangedEventArgs e, ObservableCollection<GroupDescription> groupDescriptions, ColumnCollection columns )
     {
@@ -2494,12 +2610,13 @@ namespace Xceed.Wpf.DataGrid
       if( columnsByVisiblePosition == null )
         throw new ArgumentNullException( "columnsByVisiblePosition" );
 
-      if( columns.ProcessingVisibleColumnsUpdate == true )
+      if( columns.ProcessingVisibleColumnsUpdate.IsSet )
         return;
 
-      columns.ProcessingVisibleColumnsUpdate = true;
+      if( columns.IsDeferVisibleColumnsUpdate )
+        return;
 
-      try
+      using( columns.ProcessingVisibleColumnsUpdate.Set() )
       {
         columns.NotifyVisibleColumnsUpdating();
 
@@ -2514,7 +2631,9 @@ namespace Xceed.Wpf.DataGrid
           currentColumn = columns[ currentIndex ];
 
           if( ( triggeringColumns == null ) || ( !triggeringColumns.Contains( currentColumn ) ) )
+          {
             DataGridContext.InsertColumnByVisiblePosition( columnsByVisiblePosition, currentColumn );
+          }
         }
 
         // Add the Columns which are part of the triggering columns collection
@@ -2539,7 +2658,7 @@ namespace Xceed.Wpf.DataGrid
 
             while( listNode != null )
             {
-              if( listNode.Value.VisiblePosition == column.VisiblePosition )
+              if( listNode.Value.VisiblePosition >= column.VisiblePosition )
               {
                 oldPositionNode = listNode;
                 break;
@@ -2568,6 +2687,18 @@ namespace Xceed.Wpf.DataGrid
           }
         }
 
+        var dataGridControl = columns.DataGridControl;
+        var mainColumn = columns.MainColumn;
+        if( ( dataGridControl != null ) && ( mainColumn != null ) && ( dataGridControl.AreDetailsFlatten ) )
+        {
+          var firstNode = columnsByVisiblePosition.First;
+          if( ( firstNode == null ) || ( firstNode.Value != mainColumn ) )
+          {
+            columnsByVisiblePosition.Remove( mainColumn );
+            columnsByVisiblePosition.AddFirst( mainColumn );
+          }
+        }
+
         // Fill the VisibleColumns collection and 
         // update all the columns' VisiblePosition, IsFirstVisible, and IsLastVisible properties.
         visibleColumns.InternalClear();
@@ -2579,12 +2710,18 @@ namespace Xceed.Wpf.DataGrid
         while( columnNode != null )
         {
           currentColumn = columnNode.Value;
-          currentColumn.VisiblePosition = i++;
-          currentColumn.ClearIsFirstVisible();
-          currentColumn.ClearIsLastVisible();
 
-          if( currentColumn.Visible )
-            visibleColumns.InternalAdd( currentColumn );
+          using( currentColumn.InhibitVisiblePositionChanging() )
+          {
+            currentColumn.VisiblePosition = i++;
+            currentColumn.ClearIsFirstVisible();
+            currentColumn.ClearIsLastVisible();
+
+            if( currentColumn.Visible )
+            {
+              visibleColumns.InternalAdd( currentColumn );
+            }
+          }
 
           columnNode = columnNode.Next;
         }
@@ -2595,11 +2732,7 @@ namespace Xceed.Wpf.DataGrid
           visibleColumns[ visibleColumns.Count - 1 ].SetIsLastVisible( true );
         }
 
-        columns.NotifyVisibleColumnsUpdated();
-      }
-      finally
-      {
-        columns.ProcessingVisibleColumnsUpdate = false;
+        columns.DispatchNotifyVisibleColumnsUpdated();
       }
     }
 
@@ -2609,8 +2742,7 @@ namespace Xceed.Wpf.DataGrid
     {
       DataGridContext matchingDataGridContext = null;
 
-      DataGridCollectionViewBase rootDataGridCollectionViewBase =
-        rootDataGridContext.ItemsSourceCollection as DataGridCollectionViewBase;
+      DataGridCollectionViewBase rootDataGridCollectionViewBase = rootDataGridContext.ItemsSourceCollection as DataGridCollectionViewBase;
 
       if( rootDataGridCollectionViewBase != null )
       {
@@ -2653,20 +2785,38 @@ namespace Xceed.Wpf.DataGrid
       return null;
     }
 
-    internal void SaveContainerSizeState( object item, FrameworkElement container )
+    private static void UnselectAllCells( DataGridContext dataGridContext )
     {
-      if( item == null )
+      if( dataGridContext == null )
         return;
 
-      ContainerSizeState containerSizeState = new ContainerSizeState( container );
+      var selectionManager = dataGridContext.DataGridControl.SelectionChangerManager;
+      selectionManager.Begin();
 
-      if( containerSizeState.IsEmpty() == false )
+      try
       {
-        m_sizeStateDictionary[ item ] = containerSizeState;
-
-        DataGridContext.CleanContainerSizeState( container, containerSizeState );
+        selectionManager.UnselectAllCells( dataGridContext );
       }
-      else
+      finally
+      {
+        selectionManager.End( false, false, false );
+      }
+    }
+
+    internal void SaveContainerSizeState( object item, FrameworkElement container )
+    {
+      if( item == null )
+        return;
+
+      ContainerSizeState containerSizeState = new ContainerSizeState( container );
+
+      if( containerSizeState.IsEmpty() == false )
+      {
+        m_sizeStateDictionary[ item ] = containerSizeState;
+
+        DataGridContext.CleanContainerSizeState( container, containerSizeState );
+      }
+      else
       {
         m_sizeStateDictionary.Remove( item );
       }
@@ -2722,7 +2872,7 @@ namespace Xceed.Wpf.DataGrid
 
     private void ClearViewPropertyBindings()
     {
-      foreach( ViewPropertyStruct viewProperty in m_viewProperties )
+      foreach( Views.ViewBase.ViewPropertyStruct viewProperty in m_viewProperties )
       {
         BindingOperations.ClearBinding( this, viewProperty.DependencyProperty );
         this.ClearValue( viewProperty.DependencyProperty );
@@ -2764,12 +2914,56 @@ namespace Xceed.Wpf.DataGrid
       return retval;
     }
 
+    private Binding CreateViewPropertyBinding( Views.ViewBase view, Views.ViewBase.ViewPropertyStruct viewProperty )
+    {
+      var dependencyProperty = viewProperty.DependencyProperty;
+
+      if( this.IsAFlattenDetail )
+      {
+        switch( viewProperty.FlattenDetailBindingMode )
+        {
+          case FlattenDetailBindingMode.None:
+            return null;
+
+          case FlattenDetailBindingMode.MasterOneWay:
+            {
+              var rootDataGridContext = this.RootDataGridContext;
+              Debug.Assert( ( rootDataGridContext != null ) && ( this != rootDataGridContext ) );
+              return DataGridContext.CreateViewPropertyBindingForSource( rootDataGridContext, dependencyProperty, BindingMode.OneWay );
+            }
+
+          default:
+            break;
+        }
+      }
+
+      if( viewProperty.ViewPropertyMode == ViewPropertyMode.ViewOnly )
+        return DataGridContext.CreateViewPropertyBindingForSource( view, dependencyProperty );
+
+      var detailConfiguration = this.SourceDetailConfiguration;
+      if( detailConfiguration != null )
+      {
+        var defaultDetailConfiguration = this.GetDefaultDetailConfigurationForContext();
+        if( defaultDetailConfiguration != null )
+          return DataGridContext.CreateViewPropertyBindingForSource( defaultDetailConfiguration, dependencyProperty );
+
+        return DataGridContext.CreateViewPropertyBindingForSource( detailConfiguration, dependencyProperty );
+      }
+
+      return DataGridContext.CreateViewPropertyBindingForSource( view, dependencyProperty );
+    }
+
     private static Binding CreateViewPropertyBindingForSource( object source, DependencyProperty property )
+    {
+      return DataGridContext.CreateViewPropertyBindingForSource( source, property, BindingMode.TwoWay );
+    }
+
+    private static Binding CreateViewPropertyBindingForSource( object source, DependencyProperty property, BindingMode bindingMode )
     {
       Binding binding = new Binding();
       binding.Source = source;
       binding.Path = new PropertyPath( property );
-      binding.Mode = BindingMode.TwoWay;
+      binding.Mode = bindingMode;
 
       return binding;
     }
@@ -2874,7 +3068,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private static void InsertColumnByVisiblePosition( HashedLinkedList<ColumnBase> linkedList, ColumnBase columnToInsert )
+    internal static void InsertColumnByVisiblePosition( HashedLinkedList<ColumnBase> linkedList, ColumnBase columnToInsert )
     {
       int requestedPosition = columnToInsert.VisiblePosition;
       LinkedListNode<ColumnBase> columnNode = linkedList.First;
@@ -2883,7 +3077,7 @@ namespace Xceed.Wpf.DataGrid
       ColumnBase column = null;
 
       // Append columns which VisiblePosition haven't explicitly set
-      if( columnToInsert.VisiblePosition == Int32.MaxValue )
+      if( columnToInsert.VisiblePosition == int.MaxValue )
       {
         linkedList.AddLast( columnToInsert );
         return;
@@ -2943,19 +3137,22 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public void OnGroupDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void OnGroupDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
-      this.DelayBringIntoViewAndFocusCurrent();
+      this.DelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.GroupChanged );
 
       DataGridContext.UpdateGroupLevelDescriptions( this.GroupLevelDescriptions, e, this.Items.GroupDescriptions, this.Columns );
     }
 
-    public void OnSortDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void OnSortDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
-      this.DelayBringIntoViewAndFocusCurrent();
+      this.DelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.SortChanged );
 
-      //No need to protect against SortDescriptions being null, since this reacts to the sort descriptions changes
-      DataGridContext.SynchronizeSortProperties( this.SortDescriptionsSyncContext, this.Items.SortDescriptions, this.Columns );
+      var updateColumnSortCommand = this.UpdateColumnSortCommand;
+      if( updateColumnSortCommand.CanExecute() )
+      {
+        updateColumnSortCommand.Execute();
+      }
     }
 
     private static void SetupGroupLevelDescriptionBindings( GroupLevelDescription groupLevelDescription, ColumnBase column )
@@ -2982,6 +3179,8 @@ namespace Xceed.Wpf.DataGrid
 
       Binding valueTemplateBinding = null;
       Binding valueTemplateSelectorBinding = null;
+      Binding valueStringFormatBinding = null;
+      Binding valueStringFormatCultureBinding = null;
 
       Column dataColumn = column as Column;
 
@@ -3009,6 +3208,19 @@ namespace Xceed.Wpf.DataGrid
         valueTemplateSelectorBinding.Path = new PropertyPath( ColumnBase.GroupValueTemplateSelectorProperty );
         valueTemplateSelectorBinding.Source = column;
         valueTemplateSelectorBinding.Mode = BindingMode.OneWay;
+
+        //Bind the column GroupValueStringFormat to the GroupLevelDescription string format
+        valueStringFormatBinding = new Binding();
+        valueStringFormatBinding.Path = new PropertyPath( ColumnBase.GroupValueStringFormatProperty );
+        valueStringFormatBinding.Source = column;
+        valueStringFormatBinding.Mode = BindingMode.OneWay;
+
+        //Bind the column DefaultCulture to the GroupLevelDescription string format culture
+        valueStringFormatCultureBinding = new Binding();
+        valueStringFormatCultureBinding.Path = new PropertyPath( ColumnBase.DefaultCultureProperty );
+        valueStringFormatCultureBinding.Source = column;
+        valueStringFormatCultureBinding.Mode = BindingMode.OneWay;
+        valueStringFormatCultureBinding.TargetNullValue = CultureInfo.CurrentCulture;
       }
 
       BindingOperations.SetBinding( groupLevelDescription, GroupLevelDescription.TitleProperty, titleBinding );
@@ -3016,6 +3228,16 @@ namespace Xceed.Wpf.DataGrid
       BindingOperations.SetBinding( groupLevelDescription, GroupLevelDescription.TitleTemplateSelectorProperty, titleTemplateSelectorBinding );
       BindingOperations.SetBinding( groupLevelDescription, GroupLevelDescription.ValueTemplateProperty, valueTemplateBinding );
 
+      if( valueStringFormatBinding != null )
+      {
+        BindingOperations.SetBinding( groupLevelDescription, GroupLevelDescription.ValueStringFormatProperty, valueStringFormatBinding );
+      }
+
+      if( valueStringFormatCultureBinding != null )
+      {
+        BindingOperations.SetBinding( groupLevelDescription, GroupLevelDescription.ValueStringFormatCultureProperty, valueStringFormatCultureBinding );
+      }
+
       if( valueTemplateSelectorBinding != null )
       {
         BindingOperations.SetBinding( groupLevelDescription, GroupLevelDescription.ValueTemplateSelectorProperty, valueTemplateSelectorBinding );
@@ -3025,6 +3247,7 @@ namespace Xceed.Wpf.DataGrid
     private void CreateStandaloneCollections()
     {
       m_columns = new ColumnCollection( this.DataGridControl, null );
+      VisibilityChangingEventManager.AddListener( m_columns, this );
       VisibilityChangedEventManager.AddListener( m_columns, this );
 
       m_visibleColumns = new ReadOnlyColumnCollection();
@@ -3037,8 +3260,7 @@ namespace Xceed.Wpf.DataGrid
       //Register to the Columns Collection's CollectionChanged event to manage the Removal of the CurrentColumn.
       CollectionChangedEventManager.AddListener( m_columns, this );
 
-      // Register to the VisibleColumnsChanged to update, if need be, the columns desired width
-      // when column stretching is active and there's a column reordering.
+      // Register to the VisibleColumnsChanged to update, if need be, the columns desired width when column stretching is active and there's a column reordering.
       CollectionChangedEventManager.AddListener( m_visibleColumns, this );
     }
 
@@ -3048,34 +3270,44 @@ namespace Xceed.Wpf.DataGrid
       bool needGeneratorHardReset = false;
       ColumnBase currentColumn = this.CurrentColumn;
 
+      //If( e.Action == Add ), there is nothing to do.
+
       if( e.Action == NotifyCollectionChangedAction.Reset )
       {
-        //Reset means that collection was cleared.
-        removeCurrentColumn = true;
+        var columns = this.Columns;
+
+        removeCurrentColumn = ( columns == null ) || ( !columns.Contains( currentColumn ) );
         needGeneratorHardReset = true;
       }
-      else if( ( e.Action == NotifyCollectionChangedAction.Remove ) && ( e.OldItems.Contains( currentColumn ) == true ) )
+      else if( e.Action == NotifyCollectionChangedAction.Remove )
       {
         //Remove of at least the current column
-        removeCurrentColumn = true;
-        needGeneratorHardReset = true;
+        if( e.OldItems.Contains( currentColumn ) )
+        {
+          removeCurrentColumn = true;
+          needGeneratorHardReset = true;
+        }
       }
-      else if( ( e.Action == NotifyCollectionChangedAction.Replace ) && ( e.OldItems.Contains( currentColumn ) )
-        && ( !e.NewItems.Contains( currentColumn ) ) )
+      else if( e.Action == NotifyCollectionChangedAction.Replace )
       {
         //Replace in which at least the current column was "replaced" by another (current column not present in new items )
-        removeCurrentColumn = true;
-        needGeneratorHardReset = true;
+        if( ( e.OldItems.Contains( currentColumn ) ) && ( !e.NewItems.Contains( currentColumn ) ) )
+        {
+          removeCurrentColumn = true;
+          needGeneratorHardReset = true;
+        }
+      }
+      else if( e.Action == NotifyCollectionChangedAction.Move )
+      {
+        //Nothing to do because the way to change the visible position of a column is through its VisiblePosition property.
+        return;
       }
 
-      //If we computed that current columns should be cleared
+      ColumnBase closestColumn = null;
+
       if( removeCurrentColumn )
       {
-        //The column is not in the VisibleColumns list , set CurrentColumn to null.
-        this.SetCurrentColumnCore(
-          DataGridContext.GetClosestColumn( currentColumn, this.ColumnsByVisiblePosition ),
-          false,
-          m_dataGridControl.SynchronizeSelectionWithCurrent );
+        closestColumn = DataGridContext.GetClosestColumn( currentColumn, this.ColumnsByVisiblePosition );
       }
 
       // When a column is removed, we need to clear the Generator from every container to avoid problem
@@ -3091,12 +3323,23 @@ namespace Xceed.Wpf.DataGrid
 
       this.DefaultImageColumnDetermined = false;
 
-      DataGridContext.HandleColumnsCollectionChanged(
-        e, this.Columns,
-        this.VisibleColumns as ReadOnlyColumnCollection,
-        this.ColumnsByVisiblePosition,
-        this.SortDescriptionsSyncContext,
-        this.Items.SortDescriptions );
+      var updateColumnSortCommand = this.UpdateColumnSortCommand;
+      if( updateColumnSortCommand.CanExecute() )
+      {
+        this.UpdateColumnSortCommand.Execute();
+      }
+
+      DataGridContext.HandleColumnsCollectionChanged( e, this.Columns, this.VisibleColumns as ReadOnlyColumnCollection, this.ColumnsByVisiblePosition );
+
+      if( removeCurrentColumn )
+      {
+        if( ( closestColumn != null ) && !this.Columns.Contains( closestColumn ) )
+        {
+          closestColumn = null;
+        }
+
+        this.SetCurrentColumnCore( closestColumn, false, m_dataGridControl.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.ColumnsCollectionChanged );
+      }
 
       if( m_columns != null )
       {
@@ -3132,18 +3375,6 @@ namespace Xceed.Wpf.DataGrid
       return newColumn;
     }
 
-    private void SetupCollectionsChangeNotification()
-    {
-      //register for change notification of the SortDescriptions
-      INotifyCollectionChanged notify = m_items.SortDescriptions;
-      m_sortDescriptionsCollectionChangedHandler = new WeakEventHandler<NotifyCollectionChangedEventArgs>( this.OnSortDescriptionsChanged ).Handler;
-      notify.CollectionChanged += m_sortDescriptionsCollectionChangedHandler;
-
-      //register for change notification of the GroupDescriptions
-      m_groupDescriptionsCollectionChangedHandler = new WeakEventHandler<NotifyCollectionChangedEventArgs>( this.OnGroupDescriptionsChanged ).Handler;
-      m_items.GroupDescriptions.CollectionChanged += m_groupDescriptionsCollectionChangedHandler;
-    }
-
     private void SetupViewProperties( bool initialization = false )
     {
       this.ClearViewPropertyBindings();
@@ -3152,75 +3383,25 @@ namespace Xceed.Wpf.DataGrid
       if( view == null )
         return;
 
-      // First pass, get the "View-Only" properties and bind them.
-      IEnumerable<DependencyProperty> viewProperties = view.GetViewProperties(); // retrieve the non-shared view properties.
-      foreach( DependencyProperty viewProperty in viewProperties )
-      {
-        if( viewProperty.ReadOnly == true )
-          throw new InvalidOperationException( "An attempt was made to return a read-only view property. Dependency properties returned by ViewBase.GetViewProperties() cannot be read-only." );
-
-        Binding viewPropertyBinding = DataGridContext.CreateViewPropertyBindingForSource( view, viewProperty );
-
-        BindingOperations.SetBinding( this, viewProperty, viewPropertyBinding );
-
-        //Note: we place the shared and non-shared properties in the same pool (makes no differences beyond this point ).
-        m_viewProperties.Add( new ViewPropertyStruct( ViewPropertyMode.ViewOnly, viewProperty ) );
-
-        this.NotifyPropertyChanged( viewProperty.Name );
-      }
+      var viewProperties = view.GetViewProperties()
+                             .Concat( view.GetSharedProperties() )
+                             .Concat( view.GetSharedNoFallbackProperties() );
 
-      // Second pass, get the "shared" properties and bind them.
-      viewProperties = view.GetSharedProperties(); // retrieve the shared view properties.
-      foreach( DependencyProperty viewProperty in viewProperties )
+      foreach( var viewProperty in viewProperties )
       {
-        if( viewProperty.ReadOnly == true )
-          throw new InvalidOperationException( "An attempt was made to return a read-only view property. Dependency properties returned by ViewBase.GetSharedProperties() cannot be read-only." );
+        var dependencyProperty = viewProperty.DependencyProperty;
+        Debug.Assert( !dependencyProperty.ReadOnly );
 
-        object bindingSource = view;
-        if( this.SourceDetailConfiguration != null )
+        Binding binding = this.CreateViewPropertyBinding( view, viewProperty );
+        if( binding != null )
         {
-          bindingSource = this.GetDefaultDetailConfigurationForContext();
-          if( bindingSource == null )
-          {
-            bindingSource = this.SourceDetailConfiguration;
-          }
+          BindingOperations.SetBinding( this, dependencyProperty, binding );
         }
 
-        Binding viewPropertyBinding = DataGridContext.CreateViewPropertyBindingForSource( bindingSource, viewProperty );
-
-        BindingOperations.SetBinding( this, viewProperty, viewPropertyBinding );
-
         //Note: we place the shared and non-shared properties in the same pool (makes no differences beyond this point ).
-        m_viewProperties.Add( new ViewPropertyStruct( ViewPropertyMode.Routed, viewProperty ) );
+        m_viewProperties.Add( viewProperty );
 
-        this.NotifyPropertyChanged( viewProperty.Name );
-      }
-
-      // Third pass, get the "shared no fallback" properties and bind them.
-      viewProperties = view.GetSharedNoFallbackProperties(); // retrieve the shared no fallback view properties.
-      foreach( DependencyProperty viewProperty in viewProperties )
-      {
-        if( viewProperty.ReadOnly == true )
-          throw new InvalidOperationException( "An attempt was made to return a read-only view property. Dependency properties returned by ViewBase.GetSharedProperties() cannot be read-only." );
-
-        object bindingSource = view;
-        if( this.SourceDetailConfiguration != null )
-        {
-          bindingSource = this.GetDefaultDetailConfigurationForContext();
-          if( bindingSource == null )
-          {
-            bindingSource = this.SourceDetailConfiguration;
-          }
-        }
-
-        Binding viewPropertyBinding = DataGridContext.CreateViewPropertyBindingForSource( bindingSource, viewProperty );
-
-        BindingOperations.SetBinding( this, viewProperty, viewPropertyBinding );
-
-        //Note: we place the shared and non-shared properties in the same pool (makes no differences beyond this point ).
-        m_viewProperties.Add( new ViewPropertyStruct( ViewPropertyMode.RoutedNoFallback, viewProperty ) );
-
-        this.NotifyPropertyChanged( viewProperty.Name );
+        this.NotifyPropertyChanged( dependencyProperty.Name );
       }
     }
 
@@ -3229,10 +3410,12 @@ namespace Xceed.Wpf.DataGrid
       TableflowView.SetFixedColumnSplitterTranslation( this, new TranslateTransform() );
     }
 
-    private void OnDetailConfigRequestingDelayBringIntoViewAndFocusCurrent( object sender, EventArgs e )
+    private void OnDetailConfigRequestingDelayBringIntoViewAndFocusCurrent( object sender, RequestingDelayBringIntoViewAndFocusCurrentEventArgs e )
     {
-      if( this.IsCurrent )
-        this.DelayBringIntoViewAndFocusCurrent();
+      if( !this.IsCurrent )
+        return;
+
+      this.DelayBringIntoViewAndFocusCurrent( e.Trigger );
     }
 
     private static void CleanContainerSizeState( FrameworkElement container, ContainerSizeState containerSizeState )
@@ -3285,7 +3468,7 @@ namespace Xceed.Wpf.DataGrid
 
       if( ( m_viewProperties != null ) && ( m_viewProperties.Count > 0 ) )
       {
-        if( m_viewProperties.Contains( new ViewPropertyStruct( e.Property ) ) == true )
+        if( m_viewProperties.Contains( new Views.ViewBase.ViewPropertyStruct( e.Property ) ) == true )
         {
           this.NotifyPropertyChanged( e.Property.Name );
         }
@@ -3314,7 +3497,9 @@ namespace Xceed.Wpf.DataGrid
       {
         if( sender == m_items )
         {
-          this.Items_CollectionChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+          var args = ( ( NotifyCollectionChangedEventArgs )e ).GetRangeActionOrSelf();
+
+          this.Items_CollectionChanged( sender, args );
           return true;
         }
         if( sender == this.DetailConfigurations )
@@ -3350,6 +3535,22 @@ namespace Xceed.Wpf.DataGrid
 
           return true;
         }
+        else if( sender == m_items.SortDescriptions )
+        {
+          this.OnSortDescriptionsChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+          return true;
+        }
+        else if( sender == m_items.GroupDescriptions )
+        {
+          this.OnGroupDescriptionsChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+          return true;
+        }
+      }
+      else if( managerType == typeof( VisibilityChangingEventManager ) )
+      {
+        DataGridContext.UnselectAllCells( this );
+
+        return true;
       }
       else if( managerType == typeof( VisibilityChangedEventManager ) )
       {
@@ -3362,17 +3563,7 @@ namespace Xceed.Wpf.DataGrid
       }
       else if( managerType == typeof( VisibleColumnsUpdatingEventManager ) )
       {
-        SelectionManager selectionManager = m_dataGridControl.SelectionChangerManager;
-        selectionManager.Begin();
-
-        try
-        {
-          selectionManager.UnselectAllCells( this );
-        }
-        finally
-        {
-          selectionManager.End( false, false, false );
-        }
+        DataGridContext.UnselectAllCells( this );
 
         return true;
       }
@@ -3394,6 +3585,28 @@ namespace Xceed.Wpf.DataGrid
         this.DefaultImageColumnDetermined = false;
         return true;
       }
+      else if( managerType == typeof( PreBatchCollectionChangedEventManager ) )
+      {
+        Debug.Assert( m_deferSelectionChangedOnItemsCollectionChanged == null );
+
+        if( m_deferSelectionChangedOnItemsCollectionChanged == null )
+        {
+          m_deferSelectionChangedOnItemsCollectionChanged = new DeferSelectionChangedOnItemsCollectionChangedDisposable( this );
+        }
+
+        return true;
+      }
+      else if( managerType == typeof( PostBatchCollectionChangedEventManager ) )
+      {
+        var disposable = m_deferSelectionChangedOnItemsCollectionChanged;
+        if( disposable != null )
+        {
+          m_deferSelectionChangedOnItemsCollectionChanged = null;
+          disposable.Dispose();
+        }
+
+        return true;
+      }
       else if( managerType == typeof( RealizedContainersRequestedEventManager ) )
       {
         RealizedContainersRequestedEventArgs eventArgs = ( RealizedContainersRequestedEventArgs )e;
@@ -3458,11 +3671,41 @@ namespace Xceed.Wpf.DataGrid
       }
       else if( managerType == typeof( ItemsSourceChangeCompletedEventManager ) )
       {
+        var dataGridCollectionViewBase = m_dataGridControlItemsSource as DataGridCollectionViewBase;
+
         // GenerateColumnsFromItemsSourceFields is already done in DataGridControl.ProcessDelayedItemsSourceChanged
         // no need to do it here.
-        this.UnhookToItemPropertiesChanged( m_dataGridControlItemsSource as DataGridCollectionViewBase );
+        this.UnhookToItemPropertiesChanged( dataGridCollectionViewBase );
+
+        if( dataGridCollectionViewBase != null )
+        {
+          PreBatchCollectionChangedEventManager.RemoveListener( dataGridCollectionViewBase, this );
+          PostBatchCollectionChangedEventManager.RemoveListener( dataGridCollectionViewBase, this );
+        }
+
         m_dataGridControlItemsSource = m_dataGridControl.ItemsSource;
+
+        dataGridCollectionViewBase = m_dataGridControlItemsSource as DataGridCollectionViewBase;
+        if( dataGridCollectionViewBase != null )
+        {
+          PreBatchCollectionChangedEventManager.AddListener( dataGridCollectionViewBase, this );
+          PostBatchCollectionChangedEventManager.AddListener( dataGridCollectionViewBase, this );
+        }
+
         this.HookToItemPropertiesChanged();
+
+        //If this is the master level DataGridContext
+        if( m_parentDataGridContext == null )
+        {
+          //And if this is a DataGridCollectionView
+          DataGridCollectionView collectionView = m_dataGridControlItemsSource as DataGridCollectionView;
+          if( collectionView != null )
+          {
+            //Set its dataGridContext so it can propagate a DeferRefresh to details' DataGridCollectionViews
+            collectionView.PrepareRootContextForDeferRefresh( this );
+          }
+        }
+
         return true;
       }
 
@@ -3475,7 +3718,7 @@ namespace Xceed.Wpf.DataGrid
 
     private BitVector32 m_flags = new BitVector32();
     private CurrencyManager m_currencyManager;
-    private List<ViewPropertyStruct> m_viewProperties = new List<ViewPropertyStruct>();
+    private List<Views.ViewBase.ViewPropertyStruct> m_viewProperties = new List<Views.ViewBase.ViewPropertyStruct>();
     PropertyDescriptorCollection m_viewPropertiesDescriptors; // = null
     private DefaultDetailConfiguration m_defaultDetailConfiguration; // = null
     private RecyclingManager m_recyclingManager; // = null
@@ -3483,9 +3726,7 @@ namespace Xceed.Wpf.DataGrid
     private int m_deferRestoreStateCount; // = 0;
     private Dictionary<object, ContainerSizeState> m_sizeStateDictionary = new Dictionary<object, ContainerSizeState>();
     private IEnumerable m_dataGridControlItemsSource;
-
-    private NotifyCollectionChangedEventHandler m_sortDescriptionsCollectionChangedHandler;
-    private NotifyCollectionChangedEventHandler m_groupDescriptionsCollectionChangedHandler;
+    private DeferSelectionChangedOnItemsCollectionChangedDisposable m_deferSelectionChangedOnItemsCollectionChanged; // = null
 
     #endregion
 
@@ -3659,76 +3900,116 @@ namespace Xceed.Wpf.DataGrid
 
     #region DeferRestoreStateDisposable Private Class
 
-    private class DeferRestoreStateDisposable : IDisposable
+    private sealed class DeferRestoreStateDisposable : IDisposable
     {
-      public DeferRestoreStateDisposable( DataGridContext dataGridContext )
+      internal DeferRestoreStateDisposable( DataGridContext dataGridContext )
       {
-        m_dataGridContext = dataGridContext;
-        m_dataGridContext.m_deferRestoreStateCount++;
-      }
+        if( dataGridContext == null )
+          throw new ArgumentNullException( "dataGridContext" );
 
-      private DataGridContext m_dataGridContext;
+        m_dataGridContext = new WeakReference( dataGridContext );
 
-      #region IDisposable Members
+        Interlocked.Increment( ref dataGridContext.m_deferRestoreStateCount );
+      }
 
-      public void Dispose()
+      void IDisposable.Dispose()
       {
-        if( m_dataGridContext == null )
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var wr = m_dataGridContext;
+        if( Interlocked.CompareExchange<WeakReference>( ref m_dataGridContext, null, wr ) == null )
           return;
 
-        m_dataGridContext.m_deferRestoreStateCount--;
+        var dataGridContext = ( DataGridContext )wr.Target;
+        if( dataGridContext == null )
+          return;
 
-        if( m_dataGridContext.m_deferRestoreStateCount == 0 )
-        {
-          m_dataGridContext.DataGridControl.RestoreDataGridContextState( m_dataGridContext );
-        }
+        if( Interlocked.Decrement( ref dataGridContext.m_deferRestoreStateCount ) != 0 )
+          return;
 
-        m_dataGridContext = null;
+        Debug.Assert( disposing );
+
+        var dataGridControl = dataGridContext.DataGridControl;
+        dataGridControl.RestoreDataGridContextState( dataGridContext );
       }
 
-      #endregion
+      ~DeferRestoreStateDisposable()
+      {
+        this.Dispose( false );
+      }
+
+      private WeakReference m_dataGridContext;
     }
 
     #endregion
 
-    #region ViewPropertyStruct Private Struct
+    #region DeferSelectionChangedOnItemsCollectionChangedDisposable Private Class
 
-    private struct ViewPropertyStruct
+    private sealed class DeferSelectionChangedOnItemsCollectionChangedDisposable : IDisposable
     {
-      public ViewPropertyStruct( ViewPropertyMode viewPropertyMode, DependencyProperty dependencyProperty )
+      internal DeferSelectionChangedOnItemsCollectionChangedDisposable( DataGridContext dataGridContext )
       {
-        if( dependencyProperty == null )
-          throw new ArgumentNullException( "dependencyProperty" );
+        if( dataGridContext == null )
+          throw new ArgumentNullException( "dataGridContext" );
 
-        this.ViewPropertyMode = viewPropertyMode;
-        this.DependencyProperty = dependencyProperty;
+        m_dataGridContext = new WeakReference( dataGridContext );
       }
 
-      public ViewPropertyStruct( DependencyProperty dependencyProperty )
-        : this( ViewPropertyMode.None, dependencyProperty )
+      internal void Queue( NotifyCollectionChangedEventArgs e )
       {
-      }
+        if( e == null )
+          return;
 
-      public ViewPropertyMode ViewPropertyMode;
-      public DependencyProperty DependencyProperty;
+        if( m_eventArgs != null )
+        {
+          if( m_eventArgs.Action != NotifyCollectionChangedAction.Reset )
+          {
+            m_eventArgs = new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset );
+          }
+        }
+        else
+        {
+          m_eventArgs = e;
+        }
+      }
 
+      public void Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
 
-      public override bool Equals( object obj )
+      private void Dispose( bool disposing )
       {
-        ViewPropertyStruct refStruct = ( ViewPropertyStruct )obj;
+        if( !disposing )
+          return;
 
-        if( this.DependencyProperty == refStruct.DependencyProperty )
-        {
-          return true;
-        }
+        var wr = m_dataGridContext;
+        if( Interlocked.CompareExchange<WeakReference>( ref m_dataGridContext, null, wr ) == null )
+          return;
 
-        return false;
+        var eventArgs = m_eventArgs;
+        if( eventArgs == null )
+          return;
+
+        var dataGridContext = ( DataGridContext )wr.Target;
+        if( dataGridContext == null )
+          return;
+
+        dataGridContext.UpdateSelectionAfterSourceCollectionChanged( eventArgs );
       }
 
-      public override int GetHashCode()
+      ~DeferSelectionChangedOnItemsCollectionChangedDisposable()
       {
-        return this.DependencyProperty.GetHashCode();
+        this.Dispose( false );
       }
+
+      private WeakReference m_dataGridContext;
+      private NotifyCollectionChangedEventArgs m_eventArgs; //null
     }
 
     #endregion
@@ -3902,7 +4183,7 @@ namespace Xceed.Wpf.DataGrid
           dependencyObject.SetValue( m_dp, value );
           return;
         }
-        throw new DataGridInternalException();
+        throw new ArgumentException( "SetValue was called for an object which is not a DependencyObject.", component.ToString() );
       }
 
       public override bool ShouldSerializeValue( object component )
@@ -3913,6 +4194,405 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region DataGridContextToggleColumnSortCommand Private Class
+
+    private sealed class DataGridContextToggleColumnSortCommand : ToggleColumnSortCommand
+    {
+      #region Constructor
+
+      internal DataGridContextToggleColumnSortCommand( DataGridContext dataGridContext )
+        : base()
+      {
+        ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+        m_dataGridContext = new WeakReference( dataGridContext );
+      }
+
+      #endregion
+
+      #region Properties
+
+      #region CanSort Protected Property
+
+      protected override bool CanSort
+      {
+        get
+        {
+          var dataGridContext = this.DataGridContext;
+          if( this.DataGridContext == null )
+            return false;
+
+          return this.DataGridContext.Items.CanSort;
+        }
+      }
+
+      #endregion
+
+      #region Columns Protected Property
+
+      protected override ColumnCollection Columns
+      {
+        get
+        {
+          return this.DataGridContext.Columns;
+        }
+      }
+
+      #endregion
+
+      #region DataGridContext Protected Property
+
+      protected override DataGridContext DataGridContext
+      {
+        get
+        {
+          return ( m_dataGridContext != null ) ? m_dataGridContext.Target as DataGridContext : null;
+        }
+      }
+
+      private readonly WeakReference m_dataGridContext;
+
+      #endregion
+
+      #region MaxSortLevels Protected Property
+
+      protected override int MaxSortLevels
+      {
+        get
+        {
+          return this.DataGridContext.MaxSortLevels;
+        }
+      }
+
+      #endregion
+
+      #region SortDescriptions Protected Property
+
+      protected override SortDescriptionCollection SortDescriptions
+      {
+        get
+        {
+          return this.DataGridContext.Items.SortDescriptions;
+        }
+      }
+
+      #endregion
+
+      #endregion
+
+      #region Methods Override
+
+      protected override bool CanExecuteCore( ColumnBase column, bool resetSort )
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return false;
+
+        return base.CanExecuteCore( column, resetSort );
+      }
+
+      protected override void ValidateToggleColumnSort()
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return;
+
+        Debug.Assert( !dataGridContext.IsAFlattenDetail, "A flatten detail should not be able to toggle the column sort direction." );
+      }
+
+      protected override SortDescriptionsSyncContext GetSortDescriptionsSyncContext()
+      {
+        var dataGridContext = this.DataGridContext;
+
+        ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+        return dataGridContext.SortDescriptionsSyncContext;
+      }
+
+      protected override void ValidateSynchronizationContext( SynchronizationContext synchronizationContext )
+      {
+        var dataGridContext = this.DataGridContext;
+        ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+        if( !synchronizationContext.Own )
+          throw new DataGridInternalException( "The column is already being processed.", dataGridContext.DataGridControl );
+      }
+
+      protected override void DeferRestoreStateOnLevel( Disposer disposer )
+      {
+        var dataGridContext = this.DataGridContext;
+        ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+        ToggleColumnSortCommand.DeferRestoreStateOnLevel( disposer, dataGridContext );
+      }
+
+      protected override IDisposable SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers triggers )
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return null;
+
+        return this.DataGridContext.SetQueueBringIntoViewRestrictions( triggers );
+      }
+
+      protected override bool TryDeferResortSourceDetailConfiguration( out IDisposable defer )
+      {
+        var dataGridContext = this.DataGridContext;
+        ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+        return this.TryDeferResort( dataGridContext.SourceDetailConfiguration, out defer );
+      }
+
+      protected override IDisposable DeferResortHelperItemsSourceCollection()
+      {
+        var dataGridContext = this.DataGridContext;
+        ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+        return this.DeferResortHelper( dataGridContext.ItemsSourceCollection, dataGridContext.Items );
+      }
+
+      protected override void UpdateColumnSort()
+      {
+        var dataGridContext = this.DataGridContext;
+        Debug.Assert( dataGridContext != null );
+
+        base.UpdateColumnSort();
+      }
+
+      #endregion
+    }
+
+    #endregion
+
+    #region DataGridContextUpdateColumnSortCommand Private Class
+
+    private sealed class DataGridContextUpdateColumnSortCommand : UpdateColumnSortCommand
+    {
+      #region Validation Methods
+
+      private static void ThrowIfDetailDataGridContext( DataGridContext dataGridContext, string paramName )
+      {
+        Debug.Assert( dataGridContext != null );
+
+        if( dataGridContext.ParentDataGridContext != null )
+          throw new ArgumentException( "The DataGridContext is not the topmost DataGridContext.", paramName );
+      }
+
+      #endregion
+
+      #region Constructor
+
+      internal DataGridContextUpdateColumnSortCommand( DataGridContext dataGridContext )
+      {
+        DataGridContextUpdateColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+        m_dataGridContext = new WeakReference( dataGridContext );
+      }
+
+      #endregion
+
+      #region SortDescriptionsSyncContext Protected Property
+
+      protected override SortDescriptionsSyncContext SortDescriptionsSyncContext
+      {
+        get
+        {
+          var dataGridContext = this.DataGridContext;
+          if( dataGridContext == null )
+            return null;
+
+          return dataGridContext.SortDescriptionsSyncContext;
+        }
+      }
+
+      #endregion
+
+      #region DataGridContext Private Property
+
+      private DataGridContext DataGridContext
+      {
+        get
+        {
+          return m_dataGridContext.Target as DataGridContext;
+        }
+      }
+
+      private readonly WeakReference m_dataGridContext;
+
+      #endregion
+
+      protected override bool CanExecuteCore()
+      {
+        return ( this.DataGridContext != null );
+      }
+
+      protected override void ExecuteCore()
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return;
+
+        var detailConfiguration = dataGridContext.SourceDetailConfiguration;
+        if( detailConfiguration != null )
+        {
+          this.Update( detailConfiguration );
+        }
+        // The current DataGridContext is the top most DataGridContext;
+        else
+        {
+          this.Update( dataGridContext );
+        }
+      }
+
+      private void Update( DataGridContext dataGridContext )
+      {
+        ColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+        DataGridContextUpdateColumnSortCommand.ThrowIfDetailDataGridContext( dataGridContext, "dataGridContext" );
+
+        // The sort order of the flatten details is driven by the master.  A sort order change
+        // on the master must be reflected in the details.
+        if( dataGridContext.AreDetailsFlatten )
+        {
+          foreach( var detailConfiguration in dataGridContext.DetailConfigurations )
+          {
+            this.Update( detailConfiguration, true );
+          }
+        }
+
+        using( var synchronizationContext = this.StartSynchronizing( dataGridContext.SortDescriptionsSyncContext ) )
+        {
+          this.SynchronizeColumnSort(
+            synchronizationContext,
+            dataGridContext.Items.SortDescriptions,
+            dataGridContext.Columns );
+        }
+      }
+
+      private void Update( DetailConfiguration detailConfiguration )
+      {
+        this.Update( detailConfiguration, false );
+      }
+
+      private void Update( DetailConfiguration detailConfiguration, bool recursive )
+      {
+        ColumnSortCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" );
+
+        if( recursive )
+        {
+          foreach( var children in detailConfiguration.DetailConfigurations )
+          {
+            this.Update( children, true );
+          }
+        }
+
+        var command = detailConfiguration.UpdateColumnSortCommand;
+        if( command.CanExecute() )
+        {
+          command.Execute();
+        }
+      }
+    }
+
+    #endregion
+
+    #region DataGridContextAddGroupCommand Private Class
+
+    private sealed class DataGridContextAddGroupCommand : ColumnAddGroupCommand
+    {
+      #region Constructor
+
+      internal DataGridContextAddGroupCommand( DataGridContext dataGridContext )
+      {
+        DataGridContextAddGroupCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+        m_dataGridContext = new WeakReference( dataGridContext );
+      }
+
+      #endregion
+
+      #region GroupDescriptions Protected Property
+
+      protected override ObservableCollection<GroupDescription> GroupDescriptions
+      {
+        get
+        {
+          var dataGridContext = this.DataGridContext;
+          if( dataGridContext == null )
+            return null;
+
+          return dataGridContext.Items.GroupDescriptions;
+        }
+      }
+
+      #endregion
+
+      #region DataGridContext Private Property
+
+      private DataGridContext DataGridContext
+      {
+        get
+        {
+          return m_dataGridContext.Target as DataGridContext;
+        }
+      }
+
+      private readonly WeakReference m_dataGridContext;
+
+      #endregion
+
+      protected override string GetColumnName( ColumnBase column )
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return null;
+
+        var fieldNameMap = dataGridContext.ItemPropertyMap;
+        string fieldName;
+
+        if( !fieldNameMap.TryGetItemPropertyName( column, out fieldName ) )
+          return null;
+
+        return fieldName;
+      }
+
+      protected override GroupDescription GetGroupDescription( ColumnBase column )
+      {
+        if( this.DataGridContext == null )
+          return null;
+
+        return base.GetGroupDescription( column );
+      }
+
+      protected override GroupConfiguration GetGroupConfiguration( ColumnBase column )
+      {
+        if( this.DataGridContext == null )
+          return null;
+
+        return base.GetGroupConfiguration( column );
+      }
+
+      protected override bool CanExecuteCore( ColumnBase column, int index )
+      {
+        if( this.DataGridContext == null )
+          return false;
+
+        return base.CanExecuteCore( column, index );
+      }
+
+      protected override void ExecuteCore( ColumnBase column, int index )
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return;
+
+        using( dataGridContext.SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged ) )
+        {
+          base.ExecuteCore( column, index );
+        }
+      }
+    }
+
+    #endregion
+
     #region DataGridContextFlags Private Enum
 
     [Flags]
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridControl.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridControl.cs
index 746cba3e..ffe2998b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridControl.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridControl.cs
@@ -22,7 +22,10 @@ using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Data;
 using System.Diagnostics;
+using System.Security;
+using System.Security.Permissions;
 using System.Windows;
+using System.Windows.Automation.Peers;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using System.Windows.Data;
@@ -30,25 +33,11 @@ using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Threading;
-using Xceed.Wpf.DataGrid.Views;
-using Xceed.Wpf.DataGrid.Print;
 using Xceed.Utils.Wpf;
-using Xceed.Utils.Collections;
-using System.Security;
-using System.Security.Permissions;
-using System.Windows.Automation.Peers;
+using Xceed.Utils.Wpf.DragDrop;
 using Xceed.Wpf.DataGrid.Automation;
-using Xceed.Wpf.DataGrid.Settings;
 using Xceed.Wpf.DataGrid.Export;
-using Xceed.Utils.Wpf.DragDrop;
-using System.Windows.Xps.Packaging;
-using System.IO;
-using System.IO.Packaging;
-using System.Windows.Xps;
-using System.Windows.Markup;
-using System.Printing;
-using System.Windows.Media.Imaging;
-using Xceed.Wpf.DataGrid.Utils;
+using Xceed.Wpf.DataGrid.Views;
 using Xceed.Wpf.Toolkit.Core;
 
 namespace Xceed.Wpf.DataGrid
@@ -85,25 +74,6 @@ namespace Xceed.Wpf.DataGrid
       DataGridControl.HasExpandedDetailsProperty = DataGridControl.HasExpandedDetailsPropertyKey.DependencyProperty;
     }
 
-    private static object ItemsSourceCoerceCallback( DependencyObject sender, object value )
-    {
-      DataGridControl dataGridControl = sender as DataGridControl;
-
-      // Ensure to EndEdit the currently edited container
-      object currentItem = dataGridControl.CurrentContext.InternalCurrentItem;
-
-      if( currentItem != null )
-      {
-        // Use Row.FromContainer to ensure Rows in Header/Footers are returned correctly
-        Row row = Row.FromContainer( dataGridControl.CurrentContext.GetContainerFromItem( currentItem ) );
-
-        if( ( row != null ) && ( row.IsBeingEdited ) )
-          row.CancelEdit();
-      }
-
-      return value;
-    }
-
     public DataGridControl()
     {
       m_selectionChangerManager = new SelectionManager( this );
@@ -114,7 +84,6 @@ namespace Xceed.Wpf.DataGrid
       DataGridControl.SetFixedItem( this, DataGridControl.NotSet );
 
       this.SetDetailConfigurations( new DetailConfigurationCollection( this, null ) );
-
       this.DetailConfigurations.CollectionChanged += this.OnDetailConfigurationsChanged;
 
       this.CommandBindings.Add( new CommandBinding( DataGridCommands.ExpandGroup, this.OnExpandGroupExecuted, this.OnExpandGroupCanExecute ) );
@@ -165,7 +134,6 @@ namespace Xceed.Wpf.DataGrid
       if( DesignerProperties.GetIsInDesignMode( this ) )
       {
         // Workaround for VS2008's know issue (the DataGrid's Template is not active).
-        // TODO (case 117288): Remove when the issue will be corrected.
         this.ClipToBounds = true;
       }
 
@@ -202,25 +170,22 @@ namespace Xceed.Wpf.DataGrid
           m_columnsInitDisposable = null;
         }
 
-        // Reassociate the default view to the grid at the last moment so that 
-        // eventual implicit style declarations for the default View in user applications 
-        // will work.
+        // Reassociate the default view to the grid at the last moment so that  eventual implicit style declarations for the default View in user applications will work.
         if( this.View == null )
         {
-          this.OnViewChanged( null, null );
+          this.OnViewChanged( null, this.GetDefaultView() );
         }
 
-
         if( this.ItemsSourceChangedDelayed )
         {
           this.ItemsSourceChangedDelayed = false;
           this.ProcessDelayedItemsSourceChanged();
         }
 
-        //see if any of the GroupLevelDescriptions are matched to a column but aren't bound ( case 102437 ) and
-        //update then (bind them) if necessary
+        //see if any of the GroupLevelDescriptions are matched to a column but aren't bound ( case 102437 ) and update then (bind them) if necessary
         this.DataGridContext.SetupTitleBindingForGroupLevelDescriptions();
 
+
         // The FrameworkElement implementation does not support nested BeginInit/EndInit
         base.EndInit();
       }
@@ -304,6 +269,14 @@ namespace Xceed.Wpf.DataGrid
       FrameworkElementUnloadedEventManager.RemoveListener( parentWindow, this );
     }
 
+    internal bool IsInInit
+    {
+      get
+      {
+        return ( m_columnsInitDisposable != null );
+      }
+    }
+
     #endregion INITIALIZATION
 
     #region ParentDataGridControl Attached Property
@@ -332,9 +305,6 @@ namespace Xceed.Wpf.DataGrid
 
     public static DataGridContext GetDataGridContext( DependencyObject obj )
     {
-      if( obj == null )
-        throw new ArgumentNullException( "obj" );
-
       return ( DataGridContext )obj.GetValue( DataGridControl.DataGridContextProperty );
     }
 
@@ -373,6 +343,31 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion Container Attached Property
 
+    #region IsContainerPrepared Attached Property
+
+    private static readonly DependencyPropertyKey IsContainerPreparedPropertyKey = DependencyProperty.RegisterAttachedReadOnly(
+      "IsContainerPrepared", typeof( bool ), typeof( DataGridControl ),
+      new FrameworkPropertyMetadata( false ) );
+
+    private static readonly DependencyProperty IsContainerPreparedProperty = DataGridControl.IsContainerPreparedPropertyKey.DependencyProperty;
+
+    internal static bool GetIsContainerPrepared( DependencyObject obj )
+    {
+      return ( bool )obj.GetValue( DataGridControl.IsContainerPreparedProperty );
+    }
+
+    private static void SetIsContainerPrepared( DependencyObject obj, bool value )
+    {
+      obj.SetValue( DataGridControl.IsContainerPreparedPropertyKey, value );
+    }
+
+    private static void ClearIsContainerPrepared( DependencyObject obj )
+    {
+      obj.ClearValue( DataGridControl.IsContainerPreparedPropertyKey );
+    }
+
+    #endregion IsContainerPrepared Attached Property
+
     #region StatContext Attached Property
 
     internal static readonly DependencyPropertyKey StatContextPropertyKey = DependencyProperty.RegisterAttachedReadOnly(
@@ -568,8 +563,11 @@ namespace Xceed.Wpf.DataGrid
     #region ValidationMode Property
 
     [Obsolete( "The ValidationMode is obsolete. Refer to the Editing and Validating Data topic in the documentation.", true )]
-    public static readonly DependencyProperty ValidationModeProperty =
-        DependencyProperty.Register( "ValidationMode", typeof( ValidationMode ), typeof( DataGridControl ), new UIPropertyMetadata( ValidationMode.RowEndingEdit ) );
+    public static readonly DependencyProperty ValidationModeProperty = DependencyProperty.Register(
+      "ValidationMode",
+      typeof( ValidationMode ),
+      typeof( DataGridControl ),
+      new UIPropertyMetadata( ValidationMode.RowEndingEdit ) );
 
     [Obsolete( "The ValidationMode is obsolete. Refer to the Editing and Validating Data topic in the documentation.", true )]
     [Browsable( false )]
@@ -578,12 +576,10 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return ( ValidationMode )this.GetValue( DataGridControl.ValidationModeProperty );
+        return ValidationMode.RowEndingEdit;
       }
-
       set
       {
-        this.SetValue( DataGridControl.ValidationModeProperty, value );
       }
     }
 
@@ -826,7 +822,9 @@ namespace Xceed.Wpf.DataGrid
     #region SelectionMode Property
 
     public static readonly DependencyProperty SelectionModeProperty =
-        DependencyProperty.Register( "SelectionMode", typeof( SelectionMode ), typeof( DataGridControl ), new UIPropertyMetadata( SelectionMode.Extended ) );
+        DependencyProperty.Register( "SelectionMode", typeof( SelectionMode ), typeof( DataGridControl ),
+        new UIPropertyMetadata( SelectionMode.Extended,
+          new PropertyChangedCallback( DataGridControl.OnSelectionModeChanged ) ) );
 
     public SelectionMode SelectionMode
     {
@@ -848,6 +846,10 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private static void OnSelectionModeChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+    }
+
     #endregion SelectionMode Property
 
     #region SelectionUnit Property
@@ -923,7 +925,7 @@ namespace Xceed.Wpf.DataGrid
         if( value == this.DataGridContext.CurrentItem )
           return;
 
-        this.DataGridContext.SetCurrent( value, null, null, this.DataGridContext.CurrentColumn, false, true, this.SynchronizeSelectionWithCurrent );
+        this.DataGridContext.SetCurrent( value, null, null, this.DataGridContext.CurrentColumn, false, true, this.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CurrentItemChanged );
       }
     }
 
@@ -950,7 +952,7 @@ namespace Xceed.Wpf.DataGrid
         if( value == this.DataGridContext.CurrentColumn )
           return;
 
-        this.DataGridContext.SetCurrent( this.DataGridContext.InternalCurrentItem, null, null, value, false, true, this.SynchronizeSelectionWithCurrent );
+        this.DataGridContext.SetCurrent( this.DataGridContext.InternalCurrentItem, null, null, value, false, true, this.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.CurrentColumnChanged );
       }
     }
 
@@ -1156,6 +1158,28 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion ReadOnly Property
 
+    #region AutoScrollCurrentItem Property
+
+    public static readonly DependencyProperty AutoScrollCurrentItemProperty = DependencyProperty.Register(
+      "AutoScrollCurrentItem",
+      typeof( AutoScrollCurrentItemTriggers ),
+      typeof( DataGridControl ),
+      new PropertyMetadata( AutoScrollCurrentItemTriggers.All ) );
+
+    public AutoScrollCurrentItemTriggers AutoScrollCurrentItem
+    {
+      get
+      {
+        return ( AutoScrollCurrentItemTriggers )this.GetValue( DataGridControl.AutoScrollCurrentItemProperty );
+      }
+      set
+      {
+        this.SetValue( DataGridControl.AutoScrollCurrentItemProperty, value );
+      }
+    }
+
+    #endregion AutoScrollCurrentItem Property
+
     #region EditTriggers Property
 
     public static readonly DependencyProperty EditTriggersProperty = DependencyProperty.RegisterAttached(
@@ -1239,7 +1263,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region ItemsPanel override
 
-    [Obsolete( "The ItemsPanel property  is obsolete and has been replaced by the DataGridItemsHost (and derived) classes.", false )]
+    [Obsolete( "The ItemsPanel property is obsolete and has been replaced by the DataGridItemsHost (and derived) classes.", false )]
     [Browsable( false )]
     [EditorBrowsable( EditorBrowsableState.Never )]
     public new ItemsPanelTemplate ItemsPanel
@@ -1308,8 +1332,8 @@ namespace Xceed.Wpf.DataGrid
 
     #region IsFixedHeadersHost Attached Property
 
-    public static readonly DependencyProperty IsFixedHeadersHostProperty =
-        DependencyProperty.RegisterAttached( "IsFixedHeadersHost", typeof( bool ), typeof( DataGridControl ), new UIPropertyMetadata( false, new PropertyChangedCallback( OnIsFixedHeadersHost_Changed ) ) );
+    public static readonly DependencyProperty IsFixedHeadersHostProperty = DependencyProperty.RegisterAttached(
+      "IsFixedHeadersHost", typeof( bool ), typeof( DataGridControl ), new UIPropertyMetadata( false, new PropertyChangedCallback( OnIsFixedHeadersHost_Changed ) ) );
 
     public static bool GetIsFixedHeadersHost( DependencyObject obj )
     {
@@ -1405,19 +1429,18 @@ namespace Xceed.Wpf.DataGrid
 
     #region View Property
 
-    public static readonly DependencyProperty ViewProperty =
-            DependencyProperty.Register(
-            "View",
-            typeof( Xceed.Wpf.DataGrid.Views.UIViewBase ),
-            typeof( DataGridControl ),
-            new UIPropertyMetadata( null, new PropertyChangedCallback( DataGridControl.OnViewChanged ), new CoerceValueCallback( ViewCoerceValueCallback ) ) );
+    public static readonly DependencyProperty ViewProperty = DependencyProperty.Register(
+      "View",
+      typeof( Xceed.Wpf.DataGrid.Views.UIViewBase ),
+      typeof( DataGridControl ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( DataGridControl.OnViewChanged ), new CoerceValueCallback( DataGridControl.ViewCoerceValueCallback ) ) );
 
     [TypeConverter( typeof( Markup.ViewConverter ) )]
     public Xceed.Wpf.DataGrid.Views.UIViewBase View
     {
       get
       {
-        return m_cachedView; 
+        return ( Xceed.Wpf.DataGrid.Views.UIViewBase )this.GetValue( DataGridControl.ViewProperty );
       }
       set
       {
@@ -1430,7 +1453,9 @@ namespace Xceed.Wpf.DataGrid
 
     private static object ViewCoerceValueCallback( DependencyObject sender, object value )
     {
-      Xceed.Wpf.DataGrid.Views.UIViewBase view = value as Xceed.Wpf.DataGrid.Views.UIViewBase;
+      var view = value as Xceed.Wpf.DataGrid.Views.UIViewBase;
+      if( ( view == null ) && ( sender is DataGridControl ) )
+        return ( ( DataGridControl )sender ).GetDefaultView();
 
       if( view != null )
       {
@@ -1448,8 +1473,8 @@ namespace Xceed.Wpf.DataGrid
       //for case 1044618: leave edition mode (cancel) when view changes
       grid.CancelEdit();
 
-      Xceed.Wpf.DataGrid.Views.ViewBase oldView = ( Xceed.Wpf.DataGrid.Views.ViewBase )e.OldValue;
-      Xceed.Wpf.DataGrid.Views.ViewBase newView = ( Xceed.Wpf.DataGrid.Views.ViewBase )e.NewValue;
+      var oldView = ( Xceed.Wpf.DataGrid.Views.ViewBase )e.OldValue;
+      var newView = ( Xceed.Wpf.DataGrid.Views.ViewBase )e.NewValue;
 
       grid.OnViewChanged( oldView, newView );
     }
@@ -1463,26 +1488,20 @@ namespace Xceed.Wpf.DataGrid
         oldView.FixedFooters.CollectionChanged -= new NotifyCollectionChangedEventHandler( this.View_FixedFootersCollectionChanged );
       }
 
-      if( newView == null )
+      object newDefaultStyleKey = null;
+
+      if( newView != null )
       {
-        newView = this.GetDefaultView();
-      }
+        newView.ThemeChanged += new DependencyPropertyChangedEventHandler( this.View_ThemeChanged );
+        newView.FixedHeaders.CollectionChanged += new NotifyCollectionChangedEventHandler( this.View_FixedHeadersCollectionChanged );
+        newView.FixedFooters.CollectionChanged += new NotifyCollectionChangedEventHandler( this.View_FixedFootersCollectionChanged );
 
-      newView.ThemeChanged += new DependencyPropertyChangedEventHandler( this.View_ThemeChanged );
-      newView.FixedHeaders.CollectionChanged += new NotifyCollectionChangedEventHandler( this.View_FixedHeadersCollectionChanged );
-      newView.FixedFooters.CollectionChanged += new NotifyCollectionChangedEventHandler( this.View_FixedFootersCollectionChanged );
+        newDefaultStyleKey = newView.GetDefaultStyleKey( typeof( DataGridControl ) );
+      }
 
       // Cache if the view requires to preserve container size
-      this.ViewPreservesContainerSize = ( newView != null )
-        ? newView.PreserveContainerSize
-        : true;
-
-      if( ( newView == null ) || ( newView is UIViewBase ) )
-      {
-        this.m_cachedView = ( UIViewBase )newView;
-      }
+      this.ViewPreservesContainerSize = ( newView != null ) ? newView.PreserveContainerSize : true;
 
-      object newDefaultStyleKey = newView.GetDefaultStyleKey( typeof( DataGridControl ) );
       if( !object.Equals( newDefaultStyleKey, this.DefaultStyleKey ) )
       {
         this.ClearValue( FrameworkElement.DefaultStyleKeyProperty );
@@ -1495,15 +1514,15 @@ namespace Xceed.Wpf.DataGrid
 
       this.InvalidateViewStyle();
 
-      // We cannot be sure that the grid elements default style key are different with
-      // this new View/Theme (for instance, if the new View/Theme are of the same type 
-      // as the old ones). So, we have to force the new templates. This is mainly to 
-      // setup the new ViewBindings.
+      // We cannot be sure that the grid elements default style key are different with this new View/Theme (for instance, if the new View/Theme are of the same type 
+      // as the old ones). So, we have to force the new templates. This is mainly to setup the new ViewBindings.
       this.ReapplyTemplate();
 
 
       if( this.ViewChanged != null )
+      {
         this.ViewChanged( this, EventArgs.Empty );
+      }
 
       // Reset the size states since we do not want to apply old size states to a new view/new container style.
       this.DataGridContext.ClearSizeStates();
@@ -1512,11 +1531,10 @@ namespace Xceed.Wpf.DataGrid
       this.ForceGeneratorReset = false;
 
       // Make sure the current item is into view.
-      this.DelayBringIntoViewAndFocusCurrent( DispatcherPriority.Render );
+      this.DelayBringIntoViewAndFocusCurrent( DispatcherPriority.Render, AutoScrollCurrentItemSourceTriggers.ViewChanged );
     }
 
     private Xceed.Wpf.DataGrid.Views.UIViewBase m_defaultView;
-    private Xceed.Wpf.DataGrid.Views.UIViewBase m_cachedView; // = null
 
     #endregion View Property
 
@@ -1650,7 +1668,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region FixedItem Attached Property
 
-    private static readonly object NotSet = new Object();
+    private static readonly object NotSet = new object();
 
     // The ownerType is set to FrameworkElement to make the inheritance works for all grid elements.
     private static readonly DependencyProperty FixedItemProperty = DependencyProperty.RegisterAttached(
@@ -2020,21 +2038,26 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
+
         if( m_clipboardExporters == null )
         {
           m_clipboardExporters = new Dictionary<string, ClipboardExporterBase>();
 
-          // Configure CSV ClipboardExporter
-          CsvClipboardExporter csvClipboardExporter = new CsvClipboardExporter();
-          csvClipboardExporter.FormatSettings.Separator = ',';
-          csvClipboardExporter.FormatSettings.TextQualifier = '"';
-          m_clipboardExporters.Add( DataFormats.CommaSeparatedValue, csvClipboardExporter );
-
-          // Configure tab separated value ClipboardExporter
-          csvClipboardExporter = new CsvClipboardExporter();
-          csvClipboardExporter.FormatSettings.Separator = '\t';
-          csvClipboardExporter.FormatSettings.TextQualifier = '"';
-          m_clipboardExporters.Add( DataFormats.Text, csvClipboardExporter );
+          if( !DesignerProperties.GetIsInDesignMode( this ) )
+          {
+            // Configure CSV ClipboardExporter
+            CsvClipboardExporter csvClipboardExporter = new CsvClipboardExporter();
+            csvClipboardExporter.FormatSettings.Separator = ',';
+            csvClipboardExporter.FormatSettings.TextQualifier = '"';
+            m_clipboardExporters.Add( DataFormats.CommaSeparatedValue, csvClipboardExporter );
+
+            // Configure tab separated value ClipboardExporter
+            csvClipboardExporter = new CsvClipboardExporter();
+            csvClipboardExporter.FormatSettings.Separator = '\t';
+            csvClipboardExporter.FormatSettings.TextQualifier = '"';
+            m_clipboardExporters.Add( DataFormats.Text, csvClipboardExporter );
+          }
+
         }
 
         return m_clipboardExporters;
@@ -2290,11 +2313,15 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
+#pragma warning disable 618
         return ( bool )GetValue( DataGridControl.PreserveExtendedSelectionProperty );
+#pragma warning restore 618
       }
       set
       {
+#pragma warning disable 618
         SetValue( DataGridControl.PreserveExtendedSelectionProperty, value );
+#pragma warning restore 618
       }
     }
 
@@ -2315,11 +2342,15 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
+#pragma warning disable 618
         return ( bool )GetValue( DataGridControl.PreserveSelectionWhenEnteringEditProperty );
+#pragma warning restore 618
       }
       set
       {
+#pragma warning disable 618
         SetValue( DataGridControl.PreserveSelectionWhenEnteringEditProperty, value );
+#pragma warning restore 618
       }
     }
 
@@ -2405,22 +2436,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region InhibitPreviewGotKeyboardFocus Private Property
-
-    private bool InhibitPreviewGotKeyboardFocus
-    {
-      get
-      {
-        return m_flags[ ( int )DataGridControlFlags.InhibitPreviewGotKeyboardFocus ];
-      }
-      set
-      {
-        m_flags[ ( int )DataGridControlFlags.InhibitPreviewGotKeyboardFocus ] = value;
-      }
-    }
-
-    #endregion
-
     #region DebugSaveRestore Private Property
 
     private bool DebugSaveRestore
@@ -2541,6 +2556,49 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region AreDetailsFlatten Internal Property
+
+    internal bool AreDetailsFlatten
+    {
+      get
+      {
+        var currentView = this.GetView( false );
+        if( currentView == null )
+          return false;
+
+        var attributes = currentView.GetType().GetCustomAttributes( typeof( MasterDetailLayoutAttribute ), true );
+        if( ( attributes == null ) || ( attributes.Length == 0 ) )
+          return false;
+
+        var attribute = ( MasterDetailLayoutAttribute )attributes[ 0 ];
+
+        return ( attribute.MasterDetailLayoutMode == MasterDetailLayoutMode.Flatten );
+      }
+    }
+
+    #endregion
+
+    #region GridUniqueName "conditional" Property
+
+    private string GridUniqueName
+    {
+      get
+      {
+        return m_gridUniqueName;
+      }
+      set
+      {
+        if( value != m_gridUniqueName )
+        {
+          m_gridUniqueName = value;
+          m_customItemContainerGenerator.ResetLog( value );
+        }
+      }
+    }
+
+    private string m_gridUniqueName;
+
+    #endregion
 
     #region TemplateApplied Event
 
@@ -2664,7 +2722,10 @@ namespace Xceed.Wpf.DataGrid
 
     internal void RaiseSelectionChanging( DataGridSelectionChangingEventArgs e )
     {
-      this.OnSelectionChanging( e );
+      using( m_inhibitPreviewGotKeyboardFocus.Set() )
+      {
+        this.OnSelectionChanging( e );
+      }
     }
 
     #endregion SelectionChanging Event
@@ -2768,7 +2829,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public void OnDataGridCollectionView_RootGroupChanged( object sender, EventArgs e )
+    private void OnDataGridCollectionView_RootGroupChanged( object sender, EventArgs e )
     {
       this.SetValue( DataGridControl.StatContextPropertyKey, ( ( DataGridCollectionView )sender ).RootGroup );
     }
@@ -2797,7 +2858,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public void OnDataGridDetailDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void OnDataGridDetailDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       DataGridDetailDescriptionCollection detailDescriptions = sender as DataGridDetailDescriptionCollection;
       Debug.Assert( detailDescriptions != null );
@@ -2840,7 +2901,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-
     #region Drag Management
 
     public bool AllowDrag
@@ -2870,6 +2930,14 @@ namespace Xceed.Wpf.DataGrid
       dataGrid.ResetDragDataObject();
     }
 
+    internal bool UseDragBehavior
+    {
+      get
+      {
+        return this.AllowDrag;
+      }
+    }
+
     internal IDataObject DragDataObject
     {
       get
@@ -2880,7 +2948,7 @@ namespace Xceed.Wpf.DataGrid
 
     internal void InitializeDragPostion( MouseEventArgs e )
     {
-      if( !this.AllowDrag )
+      if( !this.UseDragBehavior )
         return;
 
       m_initialDragPosition = e.GetPosition( this );
@@ -2922,7 +2990,7 @@ namespace Xceed.Wpf.DataGrid
 
     private void PrepareDragDataObject( MouseEventArgs e )
     {
-      if( !this.AllowDrag )
+      if( !this.UseDragBehavior )
         return;
 
       try
@@ -2970,11 +3038,8 @@ namespace Xceed.Wpf.DataGrid
     {
       this.QueueDataGridContextPeerChlidrenRefresh( this.DataGridContext );
 
-      // We need to reevaluate the CurrentContext when it is a detail context
-      // since the details are cleared and recreated when the theme changes
-      // and no update is made to the current item itself. We dispatch it with
-      // a high priority in order to be sure it is executed before a potential
-      // BringIntoView of the current item.
+      // We need to reevaluate the CurrentContext when it is a detail context since the details are cleared and recreated when the theme changes and no update is
+      // made to the current item itself. We dispatch it with a high priority in order to be sure it is executed before a potential BringIntoView of the current item.
       if( this.CurrentContext != this.DataGridContext )
       {
         this.Dispatcher.BeginInvoke( new Action( delegate()
@@ -2983,7 +3048,7 @@ namespace Xceed.Wpf.DataGrid
         } ), DispatcherPriority.Normal );
       }
 
-      Xceed.Wpf.DataGrid.Views.ViewBase view = this.GetView();      
+      Xceed.Wpf.DataGrid.Views.ViewBase view = this.GetView();
 
       this.SaveDataGridContextState( this.DataGridContext, true, int.MaxValue );
 
@@ -3006,14 +3071,16 @@ namespace Xceed.Wpf.DataGrid
 
       ControlTemplate newTemplate = this.Template;
 
-      // When a null Theme is set or the new Theme is the already the applied 
-      // System Theme, we detect if the template changed after setting the 
-      // DefaultStyleKey to refresh the FixedHeaders and FixedFooters
+      this.ClearValue( DataGridControl.ParentDataGridControlPropertyKey );
+      this.SetValue( DataGridControl.ParentDataGridControlPropertyKey, this );
+
+      // When a null Theme is set or the new Theme is the already the applied System Theme, we detect if the
+      // template changed after setting the DefaultStyleKey to refresh the FixedHeaders and FixedFooters
       if( oldTemplate == newTemplate )
         this.ResetFixedRegions();
 
       // Make sure the current item is into view.
-      this.DelayBringIntoViewAndFocusCurrent( DispatcherPriority.Render );
+      this.DelayBringIntoViewAndFocusCurrent( DispatcherPriority.Render, AutoScrollCurrentItemSourceTriggers.ThemeChanged );
     }
 
     /// <summary>
@@ -3052,12 +3119,15 @@ namespace Xceed.Wpf.DataGrid
 
     internal Xceed.Wpf.DataGrid.Views.ViewBase GetView( bool getViewOrDefault = true )
     {
-      Xceed.Wpf.DataGrid.Views.ViewBase view = this.View;
+      UIViewBase view = this.View;
       if( view != null )
         return view;
 
-      if( ( m_defaultView != null ) || ( getViewOrDefault ) )
-        return this.GetDefaultView();
+      if( getViewOrDefault )
+      {
+        this.View = this.GetDefaultView() as UIViewBase;
+        return this.View;
+      }
 
       return null;
     }
@@ -3080,7 +3150,19 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_inhibitSetFocus != 0;
+        return m_inhibitSetFocus.IsSet;
+      }
+    }
+
+    internal bool SettingFocusOnCell
+    {
+      get
+      {
+        return m_flags[ ( int )DataGridControlFlags.SettingFocusOnCell ];
+      }
+      private set
+      {
+        m_flags[ ( int )DataGridControlFlags.SettingFocusOnCell ] = value;
       }
     }
 
@@ -3101,14 +3183,14 @@ namespace Xceed.Wpf.DataGrid
       if( toFocus.IsKeyboardFocusWithin )
         return true;
 
-      toFocus = DataGridControl.FindFirstFocusableChild( toFocus );
+      UIElement childToFocus = DataGridControl.FindFirstFocusableChild( toFocus );
 
-      if( toFocus == null )
+      if( childToFocus == null )
         return false;
 
       try
       {
-        return toFocus.Focus();
+        return childToFocus.Focus();
       }
       catch
       {
@@ -3157,30 +3239,14 @@ namespace Xceed.Wpf.DataGrid
         new DelayedSetFocusHelperHandler( this.DelayedSetFocusHelper ), forceFocus, new object[] { true } );
     }
 
-    internal bool SetFocusHelper(
-      UIElement itemContainer,
-      ColumnBase column,
-      bool forceFocus,
-      bool preserveEditorFocus )
+    internal bool SetFocusHelper( UIElement itemContainer, ColumnBase column, bool forceFocus, bool preserveEditorFocus )
     {
-      return this.SetFocusHelper( itemContainer,
-        column,
-        forceFocus,
-        preserveEditorFocus,
-        false );
+      return this.SetFocusHelper( itemContainer, column, forceFocus, preserveEditorFocus, false );
     }
 
-    internal bool SetFocusHelper(
-      UIElement itemContainer,
-      ColumnBase column,
-      bool forceFocus,
-      bool preserveEditorFocus,
-      bool preventMakeVisibleIfCellFocused )
+    internal bool SetFocusHelper( UIElement itemContainer, ColumnBase column, bool forceFocus, bool preserveEditorFocus, bool preventMakeVisibleIfCellFocused )
     {
-      if( m_inhibitSetFocus != 0 )
-        return false;
-
-      if( itemContainer == null )
+      if( ( itemContainer == null ) || m_inhibitSetFocus.IsSet )
         return false;
 
       //There is an identified weakness with the IsKeyboardFocusWithin property where it cannot tell if the focus is within a Popup which is within the element
@@ -3206,14 +3272,15 @@ namespace Xceed.Wpf.DataGrid
         {
           Cell cell = row.Cells[ column ];
 
-          // The Cell must be in VisualTree to be able to get
-          // the focus, else, .Focus() will always return false
+          // The Cell must be in VisualTree to be able to get the focus, else, .Focus() will always return false
           if( cell != null )
           {
             cell.EnsureInVisualTree();
 
             if( preventMakeVisibleIfCellFocused )
+            {
               preventMakeVisibleDisposable = cell.InhibitMakeVisible();
+            }
           }
 
           if( ( row.IsBeingEdited ) && ( cell != null ) )
@@ -3236,18 +3303,11 @@ namespace Xceed.Wpf.DataGrid
               toFocus = cell;
             }
 
-            bool currentFocusIsInsideCell =
-              ( cell != Keyboard.FocusedElement )
-              && ( TreeHelper.IsDescendantOf( Keyboard.FocusedElement as DependencyObject, cell ) );
+            bool currentFocusIsInsideCell = ( cell != Keyboard.FocusedElement ) && ( TreeHelper.IsDescendantOf( Keyboard.FocusedElement as DependencyObject, cell ) );
 
-            //if the focus is already within the Cell to focus, then don't touch a thing
+            //If the focus is already within the Cell to focus, then don't touch a thing.  It means the item to focus should be the Keyboard focused element - Already focused
             if( ( currentFocusIsInsideCell ) && ( preserveEditorFocus ) && ( cell.IsBeingEdited ) )
-            {
-              //that means that the item to focus should be the Keyboard focused element
-
-              // Already focused
               return true;
-            }
           }
           else if( ( row.NavigationBehavior == NavigationBehavior.RowOnly ) || ( cell == null ) )
           {
@@ -3267,30 +3327,22 @@ namespace Xceed.Wpf.DataGrid
           {
             toFocus = cell;
 
-            bool currentFocusIsInsideCell =
-              ( cell != Keyboard.FocusedElement )
-              && ( TreeHelper.IsDescendantOf( Keyboard.FocusedElement as DependencyObject, cell ) );
+            bool currentFocusIsInsideCell = ( cell != Keyboard.FocusedElement ) && ( TreeHelper.IsDescendantOf( Keyboard.FocusedElement as DependencyObject, cell ) );
 
-            //if the focus is already within the Cell to focus, then don't touch a thing
+            //If the focus is already within the Cell to focus, then don't touch a thing.  It means the item to focus should be the Keyboard focused element - Already focused
             if( ( currentFocusIsInsideCell ) && ( preserveEditorFocus ) )
-            {
-              // That means that the item to focus should be the Keyboard focused element
-              // Already focused
               return true;
-            }
           }
         }
         else
         {
           toFocus = itemContainer;
 
-          //if the container for the item is not a Row, and the focus is already within that item
-          //then don't touch the focus.
+          //if the container for the item is not a Row, and the focus is already within that item then don't touch the focus.
           bool partOfContainer = TreeHelper.IsDescendantOf( Keyboard.FocusedElement as DependencyObject, toFocus );
 
           if( partOfContainer )
           {
-            // Already focused
             return true;
           }
         }
@@ -3307,18 +3359,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    internal bool SettingFocusOnCell
-    {
-      get
-      {
-        return m_flags[ ( int )DataGridControlFlags.SettingFocusOnCell ];
-      }
-      private set
-      {
-        m_flags[ ( int )DataGridControlFlags.SettingFocusOnCell ] = value;
-      }
-    }
-
     private void DelayedSetFocusHelper( bool forceFocus, bool preserveEditorFocus )
     {
       DataGridContext currentContext = this.CurrentContext;
@@ -3348,24 +3388,29 @@ namespace Xceed.Wpf.DataGrid
 
     #region BRING INTO VIEW
 
+    internal IDisposable SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers trigger )
+    {
+      return m_inhibitAutoScroll.SetRestriction( trigger );
+    }
+
     internal IDisposable InhibitQueueBringIntoView()
     {
-      return new GridControlQueueInhibiter( this );
+      return m_inhibitBringIntoView.Set();
     }
 
     internal IDisposable InhibitSetFocus()
     {
-      return new DataGridControlSetFocusInhibiter( this );
+      return m_inhibitSetFocus.Set();
     }
 
-    internal void DelayBringIntoViewAndFocusCurrent()
+    internal void DelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers trigger )
     {
-      this.DelayBringIntoViewAndFocusCurrent( DispatcherPriority.DataBind );
+      this.DelayBringIntoViewAndFocusCurrent( DispatcherPriority.DataBind, trigger );
     }
 
-    private void DelayBringIntoViewAndFocusCurrent( DispatcherPriority priority )
+    private void DelayBringIntoViewAndFocusCurrent( DispatcherPriority priority, AutoScrollCurrentItemSourceTriggers trigger )
     {
-      if( ( m_inhibitBringIntoView != 0 ) || ( m_inhibitSetFocus != 0 ) || ( m_queueBringIntoView != null ) )
+      if( ( m_queueBringIntoView != null ) || m_inhibitBringIntoView.IsSet || m_inhibitSetFocus.IsSet || !this.IsBringIntoViewAllowed( trigger ) )
         return;
 
       m_queueBringIntoView = this.QueueBringIntoView( priority );
@@ -3380,21 +3425,22 @@ namespace Xceed.Wpf.DataGrid
 
     private DispatcherOperation QueueBringIntoView( DispatcherPriority priority )
     {
-      if( m_inhibitBringIntoView != 0 )
-        return null;
+      Debug.Assert( !m_inhibitBringIntoView.IsSet );
 
       return this.Dispatcher.BeginInvoke( priority, new GenericHandler( this.QueueBringIntoViewHelper ) );
     }
 
     private bool QueueBringIntoViewHelper()
     {
-      DataGridContext currentContext = this.CurrentContext;
-      object internalCurrentItem = ( currentContext != null ) ? currentContext.InternalCurrentItem : null;
+      var dataGridContext = this.CurrentContext;
+      if( dataGridContext == null )
+        return false;
 
-      if( internalCurrentItem == null )
+      var currentItem = dataGridContext.InternalCurrentItem;
+      if( currentItem == null )
         return false;
 
-      return this.BringItemIntoViewHelper( currentContext, internalCurrentItem );
+      return this.BringItemIntoViewHelper( dataGridContext, currentItem );
     }
 
     public bool BringItemIntoView( object item )
@@ -3404,25 +3450,20 @@ namespace Xceed.Wpf.DataGrid
 
     internal bool BringItemIntoViewHelper( DataGridContext dataGridContext, object item )
     {
-      FrameworkElement itemsHost = this.ItemsHost;
-
       //this is a protection in case the Template is incomplete or not realized yet.
+      var itemsHost = this.ItemsHost;
       if( itemsHost == null )
         return false;
 
       // It is possible that a BringIntoView was queued before an operation that will
       // detach the ItemsHost of the DataGridControl and we want to avoid to call 
       // ICustomVirtualizingPanel.BringIntoView in this situation.
-      DataGridContext itemsHostDataGridContext = DataGridControl.GetDataGridContext( itemsHost );
-
+      var itemsHostDataGridContext = DataGridControl.GetDataGridContext( itemsHost );
       if( itemsHostDataGridContext == null )
-      {
         return false;
-      }
-
-      FrameworkElement container = dataGridContext.GetContainerFromItem( item ) as FrameworkElement;
 
       //if a container exists, call bring into view on it!
+      var container = dataGridContext.GetContainerFromItem( item ) as FrameworkElement;
       if( container != null )
       {
         container.BringIntoView();
@@ -3439,8 +3480,7 @@ namespace Xceed.Wpf.DataGrid
       if( ( this.ScrollViewer != null ) && ( !this.ScrollViewer.CanContentScroll ) )
         return false;
 
-      ICustomVirtualizingPanel customPanel = itemsHost as ICustomVirtualizingPanel;
-
+      var customPanel = itemsHost as ICustomVirtualizingPanel;
       if( customPanel == null )
         return false;
 
@@ -3457,6 +3497,52 @@ namespace Xceed.Wpf.DataGrid
       return false;
     }
 
+    internal bool IsBringIntoViewAllowed( AutoScrollCurrentItemSourceTriggers trigger )
+    {
+      if( trigger == AutoScrollCurrentItemSourceTriggers.None )
+        return false;
+
+      var source = ( ~m_inhibitAutoScroll.Restrictions & trigger );
+      if( source == AutoScrollCurrentItemSourceTriggers.None )
+        return false;
+
+      var options = this.AutoScrollCurrentItem;
+
+      switch( source )
+      {
+        case AutoScrollCurrentItemSourceTriggers.Editing:
+        case AutoScrollCurrentItemSourceTriggers.Navigation:
+          return true;
+
+        case AutoScrollCurrentItemSourceTriggers.CurrentItemChanged:
+        case AutoScrollCurrentItemSourceTriggers.CurrentColumnChanged:
+        case AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged:
+        case AutoScrollCurrentItemSourceTriggers.SelectionChanged:
+        case AutoScrollCurrentItemSourceTriggers.ColumnsCollectionChanged:
+          return DataGridControl.IsSet( options, AutoScrollCurrentItemTriggers.CurrentChanged );
+
+        case AutoScrollCurrentItemSourceTriggers.SortChanged:
+          return DataGridControl.IsSet( options, AutoScrollCurrentItemTriggers.SortChanged );
+
+        case AutoScrollCurrentItemSourceTriggers.GroupChanged:
+          return DataGridControl.IsSet( options, AutoScrollCurrentItemTriggers.GroupChanged );
+
+        case AutoScrollCurrentItemSourceTriggers.FocusChanged:
+          return DataGridControl.IsSet( options, AutoScrollCurrentItemTriggers.FocusChanged );
+
+        case AutoScrollCurrentItemSourceTriggers.ItemsSourceChanged:
+          return DataGridControl.IsSet( options, AutoScrollCurrentItemTriggers.ItemsSourceChanged );
+
+        case AutoScrollCurrentItemSourceTriggers.ViewChanged:
+          return DataGridControl.IsSet( options, AutoScrollCurrentItemTriggers.ViewChanged );
+
+        case AutoScrollCurrentItemSourceTriggers.ThemeChanged:
+          return DataGridControl.IsSet( options, AutoScrollCurrentItemTriggers.ThemeChanged );
+      }
+
+      return false;
+    }
+
     private void BringIntoView_Completed( object sender, EventArgs e )
     {
       m_queueBringIntoView.Completed -= new EventHandler( BringIntoView_Completed );
@@ -3474,11 +3560,16 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private static bool IsSet( AutoScrollCurrentItemTriggers source, AutoScrollCurrentItemTriggers comparand )
+    {
+      return ( ( source & comparand ) == comparand );
+    }
+
     #endregion BRING INTO VIEW
 
     #region COMMANDS
 
-    private void OnExpandGroupCanExecute( Object sender, CanExecuteRoutedEventArgs e )
+    private void OnExpandGroupCanExecute( object sender, CanExecuteRoutedEventArgs e )
     {
       e.CanExecute = false;
 
@@ -3498,7 +3589,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    protected virtual void OnExpandGroupExecuted( Object sender, ExecutedRoutedEventArgs e )
+    protected virtual void OnExpandGroupExecuted( object sender, ExecutedRoutedEventArgs e )
     {
       CollectionViewGroup cvg = e.Parameter as CollectionViewGroup;
       if( cvg != null )
@@ -3514,7 +3605,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void OnCollapseGroupCanExecute( Object sender, CanExecuteRoutedEventArgs e )
+    private void OnCollapseGroupCanExecute( object sender, CanExecuteRoutedEventArgs e )
     {
       e.CanExecute = false;
 
@@ -3534,7 +3625,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    protected virtual void OnCollapseGroupExecuted( Object sender, ExecutedRoutedEventArgs e )
+    protected virtual void OnCollapseGroupExecuted( object sender, ExecutedRoutedEventArgs e )
     {
       CollectionViewGroup cvg = e.Parameter as CollectionViewGroup;
       if( cvg != null )
@@ -3550,7 +3641,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void OnToggleGroupCanExecute( Object sender, CanExecuteRoutedEventArgs e )
+    private void OnToggleGroupCanExecute( object sender, CanExecuteRoutedEventArgs e )
     {
       e.CanExecute = false;
 
@@ -3560,7 +3651,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    protected virtual void OnToggleGroupExecuted( Object sender, ExecutedRoutedEventArgs e )
+    protected virtual void OnToggleGroupExecuted( object sender, ExecutedRoutedEventArgs e )
     {
       CollectionViewGroup cvg = e.Parameter as CollectionViewGroup;
       if( cvg != null )
@@ -3807,11 +3898,13 @@ namespace Xceed.Wpf.DataGrid
         ICollectionView collectionView = this.Items.SourceCollection as ICollectionView;
 
         if( collectionView != null )
+        {
           collectionView.Refresh();
+        }
       }
     }
 
-    protected virtual void OnClearFilterExecuted( Object sender, ExecutedRoutedEventArgs e )
+    protected virtual void OnClearFilterExecuted( object sender, ExecutedRoutedEventArgs e )
     {
       DataGridCollectionViewBase dgcv = this.ItemsSource as DataGridCollectionViewBase;
 
@@ -3858,7 +3951,7 @@ namespace Xceed.Wpf.DataGrid
           currentItemIndex = -1;
         }
 
-        localContext.SetCurrent( currentItem, null, currentItemIndex, null, false, false, this.SynchronizeSelectionWithCurrent );
+        localContext.SetCurrent( currentItem, null, currentItemIndex, null, false, false, this.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.ItemsSourceChanged );
 
         if( !this.SynchronizeSelectionWithCurrent )
         {
@@ -3893,15 +3986,10 @@ namespace Xceed.Wpf.DataGrid
 
       if( dataGridCollectionView != null )
       {
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_rootGroupChangedHandler = new WeakEventHandler<EventArgs>( this.OnDataGridCollectionView_RootGroupChanged ).Handler;
-        dataGridCollectionView.RootGroupChanged += m_rootGroupChangedHandler;
-
+        RootGroupChangedEventManager.AddListener( dataGridCollectionView, this );
         this.SetValue( DataGridControl.StatContextPropertyKey, dataGridCollectionView.RootGroup );
 
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_dataGridDetailDescriptionsChangedHandler = new WeakEventHandler<NotifyCollectionChangedEventArgs>( this.OnDataGridDetailDescriptionsChanged ).Handler;
-        dataGridCollectionView.DetailDescriptions.CollectionChanged += m_dataGridDetailDescriptionsChangedHandler;
+        CollectionChangedEventManager.AddListener( dataGridCollectionView.DetailDescriptions, this );
 
         DetailConfiguration.SynchronizeDetailConfigurations(
           dataGridCollectionView.DetailDescriptions,
@@ -3910,25 +3998,11 @@ namespace Xceed.Wpf.DataGrid
           this.AutoCreateForeignKeyConfigurations,
           this.AutoRemoveColumnsAndDetailConfigurations );
 
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_proxyCollectionRefreshHandler = new WeakEventHandler<EventArgs>( this.OnDataGridCollectionView_ProxyCollectionRefresh ).Handler;
-        dataGridCollectionView.ProxyCollectionRefresh += m_proxyCollectionRefreshHandler;
-
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_proxyGroupDescriptionsChangedHandler = new WeakEventHandler<NotifyCollectionChangedEventArgs>( this.OnDataGridCollectionView_ProxyGroupDescriptionsChanged ).Handler;
-        dataGridCollectionView.ProxyGroupDescriptionsChanged += m_proxyGroupDescriptionsChangedHandler;
-
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_proxySortDescriptionsChangedHandler = new WeakEventHandler<NotifyCollectionChangedEventArgs>( this.OnDataGridCollectionView_ProxySortDescriptionsChanged ).Handler;
-        dataGridCollectionView.ProxySortDescriptionsChanged += m_proxySortDescriptionsChangedHandler;
-
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_proxyAutoFilterValuesChangedHandler = new WeakEventHandler<NotifyCollectionChangedEventArgs>( this.OnDataGridCollectionView_ProxyAutoFilterValuesChanged ).Handler;
-        dataGridCollectionView.ProxyAutoFilterValuesChanged += m_proxyAutoFilterValuesChangedHandler;
-
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_proxyApplyingFilterCriteriasHandler = new WeakEventHandler<EventArgs>( this.OnDataGridCollectionView_ProxyApplyingFilterCriterias ).Handler;
-        dataGridCollectionView.ProxyApplyingFilterCriterias += m_proxyApplyingFilterCriteriasHandler;
+        ProxyCollectionRefreshEventManager.AddListener( dataGridCollectionView, this );
+        ProxyGroupDescriptionsChangedEventManager.AddListener( dataGridCollectionView, this );
+        ProxySortDescriptionsChangedEventManager.AddListener( dataGridCollectionView, this );
+        ProxyAutoFilterValuesChangedEventManager.AddListener( dataGridCollectionView, this );
+        ProxyApplyingFilterCriteriasEventManager.AddListener( dataGridCollectionView, this );
       }
       else
       {
@@ -3944,20 +4018,16 @@ namespace Xceed.Wpf.DataGrid
 
       if( this.IsBoundToDataGridVirtualizingCollectionViewBase )
       {
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_connectionStateChangedHandler = new WeakEventHandler<EventArgs>( this.OnDataGridVirtualizingCollectionViewBase_ConnectionStateChanged ).Handler;
-        virtualizingCollectionView.ConnectionStateChanged += m_connectionStateChangedHandler;
-
-        // We must keep a reference to the handler so that we can remove the same instance later on when unregistering from it.
-        m_connectionStateErrorHandler = new WeakEventHandler<EventArgs>( this.OnDataGridVirtualizingCollectionViewBase_ConnectionErrorChanged ).Handler;
-        virtualizingCollectionView.ConnectionErrorChanged += m_connectionStateErrorHandler;
+        ConnectionStateChangedEventManager.AddListener( virtualizingCollectionView, this );
+        ConnectionErrorChangedEventManager.AddListener( virtualizingCollectionView, this );
       }
 
-
       this.DataGridContext.NotifyItemsSourceChanged();
 
       if( this.ItemsSourceChangeCompleted != null )
+      {
         this.ItemsSourceChangeCompleted( this, EventArgs.Empty );
+      }
     }
 
     [Obsolete( "The AddingNewDataItem event is obsolete and has been replaced by the DataGridCollectionView.CreatingNewItem and InitializingNewItem events.", false )]
@@ -3971,7 +4041,9 @@ namespace Xceed.Wpf.DataGrid
     protected internal virtual void OnAddingNewDataItem( AddingNewDataItemEventArgs e )
     {
       if( this.AddingNewDataItem != null )
+      {
         this.AddingNewDataItem( this, e );
+      }
     }
 
     public event EventHandler ItemsSourceChangeCompleted;
@@ -3980,6 +4052,12 @@ namespace Xceed.Wpf.DataGrid
     {
       base.OnItemsSourceChanged( oldValue, newValue );
 
+      if( m_inhibitItemsCollectionChanged != null )
+      {
+        m_inhibitItemsCollectionChanged.Dispose();
+        m_inhibitItemsCollectionChanged = null;
+      }
+
       ScrollViewer scrollViewer = this.ScrollViewer;
       if( scrollViewer != null )
       {
@@ -4003,7 +4081,9 @@ namespace Xceed.Wpf.DataGrid
       m_detectedName = ( dataView != null ) ? dataView.Table.TableName : null;
 
       if( !object.Equals( this.ItemsSourceName, oldItemsSourceName ) )
+      {
         this.OnNotifyPropertyChanged( new PropertyChangedEventArgs( "ItemsSourceName" ) );
+      }
 
       DataGridContext localContext = this.DataGridContext;
       this.UpdateCurrentRowInEditionCellStates( null, null );
@@ -4022,14 +4102,14 @@ namespace Xceed.Wpf.DataGrid
 
       if( dataGridCollectionView != null )
       {
-        dataGridCollectionView.RootGroupChanged -= m_rootGroupChangedHandler;
-        dataGridCollectionView.DetailDescriptions.CollectionChanged -= m_dataGridDetailDescriptionsChangedHandler;
+        RootGroupChangedEventManager.RemoveListener( dataGridCollectionView, this );
+        CollectionChangedEventManager.RemoveListener( dataGridCollectionView.DetailDescriptions, this );
 
-        dataGridCollectionView.ProxyCollectionRefresh -= m_proxyCollectionRefreshHandler;
-        dataGridCollectionView.ProxyGroupDescriptionsChanged -= m_proxyGroupDescriptionsChangedHandler;
-        dataGridCollectionView.ProxySortDescriptionsChanged -= m_proxySortDescriptionsChangedHandler;
-        dataGridCollectionView.ProxyAutoFilterValuesChanged -= m_proxyAutoFilterValuesChangedHandler;
-        dataGridCollectionView.ProxyApplyingFilterCriterias -= m_proxyApplyingFilterCriteriasHandler;
+        ProxyCollectionRefreshEventManager.RemoveListener( dataGridCollectionView, this );
+        ProxyGroupDescriptionsChangedEventManager.RemoveListener( dataGridCollectionView, this );
+        ProxySortDescriptionsChangedEventManager.RemoveListener( dataGridCollectionView, this );
+        ProxyAutoFilterValuesChangedEventManager.RemoveListener( dataGridCollectionView, this );
+        ProxyApplyingFilterCriteriasEventManager.RemoveListener( dataGridCollectionView, this );
 
         m_dataGridContextsStateDictionary = null;
       }
@@ -4038,8 +4118,8 @@ namespace Xceed.Wpf.DataGrid
 
       if( virtualizingCollectionView != null )
       {
-        virtualizingCollectionView.ConnectionStateChanged -= m_connectionStateChangedHandler;
-        virtualizingCollectionView.ConnectionErrorChanged -= m_connectionStateErrorHandler;
+        ConnectionStateChangedEventManager.RemoveListener( virtualizingCollectionView, this );
+        ConnectionErrorChangedEventManager.RemoveListener( virtualizingCollectionView, this );
       }
 
       // We must refresh the FixedRegions to call Clear/Prepare Container for IDataGridItemContainer elements
@@ -4049,6 +4129,42 @@ namespace Xceed.Wpf.DataGrid
       this.ForceGeneratorReset = false;
     }
 
+    private object OnCoerceItemsSource( object value )
+    {
+      // Ensure to EndEdit the currently edited container
+      var currentContext = this.CurrentContext;
+      var currentItem = currentContext.InternalCurrentItem;
+      if( currentItem != null )
+      {
+        // Use Row.FromContainer to ensure Rows in Header/Footers are returned correctly
+        Row row = Row.FromContainer( currentContext.GetContainerFromItem( currentItem ) );
+        if( ( row != null ) && ( row.IsBeingEdited ) )
+        {
+          row.CancelEdit();
+        }
+      }
+
+      if( this.ItemsSource != value )
+      {
+        if( m_inhibitItemsCollectionChanged == null )
+        {
+          m_inhibitItemsCollectionChanged = this.Items.DeferRefresh();
+        }
+      }
+      else if( m_inhibitItemsCollectionChanged != null )
+      {
+        m_inhibitItemsCollectionChanged.Dispose();
+        m_inhibitItemsCollectionChanged = null;
+      }
+
+      return value;
+    }
+
+    private static object ItemsSourceCoerceCallback( DependencyObject sender, object value )
+    {
+      return ( ( DataGridControl )sender ).OnCoerceItemsSource( value );
+    }
+
     private void GenerateColumnsFromItemsSourceFields()
     {
       if( this.AutoCreateColumns )
@@ -4161,7 +4277,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public void OnDataGridCollectionView_ProxyCollectionRefresh( object sender, EventArgs e )
+    private void OnDataGridCollectionView_ProxyCollectionRefresh( object sender, EventArgs e )
     {
       DataGridCollectionView dataGridCollectionView = ( DataGridCollectionView )sender;
 
@@ -4178,7 +4294,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public void OnDataGridCollectionView_ProxyGroupDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void OnDataGridCollectionView_ProxyGroupDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       DataGridCollectionView dataGridCollectionView = ( DataGridCollectionView )sender;
 
@@ -4226,15 +4342,16 @@ namespace Xceed.Wpf.DataGrid
 
       if( maxGroupLevelToSave > -1 )
       {
-        DataGridContext targetDataGridContext = DataGridContext.SafeGetDataGridContextForDataGridCollectionView(
- this.DataGridContext, dataGridCollectionView );
+        DataGridContext targetDataGridContext = DataGridContext.SafeGetDataGridContextForDataGridCollectionView( this.DataGridContext, dataGridCollectionView );
 
         if( targetDataGridContext != null )
+        {
           this.SaveDataGridContextState( targetDataGridContext, false, maxGroupLevelToSave );
+        }
       }
     }
 
-    public void OnDataGridCollectionView_ProxySortDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void OnDataGridCollectionView_ProxySortDescriptionsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       DataGridCollectionView dataGridCollectionView = ( DataGridCollectionView )sender;
 
@@ -4242,15 +4359,16 @@ namespace Xceed.Wpf.DataGrid
 
       if( dataGridCollectionView.GroupDescriptions.Count > 0 )
       {
-        DataGridContext targetDataGridContext = DataGridContext.SafeGetDataGridContextForDataGridCollectionView(
-          this.DataGridContext, dataGridCollectionView );
+        DataGridContext targetDataGridContext = DataGridContext.SafeGetDataGridContextForDataGridCollectionView( this.DataGridContext, dataGridCollectionView );
 
         if( targetDataGridContext != null )
+        {
           this.SaveDataGridContextState( targetDataGridContext, false, int.MaxValue );
+        }
       }
     }
 
-    public void OnDataGridCollectionView_ProxyAutoFilterValuesChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void OnDataGridCollectionView_ProxyAutoFilterValuesChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       DataGridCollectionView dataGridCollectionView = ( DataGridCollectionView )sender;
 
@@ -4266,7 +4384,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public void OnDataGridCollectionView_ProxyApplyingFilterCriterias( object sender, EventArgs e )
+    private void OnDataGridCollectionView_ProxyApplyingFilterCriterias( object sender, EventArgs e )
     {
       DataGridCollectionView dataGridCollectionView = ( DataGridCollectionView )sender;
 
@@ -4286,14 +4404,14 @@ namespace Xceed.Wpf.DataGrid
 
     #region VIRTUALIZING COLLECTION VIEW SUPPORT
 
-    public void OnDataGridVirtualizingCollectionViewBase_ConnectionStateChanged( object sender, EventArgs e )
+    private void OnDataGridVirtualizingCollectionViewBase_ConnectionStateChanged( object sender, EventArgs e )
     {
       DataGridVirtualizingCollectionViewBase dataGridVirtualizingCollectionViewBase = sender as DataGridVirtualizingCollectionViewBase;
 
       this.SetConnectionState( dataGridVirtualizingCollectionViewBase.ConnectionState );
     }
 
-    public void OnDataGridVirtualizingCollectionViewBase_ConnectionErrorChanged( object sender, EventArgs e )
+    private void OnDataGridVirtualizingCollectionViewBase_ConnectionErrorChanged( object sender, EventArgs e )
     {
       DataGridVirtualizingCollectionViewBase dataGridVirtualizingCollectionViewBase = sender as DataGridVirtualizingCollectionViewBase;
 
@@ -4590,10 +4708,11 @@ namespace Xceed.Wpf.DataGrid
         {
           try
           {
-            currentDataGridContext.SetCurrent( oldCurrentItem, null, null, null, false, false, this.SynchronizeSelectionWithCurrent );
+            currentDataGridContext.SetCurrent( oldCurrentItem, null, null, null, false, false, this.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.Editing );
           }
           catch( DataGridException )
-          {            // We swallow the exception if it occurs because of a validation error or Cell was read-only or
+          {
+            // We swallow the exception if it occurs because of a validation error or Cell was read-only or
             // any other GridException.
           }
         }
@@ -4635,7 +4754,7 @@ namespace Xceed.Wpf.DataGrid
         this.SetCurrentDataGridContextHelper( newCurrentContext );
 
         // Set it as current using the old context CurrentItem, CurrentColumn
-        newCurrentContext.SetCurrent( newCurrentItem, null, null, currentContext.CurrentColumn, false, false, this.SynchronizeSelectionWithCurrent );
+        newCurrentContext.SetCurrent( newCurrentItem, null, null, currentContext.CurrentColumn, false, false, this.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.ThemeChanged );
       }
     }
 
@@ -4721,15 +4840,18 @@ namespace Xceed.Wpf.DataGrid
       Xceed.Wpf.DataGrid.Views.ViewBase view = this.GetView();
 
       if( view.UseDefaultHeadersFooters )
+      {
         view.InvokeAddDefaultHeadersFooters();
+      }
 
       // Cache if the view requires to preserve container size
       this.ViewPreservesContainerSize = view.PreserveContainerSize;
 
       // Notify the template was reapplied
       if( this.TemplateApplied != null )
+      {
         this.TemplateApplied( this, EventArgs.Empty );
-
+      }
     }
 
     public void ExpandGroup( CollectionViewGroup group )
@@ -4905,7 +5027,7 @@ namespace Xceed.Wpf.DataGrid
       // If element is a HeaderFooterItem, then it cannot be a Row
       if( hfi != null )
       {
-        row = HeaderFooterItem.FindIDataGridItemContainerInChildren( hfi, hfi.AsVisual() ) as Row;
+        row = Row.FromContainer( hfi );
       }
 
       // Special handling case for the Row class when it is not in a HeaderFooterItem
@@ -4948,11 +5070,11 @@ namespace Xceed.Wpf.DataGrid
             // else directly on the Row
             if( hfi != null )
             {
-              hfi.ClearContainer();
+              ( ( IDataGridItemContainer )hfi ).ClearContainer();
             }
             else
             {
-              row.ClearContainer();
+              ( ( IDataGridItemContainer )row ).ClearContainer();
             }
           }
 
@@ -4964,8 +5086,8 @@ namespace Xceed.Wpf.DataGrid
             column.CurrentRowInEditionCellState = oldCellState;
           }
 
-          m_currentItemInEdition = item;
-
+          // Though the row state is preserved, the DataGridControl is not in editing anymore.
+          m_currentItemInEdition = null;
           this.UpdateIsBeingEdited();
         }
         else
@@ -4978,11 +5100,11 @@ namespace Xceed.Wpf.DataGrid
             // else directly on the Row
             if( hfi != null )
             {
-              hfi.ClearContainer();
+              ( ( IDataGridItemContainer )hfi ).ClearContainer();
             }
             else
             {
-              row.ClearContainer();
+              ( ( IDataGridItemContainer )row ).ClearContainer();
             }
           }
         }
@@ -5000,7 +5122,7 @@ namespace Xceed.Wpf.DataGrid
       {
         // If the element we are cleaning up contains the focus, we ensure to refocus the ScrollViewer to have
         // the focus on a valid element of the grid.
-        this.DelayBringIntoViewAndFocusCurrent();
+        this.DelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.FocusChanged );
       }
     }
 
@@ -5138,8 +5260,10 @@ namespace Xceed.Wpf.DataGrid
             {
               DependencyObject originalSource = e.OriginalSource as DependencyObject;
 
-              Row row = CustomItemContainerGenerator.FindContainerFromChildOrRowSelectorOrSelf(
-                this, originalSource ) as Row;
+              FrameworkElement element = CustomItemContainerGenerator.FindContainerFromChildOrRowSelectorOrSelf( this, originalSource );
+
+              Row row = element as Row;
+              SelectionRangePoint newPosition = null;
 
               if( ( row != null ) && ( !row.IsBeingEdited ) )
               {
@@ -5158,14 +5282,19 @@ namespace Xceed.Wpf.DataGrid
 
                   int columnIndex = ( cell == null ) ? -1 : cell.ParentColumn.VisiblePosition;
 
-                  m_selectionChangerManager.UpdateSelection(
-                    this.CurrentContext, this.CurrentItem, this.CurrentColumn,
-                    newDataGridContext, true, row.IsBeingEdited, sourceDataItemIndex, item, columnIndex,
-                    SelectionManager.UpdateSelectionSource.SpaceDown );
-
-                  e.Handled = true;
+                  newPosition = new SelectionRangePoint( newDataGridContext, item, sourceDataItemIndex, columnIndex );
                 }
               }
+
+              if( newPosition != null )
+              {
+                var oldPosition = SelectionRangePoint.TryCreateFromCurrent( this.CurrentContext );
+
+                m_selectionChangerManager.UpdateSelection( oldPosition, newPosition, true,
+                  false, SelectionManager.UpdateSelectionSource.SpaceDown );
+
+                e.Handled = true;
+              }
             }
 
             break;
@@ -5250,9 +5379,9 @@ namespace Xceed.Wpf.DataGrid
           SelectionManager.UpdateSelectionSource.MouseDown );
       }
 
-      m_mouseDownCurrentDataGridContext = this.CurrentContext;
-      m_mouseDownCurrentItem = this.CurrentItem;
-      m_mouseDownCurrentColumn = this.CurrentColumn;
+      ColumnBase currentColumn = this.CurrentColumn;
+
+      m_mouseDownSelectionRangePoint = SelectionRangePoint.TryCreateFromCurrent( this.CurrentContext );
 
       base.OnPreviewMouseDown( e );
 
@@ -5274,6 +5403,10 @@ namespace Xceed.Wpf.DataGrid
 
       ColumnBase oldCurrentColumn = oldDataGridContext.CurrentColumn;
 
+      bool mouseDownHandled;
+      Row newFocusedRow;
+      ColumnBase newFocusedColumn;
+
       try
       {
         // If the source is reset during the EndEdit, we move the focus temporarely on the ScrollViewer to prevent some issue
@@ -5290,19 +5423,32 @@ namespace Xceed.Wpf.DataGrid
           // If the source was reset during the EndEdit, Ensure to relayout right away.
           // So the mouse down will continue on the new layouted element.
           this.UpdateLayout();
+
+          IInputElement visualHit = this.InputHitTest( e.GetPosition( this ) );
+          mouseDownHandled = ( visualHit == null )
+                          || ( !object.ReferenceEquals( visualHit, e.OriginalSource ) );
+          newFocusedRow = newRow;
+          newFocusedColumn = currentColumn;
         }
       }
       catch( DataGridException )
       {
         // We swallow exception if it occurs because of a validation error or Cell was read-only or
         // any other GridException.
+        mouseDownHandled = true;
+        newFocusedRow = oldRow;
+        newFocusedColumn = oldCurrentColumn;
+      }
+
+      if( mouseDownHandled )
+      {
         if( m_mouseDownUpdateSelectionSource != null )
         {
           m_mouseDownUpdateSelectionSource.Dispose();
           m_mouseDownUpdateSelectionSource = null;
         }
 
-        this.SetFocusHelper( oldRow, oldCurrentColumn, false, true );
+        this.SetFocusHelper( newFocusedRow, newFocusedColumn, false, true );
         e.Handled = true;
       }
     }
@@ -5317,41 +5463,47 @@ namespace Xceed.Wpf.DataGrid
 
       base.OnPreviewMouseUp( e );
 
-      if( e.ChangedButton == MouseButton.Left )
-      {
-        DependencyObject originalSource = e.OriginalSource as DependencyObject;
+      if( e.ChangedButton != MouseButton.Left )
+        return;
 
-        Row row = CustomItemContainerGenerator.FindContainerFromChildOrRowSelectorOrSelf(
-          this, originalSource ) as Row;
+      var source = e.OriginalSource as DependencyObject;
 
-        if( row == null || ( !row.IsKeyboardFocused && !row.IsKeyboardFocusWithin ) )
-          return;
+      FrameworkElement element = CustomItemContainerGenerator.FindContainerFromChildOrRowSelectorOrSelf( this, source );
 
-        DataGridContext newDataGridContext = DataGridControl.GetDataGridContext( row );
+      if( element == null || ( !element.IsKeyboardFocused && !element.IsKeyboardFocusWithin ) )
+        return;
 
-        if( newDataGridContext == null )
-          return;
+      var row = element as Row;
+      SelectionRangePoint newPosition = null;
+      bool rowIsBeingEdited = false;
 
-        int sourceDataItemIndex = DataGridVirtualizingPanel.GetItemIndex( row );
-        object item = newDataGridContext.GetItemFromContainer( row );
-        Cell cell = originalSource as Cell;
+      if( row != null )
+      {
+        var dataGridContext = DataGridControl.GetDataGridContext( row );
+        if( dataGridContext == null )
+          return;
 
-        if( ( cell == null ) || ( cell.ParentColumn.DataGridControl != this ) )
-        {
-          cell = Cell.FindFromChild( this, originalSource );
+        var cell = Cell.FindFromChildOrSelf( this, source );
+        if( ( cell != null ) && ( this.SelectionUnit == SelectionUnit.Cell ) && ( !cell.IsKeyboardFocused ) && ( !cell.IsKeyboardFocusWithin ) )
+          return;
 
-          if( ( cell != null ) && ( this.SelectionUnit == SelectionUnit.Cell ) && ( !cell.IsKeyboardFocused ) && ( !cell.IsKeyboardFocusWithin ) )
-            return;
-        }
+        var itemIndex = DataGridVirtualizingPanel.GetItemIndex( row );
+        var item = dataGridContext.GetItemFromContainer( row );
 
-        int columnIndex = ( cell == null ) ? -1 : cell.ParentColumn.VisiblePosition;
+        var column = ( cell != null ) ? cell.ParentColumn : null;
+        var columnIndex = ( column != null ) ? column.VisiblePosition : -1;
 
         // If we have an error during the EndEdit that prevent the PreviewMouseDown from occuring 
         // (since we put e.Handled = true if an exception occurs), 
         // the PreviewMouseUp will not occur, so it is safe to call UpdateSelection().
+        newPosition = new SelectionRangePoint( dataGridContext, item, itemIndex, columnIndex );
+        rowIsBeingEdited = row.IsBeingEdited;
+      }
+
+      if( newPosition != null )
+      {
         m_selectionChangerManager.UpdateSelection(
-          m_mouseDownCurrentDataGridContext, m_mouseDownCurrentItem, m_mouseDownCurrentColumn,
-          newDataGridContext, true, row.IsBeingEdited, sourceDataItemIndex, item, columnIndex,
+          m_mouseDownSelectionRangePoint, newPosition, true, rowIsBeingEdited,
           SelectionManager.UpdateSelectionSource.MouseUp );
       }
     }
@@ -5378,10 +5530,7 @@ namespace Xceed.Wpf.DataGrid
     {
       base.OnPreviewGotKeyboardFocus( e );
 
-      if( e.Handled )
-        return;
-
-      if( this.InhibitPreviewGotKeyboardFocus )
+      if( e.Handled || m_inhibitPreviewGotKeyboardFocus.IsSet )
         return;
 
       DependencyObject newFocus = e.NewFocus as DependencyObject;
@@ -5393,7 +5542,6 @@ namespace Xceed.Wpf.DataGrid
           e.Handled = true;
           this.ForceFocus( this.ScrollViewer );
         }
-
         return;
       }
 
@@ -5412,7 +5560,7 @@ namespace Xceed.Wpf.DataGrid
           {
             using( this.InhibitSetFocus() )
             {
-              currentDataGridContext.SetCurrent( internalCurrentItem, null, 0, currentDataGridContext.CurrentColumn, false, false, this.SynchronizeSelectionWithCurrent );
+              currentDataGridContext.SetCurrent( internalCurrentItem, null, 0, currentDataGridContext.CurrentColumn, false, false, this.SynchronizeSelectionWithCurrent, AutoScrollCurrentItemSourceTriggers.FocusChanged );
             }
           }
         }
@@ -5422,10 +5570,29 @@ namespace Xceed.Wpf.DataGrid
           //try to fetch the Container for the Internal current item
           itemUIElement = currentDataGridContext.GetContainerFromItem( internalCurrentItem ) as UIElement;
 
+          //  Special case when the previous element with the focus is now collapsed, the focus must be moved to the ScrollViewer, so the grid is kept focusable. 
+          bool focusScrollViewer = ( itemUIElement == null );
+          if( !focusScrollViewer )
+          {
+            HeaderFooterItem headerFooterItem = itemUIElement as HeaderFooterItem;
+            if( headerFooterItem != null )
+            {
+              focusScrollViewer = headerFooterItem.Visibility == Visibility.Collapsed;
+              if( !focusScrollViewer )
+              {
+                UIElement container = headerFooterItem.Container as UIElement;
+                if( container != null )
+                {
+                  focusScrollViewer = container.Visibility == Visibility.Collapsed;
+                }
+              }
+            }
+          }
+
           //if container exists, then it's visible (or close to it), try to focus it 
-          if( itemUIElement == null )
+          if( focusScrollViewer )
           {
-            currentDataGridContext.DelayBringIntoViewAndFocusCurrent();
+            currentDataGridContext.DelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.FocusChanged );
 
             if( newFocus != this.ScrollViewer )
             {
@@ -5452,27 +5619,17 @@ namespace Xceed.Wpf.DataGrid
       bool oldFocusWasInTheGrid = ( e.OldFocus != null ) && ( TreeHelper.IsDescendantOf( e.OldFocus as DependencyObject, this, false ) );
       DataGridContext oldCurrentDataGridContext = this.CurrentContext;
 
-      object oldCurrentItem;
-      ColumnBase oldCurrentColumn;
-      Row oldRow;
-
-      if( oldCurrentDataGridContext == null )
-      {
-        oldCurrentItem = null;
-        oldCurrentColumn = null;
-        oldRow = null;
-      }
-      else
+      Row oldRow = null;
+      SelectionRangePoint oldPosition = null;
+      if( oldCurrentDataGridContext != null )
       {
-        oldCurrentItem = ( oldCurrentDataGridContext == null ) ? null : oldCurrentDataGridContext.CurrentItem;
-        oldCurrentColumn = ( oldCurrentDataGridContext == null ) ? null : oldCurrentDataGridContext.CurrentColumn;
-        oldRow = ( oldCurrentDataGridContext == null ) ? null : oldCurrentDataGridContext.CurrentRow;
+        oldRow = oldCurrentDataGridContext.CurrentRow;
+        oldPosition = SelectionRangePoint.TryCreateFromCurrent( oldCurrentDataGridContext );
       }
 
       FrameworkElement newContainer = CustomItemContainerGenerator.FindContainerFromChildOrRowSelectorOrSelf( this, newFocus );
 
-      DataGridContext newDataGridContext = ( newContainer == null )
-        ? null : DataGridControl.GetDataGridContext( newContainer );
+      DataGridContext newDataGridContext = ( newContainer == null ) ? null : DataGridControl.GetDataGridContext( newContainer );
 
       Row newRow = Row.FromContainer( newContainer );
       Cell newCell = newFocus as Cell;
@@ -5500,13 +5657,11 @@ namespace Xceed.Wpf.DataGrid
               FrameworkElement previousNewContainer = newContainer;
               oldRow.EndEdit();
 
-              // We must refetch the container for the current item in case EndEdit triggers a reset on the 
-              // CustomItemContainerGenerator and remap this item to a container other than the one previously
-              // fetched
+              // We must refetch the container for the current item in case EndEdit triggers a reset on the  CustomItemContainerGenerator
+              // and remap this item to a container other than the one previously fetched
               this.UpdateLayout();
 
-              newContainer = ( item == null ) ?
-                null : newDataGridContext.GetContainerFromItem( item ) as FrameworkElement;
+              newContainer = ( item == null ) ? null : newDataGridContext.GetContainerFromItem( item ) as FrameworkElement;
 
               newRow = Row.FromContainer( newContainer );
               newCell = ( newRow == null ) ? null : newRow.Cells[ newColumn ];
@@ -5550,7 +5705,7 @@ namespace Xceed.Wpf.DataGrid
       if( item == null )
         return;
 
-      if( newCell != null )
+      if( newCell != null && newRow != null )
       {
         IDisposable inhibitSetFocus = null;
 
@@ -5569,7 +5724,7 @@ namespace Xceed.Wpf.DataGrid
           // is called twice if it's the case which give twice the focus and then endsup unselecting the element during the mouseUp 
           // because during the second updateSelection, the element is already contained then m_updateSelectionOnNextMouseUp set to true
           bool isNewFocusParentTheOldFocusedCell = ( ( oldFocusedCell != null ) && ( newFocusedElement != null ) ) ?
-                                ( oldFocusedCell != Cell.FindFromChild( this, newFocusedElement ) ) : true;
+                                                     ( oldFocusedCell != Cell.FindFromChild( this, newFocusedElement ) ) : true;
 
           int sourceDataItemIndex = DataGridVirtualizingPanel.GetItemIndex( newRow );
 
@@ -5581,20 +5736,16 @@ namespace Xceed.Wpf.DataGrid
           else if( !newCell.IsCurrent )
           {
             //set the current row/column as this cell's
-            newDataGridContext.SetCurrent(
-              item, newRow,
-              sourceDataItemIndex,
-              newColumn, false, true, false );
+            newDataGridContext.SetCurrent( item, newRow, sourceDataItemIndex, newColumn, false, true, false, AutoScrollCurrentItemSourceTriggers.FocusChanged );
           }
 
           if( isNewFocusParentTheOldFocusedCell )
           {
             bool rowIsBeingEditedAndCurrentRowNotChanged = this.IsRowBeingEditedAndCurrentRowNotChanged( newRow, oldRow );
 
-            m_selectionChangerManager.UpdateSelection(
-              oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumn,
-              newDataGridContext, oldFocusWasInTheGrid, rowIsBeingEditedAndCurrentRowNotChanged,
-              sourceDataItemIndex, item, newCell.ParentColumn.VisiblePosition, null );
+            var newPosition = SelectionRangePoint.TryCreateRangePoint( newDataGridContext, item, sourceDataItemIndex, newCell.ParentColumn.VisiblePosition );
+            m_selectionChangerManager.UpdateSelection( oldPosition, newPosition, oldFocusWasInTheGrid,
+                                                       rowIsBeingEditedAndCurrentRowNotChanged, null );
           }
         }
         catch( DataGridException )
@@ -5621,8 +5772,8 @@ namespace Xceed.Wpf.DataGrid
         {
           ColumnBase currentColumn = null;
 
-          //if the current column need to be propagated
-          if( this.NavigationBehavior == NavigationBehavior.CellOnly )
+          //  The current column may need to be propagated, unless the focus is being moved to a GroupHeaderControl
+          if( ( this.NavigationBehavior == NavigationBehavior.CellOnly ) && !( item is GroupHeaderFooterItem ) )
           {
             currentColumn = newDataGridContext.CurrentColumn;
 
@@ -5634,11 +5785,9 @@ namespace Xceed.Wpf.DataGrid
 
               if( columns.Count > 0 )
               {
-
-                int firstFocusableColumn = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( newDataGridContext, newRow );
-
+                int firstFocusableColumn = NavigationHelper.GetFirstVisibleFocusableColumnIndex( newDataGridContext, newRow );
                 if( firstFocusableColumn < 0 )
-                  throw new DataGridException( "Trying to edit while no cell is focusable. " );
+                  throw new DataGridException( "Trying to edit while no cell is focusable. ", this );
 
                 currentColumn = columns[ firstFocusableColumn ];
               }
@@ -5658,7 +5807,7 @@ namespace Xceed.Wpf.DataGrid
 
             try
             {
-              newDataGridContext.SetCurrent( item, newRow, sourceDataItemIndex, null, true, true, false );
+              newDataGridContext.SetCurrent( item, newRow, sourceDataItemIndex, null, true, true, false, AutoScrollCurrentItemSourceTriggers.FocusChanged );
             }
             finally
             {
@@ -5671,17 +5820,16 @@ namespace Xceed.Wpf.DataGrid
           else
           {
             e.Handled = true; // We prevent the focus to go on the row since we will move it on a cell
-            newDataGridContext.SetCurrent( item, newRow, sourceDataItemIndex, currentColumn, true, true, false );
+            newDataGridContext.SetCurrent( item, newRow, sourceDataItemIndex, currentColumn, true, true, false, AutoScrollCurrentItemSourceTriggers.FocusChanged );
           }
 
           int columnIndex = ( currentColumn == null ) ? -1 : currentColumn.VisiblePosition;
 
           bool rowIsBeingEditedAndCurrentRowNotChanged = this.IsRowBeingEditedAndCurrentRowNotChanged( newRow, oldRow );
 
-          m_selectionChangerManager.UpdateSelection(
-            oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumn,
-            newDataGridContext, oldFocusWasInTheGrid, rowIsBeingEditedAndCurrentRowNotChanged,
-            sourceDataItemIndex, item, columnIndex, null );
+          var newPosition = SelectionRangePoint.TryCreateRangePoint( newDataGridContext, item, sourceDataItemIndex, columnIndex );
+          m_selectionChangerManager.UpdateSelection( oldPosition, newPosition, oldFocusWasInTheGrid,
+                                                     rowIsBeingEditedAndCurrentRowNotChanged, null );
         }
         catch( DataGridException )
         {
@@ -5707,14 +5855,16 @@ namespace Xceed.Wpf.DataGrid
 
         try
         {
+          SelectionRangePoint newPosition;
           ColumnBase currentColumn = newDataGridContext.CurrentColumn;
-          newDataGridContext.SetCurrent( item, null, -1, currentColumn, true, true, false );
+          newDataGridContext.SetCurrent( item, null, -1, currentColumn, true, true, false, AutoScrollCurrentItemSourceTriggers.FocusChanged );
 
           int columnIndex = ( currentColumn == null ) ? -1 : currentColumn.VisiblePosition;
 
-          m_selectionChangerManager.UpdateSelection(
-            oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumn,
-            newDataGridContext, oldFocusWasInTheGrid, false, -1, item, columnIndex, null );
+          newPosition = SelectionRangePoint.TryCreateRangePoint( newDataGridContext, item, -1, columnIndex );
+
+          m_selectionChangerManager.UpdateSelection( oldPosition, newPosition,
+                                                     oldFocusWasInTheGrid, false, null );
         }
         catch( DataGridException )
         {
@@ -5742,12 +5892,27 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    protected override void OnMouseLeftButtonUp( MouseButtonEventArgs e )
+    {
+      base.OnMouseLeftButtonUp( e );
+
+      if( e.Handled )
+        return;
+    }
+
+    protected override void OnMouseMove( MouseEventArgs e )
+    {
+      base.OnMouseMove( e );
+
+      if( e.Handled )
+        return;
+    }
+
     protected override AutomationPeer OnCreateAutomationPeer()
     {
       return new DataGridControlAutomationPeer( this );
     }
 
-
     internal static object GetFixedItemFromContainer( DependencyObject container )
     {
       object fixedItem = DataGridControl.GetFixedItem( container );
@@ -5763,17 +5928,10 @@ namespace Xceed.Wpf.DataGrid
       if( element == null )
         return false;
 
-      Debug.Assert( !this.InhibitPreviewGotKeyboardFocus );
-      this.InhibitPreviewGotKeyboardFocus = true;
-
-      try
+      using( m_inhibitPreviewGotKeyboardFocus.Set() )
       {
         return element.Focus();
       }
-      finally
-      {
-        this.InhibitPreviewGotKeyboardFocus = false;
-      }
     }
 
     internal DependencyObject GetContainerForFixedItem( object item )
@@ -5811,12 +5969,14 @@ namespace Xceed.Wpf.DataGrid
     {
       //this function is called by the CustomItemContainerGenerator to prepare both the ActualDataItems and the custom items (e.g., Headers and Footers)
       DataGridControl.SetContainer( container, container );
+      DataGridControl.SetIsContainerPrepared( container, true );
       this.PrepareContainerForItemOverride( container, item );
     }
 
     internal void ClearItemContainer( DependencyObject container, object item )
     {
-      DataGridControl.ClearContainer( container );
+      //DataGridControl.ClearContainer( container );
+      DataGridControl.ClearIsContainerPrepared( container );
       this.ClearContainerForItemOverride( container, item );
     }
 
@@ -5929,7 +6089,7 @@ namespace Xceed.Wpf.DataGrid
 
     internal void CleanUpAfterUnload()
     {
-      m_customItemContainerGenerator.CleanupGenerator( false );
+      m_customItemContainerGenerator.CleanupGenerator();
       this.SetValue( ParentDataGridControlPropertyKey, null );
     }
 
@@ -5961,7 +6121,6 @@ namespace Xceed.Wpf.DataGrid
         this.AutoCreateForeignKeyConfigurations );
     }
 
-
     private static bool IsRemoveAllowedForDeleteCommand( IList list )
     {
       // If the list has a fixed sized or if it's read only, we won't allow remove.
@@ -6044,13 +6203,15 @@ namespace Xceed.Wpf.DataGrid
           rowSelectorPane.FreeRowSelector( element );
         }
 
-        dataGrid.ClearItemContainer( element, GetFixedItem( element ) );
+        dataGrid.ClearItemContainer( element, DataGridControl.GetFixedItem( element ) );
         DataGridControl.SetDataGridContext( element, null );
       }
 
       targetPanel.Children.Clear();
 
+      var view = dataGrid.GetView();
       DataGridContext dataGridContext = dataGrid.DataGridContext;
+
       foreach( DataTemplate template in collection )
       {
         HeaderFooterItem control = new HeaderFooterItem();
@@ -6147,7 +6308,6 @@ namespace Xceed.Wpf.DataGrid
       return new Size( width, height );
     }
 
-
     private delegate void ParametrizedGenericHandler( object param );
     private delegate void DelayedSetFocusHelperHandler( bool forceFocus, bool preserveEditorFocus );
     private delegate bool GenericHandler();
@@ -6168,7 +6328,52 @@ namespace Xceed.Wpf.DataGrid
 
     bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
     {
-      if( managerType == typeof( FrameworkElementUnloadedEventManager ) )
+      if( managerType == typeof( RootGroupChangedEventManager ) )
+      {
+        this.OnDataGridCollectionView_RootGroupChanged( sender, e );
+        return true;
+      }
+      else if( managerType == typeof( CollectionChangedEventManager ) )
+      {
+        this.OnDataGridDetailDescriptionsChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+        return true;
+      }
+      else if( managerType == typeof( ProxyCollectionRefreshEventManager ) )
+      {
+        this.OnDataGridCollectionView_ProxyCollectionRefresh( sender, e );
+        return true;
+      }
+      else if( managerType == typeof( ProxyGroupDescriptionsChangedEventManager ) )
+      {
+        this.OnDataGridCollectionView_ProxyGroupDescriptionsChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+        return true;
+      }
+      else if( managerType == typeof( ProxySortDescriptionsChangedEventManager ) )
+      {
+        this.OnDataGridCollectionView_ProxySortDescriptionsChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+        return true;
+      }
+      else if( managerType == typeof( ProxyAutoFilterValuesChangedEventManager ) )
+      {
+        this.OnDataGridCollectionView_ProxyAutoFilterValuesChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+        return true;
+      }
+      else if( managerType == typeof( ProxyApplyingFilterCriteriasEventManager ) )
+      {
+        this.OnDataGridCollectionView_ProxyApplyingFilterCriterias( sender, e );
+        return true;
+      }
+      else if( managerType == typeof( ConnectionStateChangedEventManager ) )
+      {
+        this.OnDataGridVirtualizingCollectionViewBase_ConnectionStateChanged( sender, e );
+        return true;
+      }
+      else if( managerType == typeof( ConnectionErrorChangedEventManager ) )
+      {
+        this.OnDataGridVirtualizingCollectionViewBase_ConnectionErrorChanged( sender, e );
+        return true;
+      }
+      else if( managerType == typeof( FrameworkElementUnloadedEventManager ) )
       {
         this.UnhookToUnloaded();
         this.SaveDataGridContextState( this.DataGridContext, true, int.MaxValue );
@@ -6198,7 +6403,10 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region Private Fields
+
     private IDisposable m_columnsInitDisposable; // = null
+    private IDisposable m_inhibitItemsCollectionChanged; // = null
 
     private int m_beginInitCount; // = 0
 
@@ -6212,8 +6420,10 @@ namespace Xceed.Wpf.DataGrid
     private object m_currentItemInEdition; // = null
     private RowState m_currentRowInEditionState; // = null
 
-    private int m_inhibitBringIntoView; // = 0
-    private int m_inhibitSetFocus; // = 0
+    private readonly AutoResetFlag m_inhibitBringIntoView = AutoResetFlagFactory.Create( false );
+    private readonly AutoResetFlag m_inhibitSetFocus = AutoResetFlagFactory.Create( false );
+    private readonly AutoResetFlag m_inhibitPreviewGotKeyboardFocus = AutoResetFlagFactory.Create( false );
+    private readonly AutoScrollCurrentItemSourceTriggersRestrictions m_inhibitAutoScroll = new AutoScrollCurrentItemSourceTriggersRestrictions();
     private DispatcherOperation m_queueBringIntoView; // = null
     private DispatcherOperation m_queueSetFocus; // = null
     private DispatcherOperation m_queueClearCurrentColumn; // = null
@@ -6227,9 +6437,7 @@ namespace Xceed.Wpf.DataGrid
     private CommandBinding m_refreshCommandBinding; // = null;
     private IDisposable m_mouseDownUpdateSelectionSource;
 
-    private DataGridContext m_mouseDownCurrentDataGridContext;
-    private object m_mouseDownCurrentItem;
-    private ColumnBase m_mouseDownCurrentColumn;
+    private SelectionRangePoint m_mouseDownSelectionRangePoint;
 
     private bool m_isFirstTimeLoaded = true;
 
@@ -6237,15 +6445,9 @@ namespace Xceed.Wpf.DataGrid
 
     private BitVector32 m_flags = new BitVector32();
 
-    private EventHandler m_proxyCollectionRefreshHandler;
-    private NotifyCollectionChangedEventHandler m_proxyGroupDescriptionsChangedHandler;
-    private NotifyCollectionChangedEventHandler m_proxySortDescriptionsChangedHandler;
-    private NotifyCollectionChangedEventHandler m_proxyAutoFilterValuesChangedHandler;
-    private EventHandler m_proxyApplyingFilterCriteriasHandler;
-    private EventHandler m_connectionStateChangedHandler;
-    private EventHandler m_connectionStateErrorHandler;
-    private NotifyCollectionChangedEventHandler m_dataGridDetailDescriptionsChangedHandler;
-    private EventHandler m_rootGroupChangedHandler;
+    #endregion
+
+    #region DataGridControlFlags Nested Type
 
     [Flags]
     private enum DataGridControlFlags
@@ -6255,67 +6457,13 @@ namespace Xceed.Wpf.DataGrid
       UsePrintView = 4,
       IsBoundToDataGridVirtualizingCollectionViewBase = 8,
       ViewPreservesContainerSize = 16,
-      InhibitPreviewGotKeyboardFocus = 32,
-      DebugSaveRestore = 64,
-      ItemsSourceChangedDelayed = 128,
-      SelectedIndexPropertyNeedCoerce = 256,
-      SelectedItemPropertyNeedCoerce = 512
-    }
-
-    #region GridControlQueueInhibiter Private Class
-
-    private sealed class GridControlQueueInhibiter : IDisposable
-    {
-      public GridControlQueueInhibiter( DataGridControl dataGrid )
-      {
-        if( dataGrid == null )
-        {
-          throw new ArgumentNullException( "dataGrid" );
-        }
-
-        m_gridControl = dataGrid;
-        m_gridControl.m_inhibitBringIntoView++;
-      }
-
-      #region IDisposable Members
-
-      public void Dispose()
-      {
-        m_gridControl.m_inhibitBringIntoView--;
-      }
-
-      #endregion
-
-      private DataGridControl m_gridControl; // = null
-    }
-
-    #endregion
-
-    #region DataGridControlSetFocusInhibiter Private Class
-
-    private sealed class DataGridControlSetFocusInhibiter : IDisposable
-    {
-      public DataGridControlSetFocusInhibiter( DataGridControl dataGrid )
-      {
-        if( dataGrid == null )
-          throw new ArgumentNullException( "dataGrid" );
-
-        m_gridControl = dataGrid;
-        m_gridControl.m_inhibitSetFocus++;
-      }
-
-      #region IDisposable Members
-
-      public void Dispose()
-      {
-        m_gridControl.m_inhibitSetFocus--;
-      }
-
-      #endregion
-
-      private DataGridControl m_gridControl; // = null
+      DebugSaveRestore = 32,
+      ItemsSourceChangedDelayed = 64,
+      SelectedIndexPropertyNeedCoerce = 128,
+      SelectedItemPropertyNeedCoerce = 256
     }
 
     #endregion
   }
+
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridException.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridException.cs
index 26f8c098..13017216 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridException.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridException.cs
@@ -34,15 +34,73 @@ namespace Xceed.Wpf.DataGrid
     {
     }
 
+    public DataGridException( string message, DataGridControl dataGridControl )
+      : base( message )
+    {
+      this.DataGridControl = dataGridControl;
+    }
+
     public DataGridException( string message, Exception innerException )
       : base( message, innerException )
     {
     }
 
+    public DataGridException( string message, Exception innerException, DataGridControl dataGridControl )
+      : base( message, innerException )
+    {
+      this.DataGridControl = dataGridControl;
+    }
+
     protected DataGridException( SerializationInfo info, StreamingContext context )
       : base( info, context )
     {
     }
 
+    #region DataGridControl Property
+
+    public DataGridControl DataGridControl
+    {
+      get;
+      private set;
+    }
+
+    #endregion
+
+    internal static void ThrowSystemException( string message, Type exceptionType, string source, string argument = "" )
+    {
+      Exception exception;
+
+      if( exceptionType == typeof( ArgumentException ) )
+      {
+        exception = new ArgumentException( message, argument );
+      }
+      else if( exceptionType == typeof( ArgumentNullException ) )
+      {
+        exception = new ArgumentNullException( message );
+      }
+      else if( exceptionType == typeof( ArgumentOutOfRangeException ) )
+      {
+        exception = new ArgumentOutOfRangeException( argument, message );
+      }
+      else if( exceptionType == typeof( IndexOutOfRangeException ) )
+      {
+        exception = new IndexOutOfRangeException( message );
+      }
+      else if( exceptionType == typeof( InvalidOperationException ) )
+      {
+        exception = new InvalidOperationException( message );
+      }
+      else if( exceptionType == typeof( NotSupportedException ) )
+      {
+        exception = new NotSupportedException( message );
+      }
+      else
+      {
+        exception = new Exception( message );
+      }
+
+      exception.Source = source;
+      throw exception;
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridInternalException.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridInternalException.cs
index bcbaf37f..ecdef1f6 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridInternalException.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridInternalException.cs
@@ -33,6 +33,11 @@ namespace Xceed.Wpf.DataGrid
     {
     }
 
+    public DataGridInternalException( string message, DataGridControl dataGridControl )
+      : base( message, dataGridControl )
+    {
+    }
+
     public DataGridInternalException( Exception innerException )
       : this( DefaultMessage, innerException )
     {
@@ -43,6 +48,11 @@ namespace Xceed.Wpf.DataGrid
     {
     }
 
+    public DataGridInternalException( string message, Exception innerException, DataGridControl dataGridControl )
+      : base( message, innerException, dataGridControl )
+    {
+    }
+
     protected DataGridInternalException( SerializationInfo info, StreamingContext context )
       : base( info, context )
     {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemContainerManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemContainerManager.cs
new file mode 100644
index 00000000..6d82fae6
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemContainerManager.cs
@@ -0,0 +1,158 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DataGridItemContainerManager
+  {
+    #region Constructor
+
+    internal DataGridItemContainerManager( IDataGridItemContainer owner )
+    {
+      if( owner == null )
+        throw new ArgumentNullException( "owner" );
+
+      if( !( owner is FrameworkElement ) )
+        throw new ArgumentException( "The owner must derive from FrameworkElement.", "owner" );
+
+      m_owner = owner;
+    }
+
+    #endregion
+
+    internal void Prepare( DataGridContext dataGridContext, object dataItem )
+    {
+      m_containersPrepared = true;
+      m_dataGridContext = dataGridContext;
+      m_dataItem = dataItem;
+
+      this.Update();
+    }
+
+    internal void Clear()
+    {
+      m_containersPrepared = false;
+      m_dataGridContext = null;
+      m_dataItem = null;
+
+      try
+      {
+        this.ClearContainers();
+      }
+      finally
+      {
+        m_unpreparedContainers.Clear();
+        m_preparedContainers.Clear();
+      }
+    }
+
+    internal void Update()
+    {
+      var newContainers = m_owner.GetTemplatedChildDataGridItemContainers().ToList();
+
+      try
+      {
+        this.ClearContainers( newContainers );
+      }
+      finally
+      {
+        foreach( var container in newContainers )
+        {
+          if( m_preparedContainers.Contains( container ) || m_unpreparedContainers.Contains( container ) )
+            continue;
+
+          m_unpreparedContainers.Add( container );
+        }
+      }
+
+      this.PrepareContainers();
+    }
+
+    private void PrepareContainers()
+    {
+      if( !m_containersPrepared )
+        return;
+
+      foreach( var container in m_unpreparedContainers.ToList() )
+      {
+        m_unpreparedContainers.Remove( container );
+        m_preparedContainers.Add( container );
+
+        // Row based objects apply their template through their implementation of PrepareContainer.
+        // No need to call ApplyTemplate beforehand.
+        var row = container as Row;
+        if( row == null )
+        {
+          var fe = container as FrameworkElement;
+          if( fe != null )
+          {
+            fe.ApplyTemplate();
+          }
+        }
+        else
+        {
+          // When dealing with a row, make sure its cells are properly initialized with their corresponding columns.
+          row.SynchronizeCellsWithColumns( m_dataGridContext.DataGridControl, null, false );
+        }
+
+        container.PrepareContainer( m_dataGridContext, m_dataItem );
+      }
+    }
+
+    private void ClearContainers()
+    {
+      this.ClearContainers( new List<IDataGridItemContainer>( 0 ) );
+    }
+
+    private void ClearContainers( ICollection<IDataGridItemContainer> keep )
+    {
+      foreach( var container in m_unpreparedContainers.Except( keep ).ToList() )
+      {
+        m_unpreparedContainers.Remove( container );
+
+        var row = container as Row;
+        if( row != null )
+        {
+          row.ClearCellsHost();
+        }
+      }
+
+      foreach( var container in m_preparedContainers.Except( keep ).ToList() )
+      {
+        m_preparedContainers.Remove( container );
+
+        container.ClearContainer();
+      }
+    }
+
+    #region Private Fields
+
+    private readonly IDataGridItemContainer m_owner;
+    private readonly ICollection<IDataGridItemContainer> m_unpreparedContainers = new HashSet<IDataGridItemContainer>();
+    private readonly ICollection<IDataGridItemContainer> m_preparedContainers = new HashSet<IDataGridItemContainer>();
+
+    private DataGridContext m_dataGridContext;
+    private object m_dataItem;
+    private bool m_containersPrepared; //false
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemsHost.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemsHost.cs
index 5a92d377..1d7ce855 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemsHost.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridItemsHost.cs
@@ -15,15 +15,14 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Windows;
-using System.Windows.Media;
-using System.Windows.Controls;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.Specialized;
-using System.Windows.Controls.Primitives;
 using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls.Primitives;
 using System.Windows.Input;
+using System.Windows.Media;
 using Xceed.Utils.Wpf;
 
 namespace Xceed.Wpf.DataGrid
@@ -161,7 +160,6 @@ namespace Xceed.Wpf.DataGrid
       if( m_children == null )
         throw new InvalidOperationException( "An attempt was made to retrieve a visual child when none exists for this element." );
 
-      //TODO (case 117289): Insert ZIndex lookup table checkup here.
 
       if( ( index < 0 ) || ( index >= m_children.Count ) )
         throw new ArgumentOutOfRangeException( "index", index, "index must be greater than or equal to zero and less than or equal to the number of contained UI elements." );
@@ -172,7 +170,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region  PreviewKeyDown and KeyDown handling overrides
+    #region PreviewKeyDown and KeyDown handling overrides
 
     protected override void OnPreviewKeyDown( KeyEventArgs e )
     {
@@ -431,7 +429,7 @@ namespace Xceed.Wpf.DataGrid
       if( ( m_generator != null ) && ( newValue != null ) )
       {
         if( newValue.CustomItemContainerGenerator != m_generator )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "The custom generator is different on the parent DataGridControl.", newValue );
       }
 
       // We must ensure that the old ItemsHost clears the Content of the
@@ -445,7 +443,7 @@ namespace Xceed.Wpf.DataGrid
       // DataGridControl and when the System color scheme is changed.
       if( ( oldValue != null ) && ( newValue == null ) )
       {
-        oldValue.CustomItemContainerGenerator.CleanupGenerator( false );
+        oldValue.CustomItemContainerGenerator.CleanupGenerator();
       }
 
       if( newValue != null )
@@ -501,7 +499,7 @@ namespace Xceed.Wpf.DataGrid
           navDirection = FocusNavigationDirection.Up;
           break;
         default:
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "An invalid key was processed to move the focus." );
       }
 
       //2. Call MoveFocus() on the currently focused keyboard element, 
@@ -570,6 +568,71 @@ namespace Xceed.Wpf.DataGrid
       return null;
     }
 
+    internal bool ValidateTabKeyHandleIsWithin( FrameworkElement originalSource, KeyboardDevice keyboardDevice )
+    {
+      DependencyObject predictedNextVisual = null;
+
+      //If the original source is not a control (e.g. the cells panel instead of a cell), columns will be used to move focus.
+      //In the case of a ListBox set with Cycle or Contained navigation mode, we must move in the other direction if on the first or last item,
+      //since PedictFocus will throw is we use FocusNavigationDirection.First/Last.
+      if( originalSource != null )
+      {
+        if( ( keyboardDevice.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
+        {
+          predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Left );
+          if( predictedNextVisual == null )
+          {
+            predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Up );
+            if( predictedNextVisual == null )
+            {
+              KeyboardNavigationMode navigationMode = ( KeyboardNavigationMode )originalSource.GetValue( KeyboardNavigation.TabNavigationProperty );
+              if( navigationMode == KeyboardNavigationMode.Cycle || navigationMode == KeyboardNavigationMode.Contained )
+              {
+                predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Right );
+                if( predictedNextVisual == null )
+                {
+                  predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Down );
+                }
+              }
+            }
+          }
+        }
+        else
+        {
+          predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Right );
+          if( predictedNextVisual == null )
+          {
+            predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Down );
+            if( predictedNextVisual == null )
+            {
+              KeyboardNavigationMode navigationMode = ( KeyboardNavigationMode )originalSource.GetValue( KeyboardNavigation.TabNavigationProperty );
+              if( navigationMode == KeyboardNavigationMode.Cycle || navigationMode == KeyboardNavigationMode.Contained )
+              {
+                predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Left );
+                if( predictedNextVisual == null )
+                {
+                  predictedNextVisual = originalSource.PredictFocus( FocusNavigationDirection.Up );
+                }
+              }
+            }
+          }
+        }
+      }
+
+      if( predictedNextVisual != null )
+      {
+        Cell ownerCell = Cell.FindFromChild( predictedNextVisual );
+
+        if( ( ownerCell != null ) && ( ownerCell.ParentColumn == this.ParentDataGridControl.CurrentColumn ) )
+        {
+          if( object.Equals( ownerCell.ParentRow.DataContext, this.ParentDataGridControl.CurrentItemInEdition ) )
+            return true;
+        }
+      }
+
+      return false;
+    }
+
     #endregion
 
     #region Private Methods
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridVirtualizingPanel.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridVirtualizingPanel.cs
index 389e85d2..a08beaf4 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridVirtualizingPanel.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataGridVirtualizingPanel.cs
@@ -47,9 +47,7 @@ namespace Xceed.Wpf.DataGrid
         if( ( control1 != null ) && ( m_customGenerator != null ) )
         {
           if( control1.IsGrouping == true )
-          {
             throw new NotSupportedException( "GroupStyles are not supported by the DataGridVirtualizingPanel." );
-          }
 
           retval = m_customGenerator;
         }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptor.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptor.cs
new file mode 100644
index 00000000..e7bdfb8c
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptor.cs
@@ -0,0 +1,117 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DataItemEventDescriptor : DataItemEventDescriptorBase
+  {
+    #region Constructor
+
+    internal DataItemEventDescriptor(
+      DataItemTypeDescriptor owner,
+      EventDescriptor parent,
+      Type componentType,
+      Type eventType,
+      Action<object, object> addHandler,
+      Action<object, object> removeHandler )
+      : base( owner, parent )
+    {
+      if( componentType == null )
+        throw new ArgumentNullException( "componentType" );
+
+      if( eventType == null )
+        throw new ArgumentNullException( "eventType" );
+
+      if( addHandler == null )
+        throw new ArgumentNullException( "addHandler" );
+
+      if( removeHandler == null )
+        throw new ArgumentNullException( "removeHandler" );
+
+      m_componentType = componentType;
+      m_eventType = eventType;
+      m_addHandler = addHandler;
+      m_removeHandler = removeHandler;
+    }
+
+    #endregion
+
+    #region ComponentType Property
+
+    public override Type ComponentType
+    {
+      get
+      {
+        return m_componentType;
+      }
+    }
+
+    private readonly Type m_componentType;
+
+    #endregion
+
+    #region EventType Property
+
+    public override Type EventType
+    {
+      get
+      {
+        return m_eventType;
+      }
+    }
+
+    private readonly Type m_eventType;
+
+    #endregion
+
+    public override void AddEventHandler( object component, Delegate value )
+    {
+      if( component == null )
+        return;
+
+      m_addHandler.Invoke( component, value );
+    }
+
+    public override void RemoveEventHandler( object component, Delegate value )
+    {
+      if( component == null )
+        return;
+
+      m_removeHandler.Invoke( component, value );
+    }
+
+    public override int GetHashCode()
+    {
+      return base.GetHashCode();
+    }
+
+    public override bool Equals( object obj )
+    {
+      return ( obj is DataItemEventDescriptor )
+          && ( base.Equals( obj ) );
+    }
+
+    #region Private Fields
+
+    private readonly Action<object, object> m_addHandler;
+    private readonly Action<object, object> m_removeHandler;
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorBase.cs
new file mode 100644
index 00000000..39dbed65
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorBase.cs
@@ -0,0 +1,80 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class DataItemEventDescriptorBase : EventDescriptor
+  {
+    #region Constructor
+
+    protected DataItemEventDescriptorBase( DataItemTypeDescriptor owner, EventDescriptor parent )
+      : base( parent )
+    {
+      if( owner == null )
+        throw new ArgumentNullException( "owner" );
+
+      m_owner = owner;
+    }
+
+    #endregion
+
+    #region IsMulticast Property
+
+    public override bool IsMulticast
+    {
+      get
+      {
+        return typeof( MulticastDelegate ).IsAssignableFrom( this.EventType );
+      }
+    }
+
+    #endregion
+
+    #region Owner Protected Property
+
+    protected DataItemTypeDescriptor Owner
+    {
+      get
+      {
+        return m_owner;
+      }
+    }
+
+    private readonly DataItemTypeDescriptor m_owner;
+
+    #endregion
+
+    public override int GetHashCode()
+    {
+      return base.GetHashCode();
+    }
+
+    public override bool Equals( object obj )
+    {
+      var descriptor = obj as DataItemEventDescriptorBase;
+      if( object.ReferenceEquals( descriptor, null ) )
+        return false;
+
+      return ( base.Equals( obj ) )
+          && ( descriptor.ComponentType == this.ComponentType )
+          && ( descriptor.EventType == this.EventType )
+          && ( descriptor.IsMulticast == this.IsMulticast );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorFactory.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorFactory.cs
new file mode 100644
index 00000000..0da91534
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemEventDescriptorFactory.cs
@@ -0,0 +1,166 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Reflection;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DataItemEventDescriptorFactory
+  {
+    #region Static Fields
+
+    private static readonly Type s_reflectEventDescriptorType;
+
+    #endregion
+
+    #region Constructor
+
+    static DataItemEventDescriptorFactory()
+    {
+      s_reflectEventDescriptorType = Assembly.GetAssembly( typeof( EventDescriptor ) ).GetType( "System.ComponentModel.ReflectEventDescriptor" );
+    }
+
+    internal DataItemEventDescriptorFactory( DataItemTypeDescriptor typeDescriptor )
+    {
+      if( typeDescriptor == null )
+        throw new ArgumentNullException( "typeDescriptor" );
+
+      m_typeDescriptor = typeDescriptor;
+    }
+
+    #endregion
+
+    internal DataItemEventDescriptorBase CreateEventDescriptor( EventDescriptor source )
+    {
+      if( !DataItemEventDescriptorFactory.IsReflected( source ) )
+        return null;
+
+      var componentType = source.ComponentType;
+
+      EventInfo eventInfo;
+      try
+      {
+        eventInfo = componentType.GetEvent( source.Name, BindingFlags.Public | BindingFlags.Instance );
+        if( eventInfo == null )
+          return null;
+      }
+      catch( AmbiguousMatchException )
+      {
+        return null;
+      }
+
+      var handlerType = eventInfo.EventHandlerType;
+      Debug.Assert( handlerType == source.EventType );
+
+      var creatorHelper = DelegateCreatorHelperFactory.CreateHelper( componentType, handlerType );
+
+      var addHandler = DataItemEventDescriptorFactory.CreateAddHandler( eventInfo, creatorHelper );
+      if( addHandler == null )
+        return null;
+
+      var removeHandler = DataItemEventDescriptorFactory.CreateRemoveHandler( eventInfo, creatorHelper );
+      if( removeHandler == null )
+        return null;
+
+      return new DataItemEventDescriptor( m_typeDescriptor, source, componentType, handlerType, addHandler, removeHandler );
+    }
+
+    private static bool IsReflected( EventDescriptor descriptor )
+    {
+      return ( descriptor != null )
+          && ( descriptor.GetType() == s_reflectEventDescriptorType );
+    }
+
+    private static Action<object, object> CreateAddHandler( EventInfo eventInfo, IDelegateCreatorHelper helper )
+    {
+      var methodInfo = eventInfo.GetAddMethod();
+      if( methodInfo == null )
+        return null;
+
+      Debug.Assert( methodInfo.IsPublic );
+
+
+      return helper.CreateAddOrRemoveHandler( methodInfo );
+    }
+
+    private static Action<object, object> CreateRemoveHandler( EventInfo eventInfo, IDelegateCreatorHelper helper )
+    {
+      var methodInfo = eventInfo.GetRemoveMethod();
+      if( methodInfo == null )
+        return null;
+
+      Debug.Assert( methodInfo.IsPublic );
+
+
+      return helper.CreateAddOrRemoveHandler( methodInfo );
+    }
+
+    #region Private Fields
+
+    private readonly DataItemTypeDescriptor m_typeDescriptor;
+
+    #endregion
+
+    #region IDelegateCreatorHelper Private Interface
+
+    private interface IDelegateCreatorHelper
+    {
+      Action<object, object> CreateAddOrRemoveHandler( MethodInfo methodInfo );
+    }
+
+    #endregion
+
+    #region DelegateCreatorHelperFactory Private Class
+
+    private static class DelegateCreatorHelperFactory
+    {
+      internal static IDelegateCreatorHelper CreateHelper( Type componentType, Type handleType )
+      {
+        return ( IDelegateCreatorHelper )typeof( DelegateCreatorHelper<,> ).MakeGenericType( componentType, handleType ).GetConstructor( Type.EmptyTypes ).Invoke( null );
+      }
+    }
+
+    #endregion
+
+    #region DelegateCreatorHelper<> Private Class
+
+    private sealed class DelegateCreatorHelper<TSource, THandler> : IDelegateCreatorHelper
+    {
+      public Action<object, object> CreateAddOrRemoveHandler( MethodInfo methodInfo )
+      {
+        Debug.Assert( methodInfo != null );
+        Debug.Assert( methodInfo.IsPublic );
+        Debug.Assert( methodInfo.GetParameters().Length == 1 );
+        Debug.Assert( methodInfo.GetParameters()[ 0 ].ParameterType == typeof( THandler ) );
+
+        if( !typeof( TSource ).IsValueType )
+        {
+          var d = ( Action<TSource, THandler> )Delegate.CreateDelegate( typeof( Action<TSource, THandler> ), methodInfo, false );
+          if( d != null )
+            return ( source, handler ) => d.Invoke( ( TSource )source, ( THandler )handler );
+        }
+
+        return ( source, handler ) => methodInfo.Invoke( source, new object[] { handler } );
+      }
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptor.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptor.cs
new file mode 100644
index 00000000..3630874e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptor.cs
@@ -0,0 +1,105 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class DataItemPropertyDescriptor : DataItemPropertyDescriptorBase
+  {
+    #region Constructor
+
+    internal DataItemPropertyDescriptor(
+      DataItemTypeDescriptor owner,
+      PropertyDescriptor parent,
+      Type componentType,
+      Type propertyType,
+      Func<object, object> getter,
+      Action<object, object> setter,
+      Action<object> resetter )
+      : base( owner, parent, getter, setter, resetter )
+    {
+      if( componentType == null )
+        throw new ArgumentNullException( "componentType" );
+
+      if( propertyType == null )
+        throw new ArgumentNullException( "propertyType" );
+
+      m_componentType = componentType;
+      m_propertyType = propertyType;
+    }
+
+    #endregion
+
+    #region ComponentType Property
+
+    public sealed override Type ComponentType
+    {
+      get
+      {
+        return m_componentType;
+      }
+    }
+
+    private readonly Type m_componentType;
+
+    #endregion
+
+    #region PropertyType Property
+
+    public sealed override Type PropertyType
+    {
+      get
+      {
+        return m_propertyType;
+      }
+    }
+
+    private readonly Type m_propertyType;
+
+    #endregion
+
+    public override int GetHashCode()
+    {
+      return base.GetHashCode();
+    }
+
+    public override bool Equals( object obj )
+    {
+      return ( obj is DataItemPropertyDescriptor )
+          && ( base.Equals( obj ) );
+    }
+
+    protected override bool MustInhibitValueChanged( object component )
+    {
+      return false;
+    }
+
+    protected override bool IsValueChangedInhibited( object component )
+    {
+      return false;
+    }
+
+    protected override void InhibitValueChanged( object component )
+    {
+    }
+
+    protected override void ResetInhibitValueChanged( object component )
+    {
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorBase.cs
new file mode 100644
index 00000000..6f2b2892
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorBase.cs
@@ -0,0 +1,344 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class DataItemPropertyDescriptorBase : PropertyDescriptor
+  {
+    #region Static Fields
+
+    private static readonly object NotInitialized = new object();
+    private static readonly object NotSet = new object();
+
+    #endregion
+
+    #region Constructor
+
+    protected DataItemPropertyDescriptorBase(
+      DataItemTypeDescriptor owner,
+      PropertyDescriptor parent,
+      Func<object, object> getter,
+      Action<object, object> setter,
+      Action<object> resetter )
+      : base( parent )
+    {
+      if( owner == null )
+        throw new ArgumentNullException( "owner" );
+
+      if( getter == null )
+        throw new ArgumentNullException( "getter" );
+
+      m_owner = owner;
+      m_getter = getter;
+      m_setter = setter;
+      m_resetter = resetter;
+    }
+
+    #endregion
+
+    #region IsReadOnly Property
+
+    public sealed override bool IsReadOnly
+    {
+      get
+      {
+        if( m_setter == null )
+          return true;
+
+        var attribute = ( ReadOnlyAttribute )this.Attributes[ typeof( ReadOnlyAttribute ) ];
+
+        return ( attribute != null )
+            && ( attribute.IsReadOnly );
+      }
+    }
+
+    #endregion
+
+    #region Owner Protected Property
+
+    protected DataItemTypeDescriptor Owner
+    {
+      get
+      {
+        return m_owner;
+      }
+    }
+
+    private readonly DataItemTypeDescriptor m_owner;
+
+    #endregion
+
+    #region IsValueChangeEventEnabled Private Property
+
+    private bool IsValueChangeEventEnabled
+    {
+      get
+      {
+        return ( this.SupportsChangeEvents )
+            || ( !this.IsReadOnly );
+      }
+    }
+
+    #endregion
+
+    #region DefaultValue Private Property
+
+    private object DefaultValue
+    {
+      get
+      {
+        if( m_defaultValue == DataItemPropertyDescriptorBase.NotInitialized )
+        {
+          var attribute = ( DefaultValueAttribute )this.Attributes[ typeof( DefaultValueAttribute ) ];
+          if( attribute != null )
+          {
+            var propertyType = this.PropertyType;
+            var value = attribute.Value;
+
+            if( ( value != null ) && ( propertyType.IsEnum ) && ( Enum.GetUnderlyingType( propertyType ) == value.GetType() ) )
+            {
+              value = Enum.ToObject( propertyType, value );
+            }
+
+            m_defaultValue = value;
+          }
+          else
+          {
+            m_defaultValue = DataItemPropertyDescriptorBase.NotSet;
+          }
+        }
+
+        return m_defaultValue;
+      }
+    }
+
+    private object m_defaultValue = DataItemPropertyDescriptorBase.NotInitialized;
+
+    #endregion
+
+    #region AmbientValue Private Property
+
+    private object AmbientValue
+    {
+      get
+      {
+        if( m_ambientValue == DataItemPropertyDescriptorBase.NotInitialized )
+        {
+          var attribute = ( AmbientValueAttribute )this.Attributes[ typeof( AmbientValueAttribute ) ];
+          if( attribute != null )
+          {
+            m_ambientValue = attribute.Value;
+          }
+          else
+          {
+            m_ambientValue = DataItemPropertyDescriptorBase.NotSet;
+          }
+        }
+
+        return m_ambientValue;
+      }
+    }
+
+    private object m_ambientValue = DataItemPropertyDescriptorBase.NotInitialized;
+
+    #endregion
+
+    public override bool ShouldSerializeValue( object component )
+    {
+      if( this.IsReadOnly )
+        return this.Attributes.Contains( DesignerSerializationVisibilityAttribute.Content );
+
+      if( this.DefaultValue != DataItemPropertyDescriptorBase.NotSet )
+        return !object.Equals( this.GetValue( component ), this.DefaultValue );
+
+      return true;
+    }
+
+    public sealed override object GetValue( object component )
+    {
+      if( component == null )
+        return null;
+
+      return m_getter.Invoke( component );
+    }
+
+    public sealed override void SetValue( object component, object value )
+    {
+      if( ( component == null ) || this.IsReadOnly )
+        return;
+
+      Debug.Assert( m_setter != null );
+
+      bool inhibit;
+
+      lock( m_syncRoot )
+      {
+        inhibit = this.MustInhibitValueChanged( component );
+
+        if( inhibit )
+        {
+          this.InhibitValueChanged( component );
+        }
+      }
+
+      try
+      {
+        m_setter.Invoke( component, value );
+      }
+      finally
+      {
+        if( inhibit )
+        {
+          lock( m_syncRoot )
+          {
+            this.ResetInhibitValueChanged( component );
+          }
+        }
+      }
+
+      this.OnValueChanged( component, EventArgs.Empty );
+    }
+
+    public sealed override bool CanResetValue( object component )
+    {
+      if( this.IsReadOnly )
+        return false;
+
+      if( this.DefaultValue != DataItemPropertyDescriptorBase.NotSet )
+        return !object.Equals( this.GetValue( component ), this.DefaultValue );
+
+      if( m_resetter != null )
+        return true;
+
+      return ( this.AmbientValue != DataItemPropertyDescriptorBase.NotSet )
+          && ( this.ShouldSerializeValue( component ) );
+    }
+
+    public sealed override void ResetValue( object component )
+    {
+      if( ( component == null ) || this.IsReadOnly )
+        return;
+
+      if( this.DefaultValue != DataItemPropertyDescriptorBase.NotSet )
+      {
+        this.SetValue( component, this.DefaultValue );
+      }
+      else if( this.AmbientValue != DataItemPropertyDescriptorBase.NotSet )
+      {
+        this.SetValue( component, this.AmbientValue );
+      }
+      else if( m_resetter != null )
+      {
+        Debug.Assert( this.CanResetValue( component ) );
+        m_resetter.Invoke( component );
+      }
+    }
+
+    public sealed override void AddValueChanged( object component, EventHandler handler )
+    {
+      // There is no need to set the handler if the ValueChanged event will never be triggered.
+      if( !this.IsValueChangeEventEnabled )
+        return;
+
+      lock( m_syncRoot )
+      {
+        // We register only once on the target component.
+        if( this.SupportsChangeEvents && ( this.GetValueChangedHandler( component ) == null ) )
+        {
+          this.AddValueChangedCore( component );
+        }
+
+        base.AddValueChanged( component, handler );
+      }
+    }
+
+    public sealed override void RemoveValueChanged( object component, EventHandler handler )
+    {
+      // There is no need to remove the handler if it was never set in the first place.
+      if( !this.IsValueChangeEventEnabled )
+        return;
+
+      lock( m_syncRoot )
+      {
+        base.RemoveValueChanged( component, handler );
+
+        // We unregister only when there is no handler left for the target component.
+        if( this.SupportsChangeEvents && ( this.GetValueChangedHandler( component ) == null ) )
+        {
+          this.RemoveValueChangedCore( component );
+        }
+      }
+    }
+
+    public override int GetHashCode()
+    {
+      return base.GetHashCode();
+    }
+
+    public override bool Equals( object obj )
+    {
+      var descriptor = obj as DataItemPropertyDescriptorBase;
+      if( object.ReferenceEquals( descriptor, null ) )
+        return false;
+
+      return ( base.Equals( descriptor ) )
+          && ( descriptor.ComponentType == this.ComponentType )
+          && ( descriptor.IsReadOnly == this.IsReadOnly )
+          && ( descriptor.SupportsChangeEvents == this.SupportsChangeEvents );
+    }
+
+    protected sealed override void OnValueChanged( object component, EventArgs e )
+    {
+      if( component == null )
+        return;
+
+      lock( m_syncRoot )
+      {
+        if( this.IsValueChangedInhibited( component ) )
+          return;
+      }
+
+      base.OnValueChanged( component, e );
+    }
+
+    protected abstract bool MustInhibitValueChanged( object component );
+    protected abstract bool IsValueChangedInhibited( object component );
+    protected abstract void InhibitValueChanged( object component );
+    protected abstract void ResetInhibitValueChanged( object component );
+
+    protected virtual void AddValueChangedCore( object component )
+    {
+    }
+
+    protected virtual void RemoveValueChangedCore( object component )
+    {
+    }
+
+    #region Private Fields
+
+    private readonly object m_syncRoot = new object();
+    private readonly Func<object, object> m_getter;
+    private readonly Action<object, object> m_setter;
+    private readonly Action<object> m_resetter;
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorFactory.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorFactory.cs
new file mode 100644
index 00000000..44d13ec0
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemPropertyDescriptorFactory.cs
@@ -0,0 +1,297 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DataItemPropertyDescriptorFactory
+  {
+    #region Static Fields
+
+    private static readonly Type s_reflectPropertyDescriptorType;
+
+    #endregion
+
+    #region Constructor
+
+    static DataItemPropertyDescriptorFactory()
+    {
+      s_reflectPropertyDescriptorType = Assembly.GetAssembly( typeof( PropertyDescriptor ) ).GetType( "System.ComponentModel.ReflectPropertyDescriptor" );
+    }
+
+    internal DataItemPropertyDescriptorFactory( DataItemTypeDescriptor typeDescriptor )
+    {
+      if( typeDescriptor == null )
+        throw new ArgumentNullException( "typeDescriptor" );
+
+      m_typeDescriptor = typeDescriptor;
+    }
+
+    #endregion
+
+    internal DataItemPropertyDescriptorBase CreatePropertyDescriptor( PropertyDescriptor source )
+    {
+      if( !DataItemPropertyDescriptorFactory.IsReflected( source ) )
+        return null;
+
+      var componentType = source.ComponentType;
+
+      PropertyInfo propertyInfo;
+      try
+      {
+        propertyInfo = componentType.GetProperty( source.Name, BindingFlags.Public | BindingFlags.Instance );
+        if( ( propertyInfo == null ) || DataItemPropertyDescriptorFactory.IsIndexed( propertyInfo ) )
+          return null;
+      }
+      catch( AmbiguousMatchException )
+      {
+        return null;
+      }
+
+      var propertyType = propertyInfo.PropertyType;
+      Debug.Assert( propertyType == source.PropertyType );
+
+      var creatorHelper = DelegateCreatorHelperFactory.CreateHelper( componentType, propertyType );
+
+      var getter = DataItemPropertyDescriptorFactory.CreateGetter( propertyInfo, creatorHelper );
+      if( getter == null )
+        return null;
+
+      var setter = DataItemPropertyDescriptorFactory.CreateSetter( propertyInfo, creatorHelper );
+      var resetter = DataItemPropertyDescriptorFactory.CreateResetter( componentType, propertyInfo, creatorHelper );
+
+      var propertyChangedEvent = this.GetPropertyChangedEvent( propertyInfo.Name );
+      if( propertyChangedEvent != null )
+        return new ValueChangeDataItemPropertyDescriptor( m_typeDescriptor, source, componentType, propertyType, getter, setter, resetter, propertyChangedEvent );
+
+      return new DataItemPropertyDescriptor( m_typeDescriptor, source, componentType, propertyType, getter, setter, resetter );
+    }
+
+    private void InitializeEvents()
+    {
+      if( m_eventDescriptors != null )
+        return;
+
+      m_eventDescriptors = m_typeDescriptor.GetEvents();
+      m_notifyPropertyChangedEventDescriptor = ( from ed in m_eventDescriptors.Cast<EventDescriptor>()
+                                                 where ( ed != null )
+                                                    && ( ed.Name == "PropertyChanged" )
+                                                    && ( typeof( INotifyPropertyChanged ).IsAssignableFrom( ed.ComponentType ) )
+                                                    && ( typeof( PropertyChangedEventHandler ).IsAssignableFrom( ed.EventType ) )
+                                                 select ed ).FirstOrDefault();
+    }
+
+    private EventDescriptor GetNotifyPropertyChangedEvent()
+    {
+      this.InitializeEvents();
+
+      return m_notifyPropertyChangedEventDescriptor;
+    }
+
+    private EventDescriptor GetSinglePropertyChangedEvent( string propertyName )
+    {
+      this.InitializeEvents();
+
+      var eventName = string.Format( CultureInfo.InvariantCulture, "{0}Changed", propertyName );
+
+      return ( from ed in m_eventDescriptors.Cast<EventDescriptor>()
+               where ( ed != null )
+                  && ( ed.Name == eventName )
+                  && ( typeof( EventHandler ).IsAssignableFrom( ed.EventType ) )
+               select ed ).FirstOrDefault();
+    }
+
+    private EventDescriptor GetPropertyChangedEvent( string propertyName )
+    {
+      var descriptor = this.GetSinglePropertyChangedEvent( propertyName );
+      if( descriptor != null )
+        return descriptor;
+
+      return this.GetNotifyPropertyChangedEvent();
+    }
+
+    private static bool IsReflected( PropertyDescriptor descriptor )
+    {
+      return ( descriptor != null )
+          && ( descriptor.GetType() == s_reflectPropertyDescriptorType );
+    }
+
+    private static bool IsIndexed( PropertyInfo propertyInfo )
+    {
+      var parameters = propertyInfo.GetIndexParameters();
+
+      return ( parameters != null )
+          && ( parameters.Length > 0 );
+    }
+
+    private static Func<object, object> CreateGetter( PropertyInfo propertyInfo, IDelegateCreatorHelper helper )
+    {
+      if( !propertyInfo.CanRead )
+        return null;
+
+      var methodInfo = propertyInfo.GetGetMethod();
+      if( methodInfo == null )
+        return null;
+
+      Debug.Assert( methodInfo.IsPublic );
+
+
+      return helper.CreateGetter( methodInfo );
+    }
+
+    private static Action<object, object> CreateSetter( PropertyInfo propertyInfo, IDelegateCreatorHelper helper )
+    {
+      if( !propertyInfo.CanWrite )
+        return null;
+
+      var methodInfo = propertyInfo.GetSetMethod();
+      if( methodInfo == null )
+        return null;
+
+      Debug.Assert( methodInfo.IsPublic );
+
+
+      return helper.CreateSetter( methodInfo );
+    }
+
+    private static Action<object> CreateResetter( Type componentType, PropertyInfo propertyInfo, IDelegateCreatorHelper helper )
+    {
+      MethodInfo methodInfo;
+      try
+      {
+        methodInfo = componentType.GetMethod( string.Format( CultureInfo.InvariantCulture, "Reset{0}", propertyInfo.Name ), BindingFlags.Public | BindingFlags.Instance, null, Type.EmptyTypes, null );
+        if( ( methodInfo == null ) || methodInfo.IsGenericMethod )
+          return null;
+      }
+      catch( AmbiguousMatchException )
+      {
+        return null;
+      }
+
+      Debug.Assert( methodInfo.IsPublic );
+
+
+      return helper.CreateResetter( methodInfo );
+    }
+
+    #region Private Fields
+
+    private readonly DataItemTypeDescriptor m_typeDescriptor;
+    private EventDescriptorCollection m_eventDescriptors; //null
+    private EventDescriptor m_notifyPropertyChangedEventDescriptor; //null
+
+    #endregion
+
+    #region IDelegateCreatorHelper Private Interface
+
+    private interface IDelegateCreatorHelper
+    {
+      Func<object, object> CreateGetter( MethodInfo methodInfo );
+      Action<object, object> CreateSetter( MethodInfo methodInfo );
+      Action<object> CreateResetter( MethodInfo methodInfo );
+    }
+
+    #endregion
+
+    #region DelegateCreatorHelperFactory Private Class
+
+    private static class DelegateCreatorHelperFactory
+    {
+      internal static IDelegateCreatorHelper CreateHelper( Type componentType, Type propertyType )
+      {
+        return ( IDelegateCreatorHelper )typeof( DelegateCreatorHelper<,> ).MakeGenericType( componentType, propertyType ).GetConstructor( Type.EmptyTypes ).Invoke( null );
+      }
+    }
+
+    #endregion
+
+    #region DelegateCreatorHelper<> Private Class
+
+    private sealed class DelegateCreatorHelper<TSource, TProperty> : IDelegateCreatorHelper
+    {
+      public Func<object, object> CreateGetter( MethodInfo methodInfo )
+      {
+        Debug.Assert( methodInfo != null );
+        Debug.Assert( methodInfo.IsPublic );
+        Debug.Assert( methodInfo.GetParameters().Length == 0 );
+        Debug.Assert( methodInfo.ReturnType == typeof( TProperty ) );
+
+        if( typeof( TSource ).IsValueType )
+        {
+          var d = ( ValueTypeGetter )Delegate.CreateDelegate( typeof( ValueTypeGetter ), methodInfo, false );
+          if( d != null )
+            return ( source ) =>
+              {
+                var s = ( TSource )source;
+
+                return d.Invoke( ref s );
+              };
+        }
+        else
+        {
+          var d = ( Func<TSource, TProperty> )Delegate.CreateDelegate( typeof( Func<TSource, TProperty> ), methodInfo, false );
+          if( d != null )
+            return ( source ) => d.Invoke( ( TSource )source );
+        }
+
+        return ( source ) => methodInfo.Invoke( source, null );
+      }
+
+      public Action<object, object> CreateSetter( MethodInfo methodInfo )
+      {
+        Debug.Assert( methodInfo != null );
+        Debug.Assert( methodInfo.IsPublic );
+        Debug.Assert( methodInfo.GetParameters().Length == 1 );
+        Debug.Assert( methodInfo.GetParameters()[ 0 ].ParameterType == typeof( TProperty ) );
+
+        if( !typeof( TSource ).IsValueType )
+        {
+          var d = ( Action<TSource, TProperty> )Delegate.CreateDelegate( typeof( Action<TSource, TProperty> ), methodInfo );
+          if( d != null )
+            return ( source, value ) => d.Invoke( ( TSource )source, ( TProperty )value );
+        }
+
+        return ( source, value ) => methodInfo.Invoke( source, new object[] { value } );
+      }
+
+      public Action<object> CreateResetter( MethodInfo methodInfo )
+      {
+        Debug.Assert( methodInfo != null );
+        Debug.Assert( methodInfo.IsPublic );
+        Debug.Assert( methodInfo.GetParameters().Length == 0 );
+
+        if( !typeof( TSource ).IsValueType )
+        {
+          var d = ( Action<TSource> )Delegate.CreateDelegate( typeof( Action<TSource> ), methodInfo );
+          if( d != null )
+            return ( source ) => d.Invoke( ( TSource )source );
+        }
+
+        return ( source ) => methodInfo.Invoke( source, null );
+      }
+
+      private delegate TProperty ValueTypeGetter( ref TSource source );
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptionProvider.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptionProvider.cs
new file mode 100644
index 00000000..745a6f92
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptionProvider.cs
@@ -0,0 +1,48 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DataItemTypeDescriptionProvider : TypeDescriptionProvider
+  {
+    #region Constructor
+
+    internal DataItemTypeDescriptionProvider( TypeDescriptionProvider parent )
+      : base( parent )
+    {
+    }
+
+    #endregion
+
+    public override ICustomTypeDescriptor GetTypeDescriptor( Type objectType, object instance )
+    {
+      var descriptor = base.GetTypeDescriptor( objectType, instance );
+
+      return DataItemTypeDescriptionProvider.GetTypeDescriptor( objectType, descriptor );
+    }
+
+    internal static ICustomTypeDescriptor GetTypeDescriptor( Type objectType, ICustomTypeDescriptor descriptor )
+    {
+      if( descriptor == null )
+        return null;
+
+      return new DataItemTypeDescriptor( descriptor, objectType );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptor.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptor.cs
new file mode 100644
index 00000000..1368e829
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataItemTypeDescriptor.cs
@@ -0,0 +1,254 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class DataItemTypeDescriptor : CustomTypeDescriptor
+  {
+    #region Static Fields
+
+    private static readonly List<WeakReference> s_entries = new List<WeakReference>();
+
+    #endregion
+
+    #region Constructors
+
+    internal DataItemTypeDescriptor( ICustomTypeDescriptor parent, Type objectType )
+      : base( parent )
+    {
+      if( parent == null )
+        throw new ArgumentNullException( "parent" );
+
+      m_targetType = objectType;
+      m_descriptorType = parent.GetType();
+    }
+
+    #endregion
+
+    public override EventDescriptorCollection GetEvents()
+    {
+      return this.GetEvents( null );
+    }
+
+    public override EventDescriptorCollection GetEvents( Attribute[] attributes )
+    {
+      var sourceEvents = base.GetEvents( attributes );
+      if( ( sourceEvents == null ) || ( sourceEvents.Count == 0 ) )
+        return sourceEvents;
+
+      var entry = this.GetEntry();
+      var replaceEvents = default( Dictionary<EventDescriptor, DataItemEventDescriptorBase> );
+
+      lock( entry )
+      {
+        replaceEvents = entry.Events;
+
+        if( replaceEvents == null )
+        {
+          replaceEvents = new Dictionary<EventDescriptor, DataItemEventDescriptorBase>();
+          entry.Events = replaceEvents;
+
+          var factory = new DataItemEventDescriptorFactory( this );
+
+          foreach( var sourceEvent in sourceEvents.Cast<EventDescriptor>() )
+          {
+            var descriptor = factory.CreateEventDescriptor( sourceEvent );
+            if( descriptor != null )
+            {
+              replaceEvents.Add( sourceEvent, descriptor );
+            }
+          }
+        }
+
+        if( replaceEvents.Count == 0 )
+          return sourceEvents;
+      }
+
+      var destinationEvents = new EventDescriptor[ sourceEvents.Count ];
+
+      for( int i = 0; i < sourceEvents.Count; i++ )
+      {
+        var sourceEvent = sourceEvents[ i ];
+
+        DataItemEventDescriptorBase destinationEvent;
+        if( replaceEvents.TryGetValue( sourceEvent, out destinationEvent ) )
+        {
+          destinationEvents[ i ] = destinationEvent;
+        }
+        else
+        {
+          destinationEvents[ i ] = sourceEvent;
+        }
+      }
+
+      return new EventDescriptorCollection( destinationEvents );
+    }
+
+    public override PropertyDescriptorCollection GetProperties()
+    {
+      return this.GetProperties( null );
+    }
+
+    public override PropertyDescriptorCollection GetProperties( Attribute[] attributes )
+    {
+      var sourceProperties = base.GetProperties( attributes );
+      if( ( sourceProperties == null ) || ( sourceProperties.Count == 0 ) )
+        return sourceProperties;
+
+      var entry = this.GetEntry();
+      var replaceProperties = default( Dictionary<PropertyDescriptor, DataItemPropertyDescriptorBase> );
+
+      lock( entry )
+      {
+        replaceProperties = entry.Properties;
+
+        if( replaceProperties == null )
+        {
+          replaceProperties = new Dictionary<PropertyDescriptor, DataItemPropertyDescriptorBase>();
+          entry.Properties = replaceProperties;
+
+          var factory = new DataItemPropertyDescriptorFactory( this );
+
+          foreach( var sourceProperty in sourceProperties.Cast<PropertyDescriptor>() )
+          {
+            var descriptor = factory.CreatePropertyDescriptor( sourceProperty );
+            if( descriptor != null )
+            {
+              replaceProperties.Add( sourceProperty, descriptor );
+            }
+          }
+        }
+
+        if( replaceProperties.Count == 0 )
+          return sourceProperties;
+      }
+
+      var destinationProperties = new PropertyDescriptor[ sourceProperties.Count ];
+
+      for( int i = 0; i < sourceProperties.Count; i++ )
+      {
+        var sourceProperty = sourceProperties[ i ];
+
+        DataItemPropertyDescriptorBase destinationProperty;
+        if( replaceProperties.TryGetValue( sourceProperty, out destinationProperty ) )
+        {
+          destinationProperties[ i ] = destinationProperty;
+        }
+        else
+        {
+          destinationProperties[ i ] = sourceProperty;
+        }
+      }
+
+      return new PropertyDescriptorCollection( destinationProperties );
+    }
+
+    private Entry GetEntry()
+    {
+      if( m_entry == null )
+      {
+        m_entry = DataItemTypeDescriptor.GetEntry( m_targetType, m_descriptorType );
+      }
+
+      return m_entry;
+    }
+
+    private static Entry GetEntry( Type targetType, Type descriptorType )
+    {
+      Debug.Assert( targetType != null );
+      Debug.Assert( descriptorType != null );
+
+      lock( ( ( ICollection )s_entries ).SyncRoot )
+      {
+        for( int i = s_entries.Count - 1; i >= 0; i-- )
+        {
+          var entry = ( Entry )s_entries[ i ].Target;
+
+          if( entry != null )
+          {
+            if( object.Equals( targetType, entry.TargetType ) && object.Equals( descriptorType, entry.DescriptorType ) )
+              return entry;
+          }
+          else
+          {
+            s_entries.RemoveAt( i );
+          }
+        }
+
+        var result = new Entry( targetType, descriptorType );
+
+        s_entries.Add( new WeakReference( result ) );
+
+        return result;
+      }
+    }
+
+    #region Private Fields
+
+    private readonly Type m_targetType;
+    private readonly Type m_descriptorType;
+    private Entry m_entry; //null
+
+    #endregion
+
+    #region Entry Private Class
+
+    private sealed class Entry
+    {
+      internal Entry( Type targetType, Type descriptorType )
+      {
+        Debug.Assert( targetType != null );
+        Debug.Assert( descriptorType != null );
+
+        this.TargetType = targetType;
+        this.DescriptorType = descriptorType;
+      }
+
+      internal Type TargetType
+      {
+        get;
+        private set;
+      }
+
+      internal Type DescriptorType
+      {
+        get;
+        private set;
+      }
+
+      internal Dictionary<EventDescriptor, DataItemEventDescriptorBase> Events
+      {
+        get;
+        set;
+      }
+
+      internal Dictionary<PropertyDescriptor, DataItemPropertyDescriptorBase> Properties
+      {
+        get;
+        set;
+      }
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataRow.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataRow.cs
index cfc88f5d..7446db0f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataRow.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DataRow.cs
@@ -15,17 +15,15 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Windows;
 using System.Windows.Data;
-using Xceed.Wpf.DataGrid.Views;
 using System.Windows.Input;
-using System.Windows.Controls;
-using System.Collections.Specialized;
-using System.Windows.Threading;
 using System.Windows.Media.Animation;
-using System.Collections.Generic;
+using System.Windows.Threading;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -152,6 +150,36 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion TitleBarContent Private Property
 
+    protected override void OnMouseEnter( MouseEventArgs e )
+    {
+      base.OnMouseEnter( e );
+
+      //If the current CellEditorDisplayConditions requires display when mouse is over the Row 
+      if( Row.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverRow ) )
+      {
+        //Display the editors for the Row
+        this.SetDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverRow );
+      }
+
+      // In case a value was explicitly specified on the Cell's ParentColumn
+      this.RefreshCellsDisplayedTemplate();
+    }
+
+    protected override void OnMouseLeave( MouseEventArgs e )
+    {
+      base.OnMouseLeave( e );
+
+      //If the current CellEditorDisplayConditions requires display when mouse is over the Row 
+      if( Row.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverRow ) )
+      {
+        //Display the editors for the Row
+        this.RemoveDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverRow );
+      }
+
+      // In case a value was explicitly specified on the Cell's ParentColumn
+      this.RefreshCellsDisplayedTemplate();
+    }
+
     protected override void SetDataContext( object item )
     {
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
@@ -174,10 +202,10 @@ namespace Xceed.Wpf.DataGrid
 
         Debug.Assert( m_affectDataContextOperation == null );
 
-        // Dispatch a call to SetRealDataItem that will update
-        // the DataContext of the Row and every CreatedCells
-        // to the DataItem the Row must display. We use a Background priority
-        // to limit the impact on scrolling.
+        // Dispatch a call to SetDataContextDispatched that will update
+        // the DataContext of the Row and every CreatedCells to the
+        // DataItem the Row must display. We use a low priority to limit
+        // the impact on scrolling.
         m_affectDataContextOperation = this.Dispatcher.BeginInvoke(
           new Action<object>( this.SetDataContextDispatched ), DispatcherPriority.Background, item );
       }
@@ -327,7 +355,7 @@ namespace Xceed.Wpf.DataGrid
       base.PreEditCanceled();
     }
 
-    protected internal override void PrepareContainer( DataGridContext dataGridContext, object item )
+    protected override void PrepareContainer( DataGridContext dataGridContext, object item )
     {
       base.PrepareContainer( dataGridContext, item );
 
@@ -339,7 +367,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    protected internal override void ClearContainer()
+    protected override void ClearContainer()
     {
       if( m_affectDataContextOperation != null )
       {
@@ -368,7 +396,7 @@ namespace Xceed.Wpf.DataGrid
     protected override Cell CreateCell( ColumnBase column )
     {
       if( column == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "Column is null.", DataGridControl.GetDataGridContext( this ).DataGridControl );
 
       return new DataCell();
     }
@@ -503,22 +531,14 @@ namespace Xceed.Wpf.DataGrid
       {
         Xceed.Wpf.DataGrid.Views.ViewBase view = dataGridContext.DataGridControl.GetView();
 
-        if( ( view is TableView )
-          || ( view is TableflowView ) )
-        {
+        if( ( view is TableView ) || ( view is TableflowView ) )
           return;
-        }
 
         Column headerColumn = dataGridContext.Columns.MainColumn as Column;
 
         if( headerColumn != null )
         {
-          // Disable warning for DisplayMemberBinding when internaly used
-#pragma warning disable 618
-
-          BindingBase displayMemberBinding = headerColumn.DisplayMemberBinding;
-
-#pragma warning restore 618
+          BindingBase displayMemberBinding = headerColumn.GetDisplayMemberBinding();
 
           if( displayMemberBinding == null )
           {
@@ -529,9 +549,7 @@ namespace Xceed.Wpf.DataGrid
             ItemsSourceHelper.FieldDescriptor fieldDescriptor;
             dataGridContext.ItemsSourceFieldDescriptors.TryGetValue( name, out fieldDescriptor );
 
-            displayMemberBinding = ItemsSourceHelper.CreateDefaultBinding(
-              this.DataContext is DataRow, name, fieldDescriptor,
-              false, true, typeof( object ) );
+            displayMemberBinding = ItemsSourceHelper.CreateDefaultBinding( this.DataContext is DataRow, name, fieldDescriptor, headerColumn, true, typeof( object ) );
 
           }
 
@@ -607,7 +625,7 @@ namespace Xceed.Wpf.DataGrid
         this.ApplyAnimationClock( Row.CellContentOpacityProperty, null );
         this.SetValue( Row.CellContentOpacityProperty, 0d );
       }
-      else 
+      else
       {
         m_fadeInAnimation.From = 0d;
         m_fadeInAnimation.To = 1d;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml
index 0930223e..60d6a1fd 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml
@@ -22,11 +22,11 @@
                   xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                   xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                   xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                  xmlns:s="clr-namespace:System;assembly=mscorlib"
-                  xmlns:sxml="clr-namespace:System.Xml;assembly=System.Xml">
-
+                  xmlns:s="clr-namespace:System;assembly=mscorlib">
    <FrameworkElement.Resources>
 
+      <conv:NullToBooleanConverter x:Key="nullToBooleanConverter" />
+
       <ControlTemplate x:Key="scrollViewerTemplate"
                        TargetType="{x:Type ScrollViewer}">
          <ScrollContentPresenter CanContentScroll="{TemplateBinding CanContentScroll}" />
@@ -203,10 +203,10 @@
          <local:CellEditor.EditTemplate>
             <DataTemplate DataType="{x:Type s:Boolean}">
                <local:DataGridCheckBox IsChecked="{markup:CellEditorBinding}"
-                                       local:DataCell.IsCellFocusScope="True"
-                                       VerticalAlignment="Stretch"
-                                       Foreground="{Binding RelativeSource={RelativeSource TemplatedParent},  Path=(TextElement.Foreground)}"
-                                       AutomationProperties.AutomationId="CheckBoxEditor" />
+                               local:DataCell.IsCellFocusScope="True"
+                               VerticalAlignment="Stretch"
+                               Foreground="{Binding RelativeSource={RelativeSource TemplatedParent},  Path=(TextElement.Foreground)}"
+                               AutomationProperties.AutomationId="CheckBoxEditor" />
             </DataTemplate>
          </local:CellEditor.EditTemplate>
          <local:CellEditor.ActivationGestures>
@@ -227,13 +227,13 @@
          <local:CellEditor.EditTemplate>
             <DataTemplate DataType="{x:Type s:DateTime}">
                <local:ValidateInputWrapper>
-                    <local:DataGridDatePicker SelectedDate="{markup:CellEditorBinding}"
-                                        x:Name="PART_CellEditorBoundControl"
-                                        VerticalAlignment="Top"
-                                        Foreground="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=(TextElement.Foreground)}"
-                                        AutomationProperties.AutomationId="DatePickerEditor" />
-                </local:ValidateInputWrapper>
-                </DataTemplate>
+                  <local:DataGridDatePicker SelectedDate="{markup:CellEditorBinding}"
+                                            x:Name="PART_CellEditorBoundControl"
+                                            VerticalAlignment="Top"
+                                            Foreground="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=(TextElement.Foreground)}"
+                                            AutomationProperties.AutomationId="DatePickerEditor" />
+               </local:ValidateInputWrapper>
+            </DataTemplate>
          </local:CellEditor.EditTemplate>
          <local:CellEditor.ActivationGestures>
             <local:KeyActivationGesture SystemKey="Down"
@@ -244,8 +244,6 @@
          </local:CellEditor.ActivationGestures>
       </local:CellEditor>
 
-      <conv:NullToBooleanConverter x:Key="nullToBooleanConverter" />
-
       <!-- ForeignKey CellEditor -->
       <local:CellEditor x:Key="foreignKeyCellEditor">
          <local:CellEditor.EditTemplate>
@@ -257,18 +255,38 @@
                          ItemContainerStyle="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ForeignKeyConfiguration.ItemContainerStyle, Mode=OneWay}"
                          ItemsSource="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ForeignKeyConfiguration.ItemsSource, Mode=OneWay}"
                          SelectedValuePath="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ForeignKeyConfiguration.ValuePath, Mode=OneWay}"
-                         DisplayMemberPath="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ForeignKeyConfiguration.DisplayMemberPath, Mode=OneWay}"
                          SelectedValue="{markup:CellEditorBinding}"
                          AutomationProperties.AutomationId="ForeignKeyCellEditor" />
 
-               <!-- Only affect Selector if Template or Style is null -->
+               <!-- Only affect Selector if Template is null and DisplayMemberPath is null or empty -->
                <DataTemplate.Triggers>
-                  <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ParentColumn.CellContentTemplate, Converter={StaticResource nullToBooleanConverter}, Mode=OneWay}"
-                               Value="True">
-                     <Setter TargetName="fkComboBox"
-                             Property="ItemTemplateSelector"
-                             Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ParentColumn.CellContentTemplateSelector, Mode=OneWay}" />
-                  </DataTrigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ParentColumn.CellContentTemplate, Converter={StaticResource nullToBooleanConverter}, Mode=OneWay}"
+                                   Value="True" />
+                        <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ParentColumn.CellContentTemplateSelector, Converter={StaticResource nullToBooleanConverter}, Mode=OneWay}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <MultiDataTrigger.Setters>
+                        <Setter TargetName="fkComboBox"
+                                Property="ItemTemplateSelector"
+                                Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ParentColumn.CellContentTemplateSelector, Mode=OneWay}" />
+                     </MultiDataTrigger.Setters>
+                  </MultiDataTrigger>
+
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ParentColumn.CellContentTemplate, Converter={StaticResource nullToBooleanConverter}, Mode=OneWay}"
+                                   Value="True" />
+                        <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ParentColumn.CellContentTemplateSelector, Converter={StaticResource nullToBooleanConverter}, Mode=OneWay}"
+                                   Value="True" />
+                     </MultiDataTrigger.Conditions>
+                     <MultiDataTrigger.Setters>
+                        <Setter TargetName="fkComboBox"
+                                Property="DisplayMemberPath"
+                                Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ForeignKeyConfiguration.DisplayMemberPath, Mode=OneWay}" />
+                     </MultiDataTrigger.Setters>
+                  </MultiDataTrigger>
 
                   <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:Cell.CellEditorContext).ForeignKeyConfiguration.ItemContainerStyle, Converter={StaticResource nullToBooleanConverter}, Mode=OneWay}"
                                Value="True">
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml.cs
index 42f0f29e..d81c5150 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultCellEditorSelector.xaml.cs
@@ -24,26 +24,18 @@ namespace Xceed.Wpf.DataGrid
 {
   internal partial class DefaultCellEditorSelector : FrameworkElement
   {
-    #region Constructors
-
     static DefaultCellEditorSelector()
     {
       Instance = new DefaultCellEditorSelector();
-    } 
+    }
 
     private DefaultCellEditorSelector()
     {
       this.InitializeComponent();
     }
 
-    #endregion
-
-    #region Static Fields
-
     private static readonly DefaultCellEditorSelector Instance;
 
-    #endregion
-
     #region TextBoxEditor Public Static Property
 
     public static CellEditor TextBoxEditorCache;
@@ -57,7 +49,7 @@ namespace Xceed.Wpf.DataGrid
 
         return TextBoxEditorCache;
       }
-    } 
+    }
 
     #endregion
 
@@ -74,7 +66,7 @@ namespace Xceed.Wpf.DataGrid
 
         return CheckBoxEditorCache;
       }
-    } 
+    }
 
     #endregion
 
@@ -111,13 +103,13 @@ namespace Xceed.Wpf.DataGrid
 
         return ForeignKeyEditorCache;
       }
-    } 
+    }
 
     #endregion
 
     #region LinqCellEditor Public Static Editor
 
-    private static CellEditor LinqCellEditorCache; 
+    private static CellEditor LinqCellEditorCache;
 
     public static CellEditor LinqCellEditor
     {
@@ -135,8 +127,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region Public Methods
-
     public static CellEditor SelectCellEditor( Type dataType )
     {
       CellEditor cellEditor = null;
@@ -153,11 +143,7 @@ namespace Xceed.Wpf.DataGrid
       }
 
       return cellEditor;
-    } 
-
-    #endregion
-
-    #region Private Methods
+    }
 
     private static object ThreadSafeTryFindResource( string key )
     {
@@ -199,11 +185,9 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        DefaultCellEditorSelector.Instance.Dispatcher.Invoke( 
+        DefaultCellEditorSelector.Instance.Dispatcher.Invoke(
           new Action<CellEditor>( DefaultCellEditorSelector.ThreadSafeTryFreezeEditor ), cellEditor );
       }
-    } 
-
-    #endregion
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultDetailConfiguration.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultDetailConfiguration.cs
index f7a5f4c3..3b752375 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultDetailConfiguration.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DefaultDetailConfiguration.cs
@@ -26,8 +26,6 @@ namespace Xceed.Wpf.DataGrid
 {
   public class DefaultDetailConfiguration : DependencyObject
   {
-    #region Constructors
-
     static DefaultDetailConfiguration()
     {
       HeadersProperty = HeadersPropertyKey.DependencyProperty;
@@ -38,9 +36,7 @@ namespace Xceed.Wpf.DataGrid
     {
       this.SetHeaders( new ObservableCollection<DataTemplate>() );
       this.SetFooters( new ObservableCollection<DataTemplate>() );
-    } 
-
-    #endregion
+    }
 
     #region AllowDetailToggle Property
 
@@ -50,11 +46,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return (bool)this.GetValue(DefaultDetailConfiguration.AllowDetailToggleProperty);
+        return ( bool )this.GetValue( DefaultDetailConfiguration.AllowDetailToggleProperty );
       }
       set
       {
-        this.SetValue(DefaultDetailConfiguration.AllowDetailToggleProperty, value);
+        this.SetValue( DefaultDetailConfiguration.AllowDetailToggleProperty, value );
       }
     }
 
@@ -68,11 +64,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return (GroupConfiguration)this.GetValue(DefaultDetailConfiguration.DefaultGroupConfigurationProperty);
+        return ( GroupConfiguration )this.GetValue( DefaultDetailConfiguration.DefaultGroupConfigurationProperty );
       }
       set
       {
-        this.SetValue(DefaultDetailConfiguration.DefaultGroupConfigurationProperty, value);
+        this.SetValue( DefaultDetailConfiguration.DefaultGroupConfigurationProperty, value );
       }
     }
 
@@ -86,11 +82,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return (GroupConfigurationSelector)this.GetValue(DefaultDetailConfiguration.GroupConfigurationSelectorProperty);
+        return ( GroupConfigurationSelector )this.GetValue( DefaultDetailConfiguration.GroupConfigurationSelectorProperty );
       }
       set
       {
-        this.SetValue(DefaultDetailConfiguration.GroupConfigurationSelectorProperty, value);
+        this.SetValue( DefaultDetailConfiguration.GroupConfigurationSelectorProperty, value );
       }
     }
 
@@ -98,17 +94,17 @@ namespace Xceed.Wpf.DataGrid
 
     #region ItemContainerStyle Property
 
-    public static readonly DependencyProperty ItemContainerStyleProperty = DataGridControl.ItemContainerStyleProperty.AddOwner( typeof( DefaultDetailConfiguration ) ) ;
+    public static readonly DependencyProperty ItemContainerStyleProperty = DataGridControl.ItemContainerStyleProperty.AddOwner( typeof( DefaultDetailConfiguration ) );
 
     public Style ItemContainerStyle
     {
       get
       {
-        return (Style)this.GetValue(DefaultDetailConfiguration.ItemContainerStyleProperty);
+        return ( Style )this.GetValue( DefaultDetailConfiguration.ItemContainerStyleProperty );
       }
       set
       {
-        this.SetValue(DefaultDetailConfiguration.ItemContainerStyleProperty, value);
+        this.SetValue( DefaultDetailConfiguration.ItemContainerStyleProperty, value );
       }
     }
 
@@ -116,17 +112,17 @@ namespace Xceed.Wpf.DataGrid
 
     #region ItemContainerStyleSelector Property
 
-    public static readonly DependencyProperty ItemContainerStyleSelectorProperty = DataGridControl.ItemContainerStyleSelectorProperty.AddOwner( typeof(DefaultDetailConfiguration ) );
+    public static readonly DependencyProperty ItemContainerStyleSelectorProperty = DataGridControl.ItemContainerStyleSelectorProperty.AddOwner( typeof( DefaultDetailConfiguration ) );
 
     public StyleSelector ItemContainerStyleSelector
     {
       get
       {
-        return (StyleSelector)this.GetValue(DefaultDetailConfiguration.ItemContainerStyleSelectorProperty);
+        return ( StyleSelector )this.GetValue( DefaultDetailConfiguration.ItemContainerStyleSelectorProperty );
       }
       set
       {
-        this.SetValue(DefaultDetailConfiguration.ItemContainerStyleSelectorProperty, value);
+        this.SetValue( DefaultDetailConfiguration.ItemContainerStyleSelectorProperty, value );
       }
     }
 
@@ -140,11 +136,11 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return (Style)this.GetValue(DefaultDetailConfiguration.DetailIndicatorStyleProperty);
+        return ( Style )this.GetValue( DefaultDetailConfiguration.DetailIndicatorStyleProperty );
       }
       set
       {
-        this.SetValue(DefaultDetailConfiguration.DetailIndicatorStyleProperty, value);
+        this.SetValue( DefaultDetailConfiguration.DetailIndicatorStyleProperty, value );
       }
     }
 
@@ -153,7 +149,7 @@ namespace Xceed.Wpf.DataGrid
     #region Headers Property
 
     private static readonly DependencyPropertyKey HeadersPropertyKey =
-        DependencyProperty.RegisterReadOnly("Headers", typeof(ObservableCollection<DataTemplate>), typeof(DefaultDetailConfiguration), new FrameworkPropertyMetadata(null));
+        DependencyProperty.RegisterReadOnly( "Headers", typeof( ObservableCollection<DataTemplate> ), typeof( DefaultDetailConfiguration ), new FrameworkPropertyMetadata( null ) );
 
     public static readonly DependencyProperty HeadersProperty;
 
@@ -161,13 +157,13 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return (ObservableCollection<DataTemplate>)this.GetValue(DefaultDetailConfiguration.HeadersProperty);
+        return ( ObservableCollection<DataTemplate> )this.GetValue( DefaultDetailConfiguration.HeadersProperty );
       }
     }
 
-    private void SetHeaders(ObservableCollection<DataTemplate> headers)
+    private void SetHeaders( ObservableCollection<DataTemplate> headers )
     {
-      this.SetValue(DefaultDetailConfiguration.HeadersPropertyKey, headers);
+      this.SetValue( DefaultDetailConfiguration.HeadersPropertyKey, headers );
     }
 
     #endregion Headers Property
@@ -175,7 +171,7 @@ namespace Xceed.Wpf.DataGrid
     #region Footers Property
 
     private static readonly DependencyPropertyKey FootersPropertyKey =
-        DependencyProperty.RegisterReadOnly("Footers", typeof(ObservableCollection<DataTemplate>), typeof(DefaultDetailConfiguration), new FrameworkPropertyMetadata(null));
+        DependencyProperty.RegisterReadOnly( "Footers", typeof( ObservableCollection<DataTemplate> ), typeof( DefaultDetailConfiguration ), new FrameworkPropertyMetadata( null ) );
 
     public static readonly DependencyProperty FootersProperty;
 
@@ -183,13 +179,13 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return (ObservableCollection<DataTemplate>)this.GetValue(DefaultDetailConfiguration.FootersProperty);
+        return ( ObservableCollection<DataTemplate> )this.GetValue( DefaultDetailConfiguration.FootersProperty );
       }
     }
 
-    private void SetFooters(ObservableCollection<DataTemplate> footers)
+    private void SetFooters( ObservableCollection<DataTemplate> footers )
     {
-      this.SetValue(DefaultDetailConfiguration.FootersPropertyKey, footers);
+      this.SetValue( DefaultDetailConfiguration.FootersPropertyKey, footers );
     }
 
     #endregion Footers Property
@@ -232,17 +228,17 @@ namespace Xceed.Wpf.DataGrid
 
     #region UseDefaultHeadersFooters Property
 
-    public static readonly DependencyProperty UseDefaultHeadersFootersProperty = DetailConfiguration.UseDefaultHeadersFootersProperty.AddOwner(typeof(DefaultDetailConfiguration));
+    public static readonly DependencyProperty UseDefaultHeadersFootersProperty = DetailConfiguration.UseDefaultHeadersFootersProperty.AddOwner( typeof( DefaultDetailConfiguration ) );
 
     public bool UseDefaultHeadersFooters
     {
       get
       {
-        return (bool)this.GetValue(DefaultDetailConfiguration.UseDefaultHeadersFootersProperty);
+        return ( bool )this.GetValue( DefaultDetailConfiguration.UseDefaultHeadersFootersProperty );
       }
       set
       {
-        this.SetValue(DefaultDetailConfiguration.UseDefaultHeadersFootersProperty, value);
+        this.SetValue( DefaultDetailConfiguration.UseDefaultHeadersFootersProperty, value );
       }
     }
 
@@ -250,8 +246,8 @@ namespace Xceed.Wpf.DataGrid
 
     #region IsDeleteCommandEnabled Property
 
-    public static readonly DependencyProperty IsDeleteCommandEnabledProperty = DetailConfiguration.IsDeleteCommandEnabledProperty.AddOwner( 
-      typeof( DefaultDetailConfiguration ), 
+    public static readonly DependencyProperty IsDeleteCommandEnabledProperty = DetailConfiguration.IsDeleteCommandEnabledProperty.AddOwner(
+      typeof( DefaultDetailConfiguration ),
       new FrameworkPropertyMetadata( false, new PropertyChangedCallback( DefaultDetailConfiguration.OnIsDeleteCommandEnabledChanged ) ) );
 
     public bool IsDeleteCommandEnabled
@@ -273,8 +269,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion IsDeleteCommandEnabled Property
 
-    #region Internal Methods
-
     internal void AddDefaultHeadersFooters()
     {
       if( m_defaultHeadersFootersAdded )
@@ -282,16 +276,9 @@ namespace Xceed.Wpf.DataGrid
 
       m_defaultHeadersFootersAdded = true;
 
-      DetailConfiguration.AddDefaultHeadersFooters( this.Headers, this.Footers );
-    } 
-
-    #endregion
-
-    #region Private Fields
-
-    private bool m_defaultHeadersFootersAdded = false; 
-
-    #endregion
+      DetailConfiguration.AddDefaultHeadersFooters( this.Headers, false );
+    }
 
+    private bool m_defaultHeadersFootersAdded = false;
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfiguration.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfiguration.cs
index 78daf234..0d73e4da 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfiguration.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfiguration.cs
@@ -15,27 +15,23 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Text;
-using System.Windows;
-using System.Windows.Controls;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
-using System.Collections;
-using System.Diagnostics;
-using Xceed.Wpf.DataGrid.Views;
 using System.ComponentModel;
-using Xceed.Wpf.DataGrid.Markup;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Data;
 using System.Windows.Input;
-using System.Windows.Media;
+using Xceed.Wpf.DataGrid.Markup;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
   internal sealed class DetailConfiguration : DependencyObject, IWeakEventListener, ISupportInitialize, INotifyPropertyChanged
   {
-    #region Constructors
-
     static DetailConfiguration()
     {
       DetailConfiguration.DetailConfigurationsProperty = DetailConfiguration.DetailConfigurationsPropertyKey.DependencyProperty;
@@ -48,54 +44,28 @@ namespace Xceed.Wpf.DataGrid
       DetailConfiguration.BuildDefaultTemplates();
     }
 
-    internal DetailConfiguration( bool isSynchronizedWithParent )
+    public DetailConfiguration()
     {
-      if( !isSynchronizedWithParent )
-      {
-        this.SetColumns( new ColumnCollection( this.DataGridControl, this ) );
-        this.Columns.CollectionChanged += new NotifyCollectionChangedEventHandler( this.OnColumnsCollectionChanged );
-        VisibilityChangedEventManager.AddListener( this.Columns, this );
+      var columns = new ColumnCollection( this.DataGridControl, this );
 
-        this.SetVisibleColumns( new ReadOnlyColumnCollection() );
+      this.SetColumns( columns );
+      this.Columns.CollectionChanged += new NotifyCollectionChangedEventHandler( this.OnColumnsCollectionChanged );
+      VisibilityChangedEventManager.AddListener( this.Columns, this );
 
-        m_columnsByVisiblePosition = new HashedLinkedList<ColumnBase>();
+      this.SetVisibleColumns( new ReadOnlyColumnCollection() );
 
-        this.SetGroupLevelDescriptions( new GroupLevelDescriptionCollection() );
-      }
+      m_columnsByVisiblePosition = new HashedLinkedList<ColumnBase>();
+      m_columnSynchronizationManager = new ColumnSynchronizationManager( this );
 
       this.SetHeaders( new ObservableCollection<DataTemplate>() );
       this.SetFooters( new ObservableCollection<DataTemplate>() );
 
+      this.SetGroupLevelDescriptions( new GroupLevelDescriptionCollection() );
       this.SetDetailConfigurations( new DetailConfigurationCollection( this.DataGridControl, this ) );
-
       CollectionChangedEventManager.AddListener( this.DetailConfigurations, this );
-    }
-
-    internal DetailConfiguration( DataGridContext synchronizedParent )
-      : this( true )
-    {
-      m_shouldCreateColumns = false;
-
-      this.SetColumns( synchronizedParent.Columns );
-      this.SetVisibleColumns( synchronizedParent.VisibleColumns );
-      m_columnsByVisiblePosition = synchronizedParent.ColumnsByVisiblePosition;
 
-      m_sortDescriptions = synchronizedParent.Items.SortDescriptions;
-      m_groupDescriptions = synchronizedParent.Items.GroupDescriptions;
-
-      this.SetGroupLevelDescriptions( synchronizedParent.GroupLevelDescriptions );
     }
 
-    public DetailConfiguration()
-      : this( false )
-    {
-    }
-
-
-    #endregion
-
-    #region Static Fields
-
     private static void BuildDefaultTemplates()
     {
       //Defining the FrameworkElementFactory variables I will use below.
@@ -171,14 +141,13 @@ namespace Xceed.Wpf.DataGrid
     private static DataTemplate DefaultColumnManagerRowTemplate;
     private static DataTemplate DefaultGroupByControlTemplate;
 
-    #endregion
-
-    #region Static Methods
-
-    internal static void AddDefaultHeadersFooters( ObservableCollection<DataTemplate> headersCollection, ObservableCollection<DataTemplate> footersCollection )
+    internal static void AddDefaultHeadersFooters( ObservableCollection<DataTemplate> headersCollection, bool areDetailsFlatten )
     {
-      headersCollection.Insert( 0, DetailConfiguration.DefaultColumnManagerRowTemplate );
-      headersCollection.Insert( 0, DetailConfiguration.DefaultHeaderSpacerTemplate );
+      if( !areDetailsFlatten )
+      {
+        headersCollection.Insert( 0, DetailConfiguration.DefaultColumnManagerRowTemplate );
+        headersCollection.Insert( 0, DetailConfiguration.DefaultHeaderSpacerTemplate );
+      }
     }
 
     internal static void SynchronizeDetailConfigurations(
@@ -189,11 +158,10 @@ namespace Xceed.Wpf.DataGrid
       bool autoRemoveUnassociated )
     {
       HashSet<DetailConfiguration> detailConfigWithAssociation = new HashSet<DetailConfiguration>();
-      DetailConfiguration detailConfig;
 
       foreach( DataGridDetailDescription detailDescription in dataGridDetailDescriptionCollection )
       {
-        detailConfig = detailConfigurationCollection[ detailDescription.RelationName ];
+        DetailConfiguration detailConfig = detailConfigurationCollection[ detailDescription.RelationName ];
 
         if( detailConfig == null )
         {
@@ -218,7 +186,7 @@ namespace Xceed.Wpf.DataGrid
 
       for( int i = detailConfigurationCollection.Count - 1; i >= 0; i-- )
       {
-        detailConfig = detailConfigurationCollection[ i ];
+        DetailConfiguration detailConfig = detailConfigurationCollection[ i ];
 
         if( !detailConfigWithAssociation.Contains( detailConfig ) )
         {
@@ -263,10 +231,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion
-
-    // PUBLIC PROPERTIES
-
     #region RelationName Property
 
     public static readonly DependencyProperty RelationNameProperty =
@@ -357,7 +321,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region AutoRemoveColumnsAndDetailConfigurations Property
 
-    public static readonly DependencyProperty AutoRemoveColumnsAndDetailConfigurationsProperty = 
+    public static readonly DependencyProperty AutoRemoveColumnsAndDetailConfigurationsProperty =
       DataGridControl.AutoRemoveColumnsAndDetailConfigurationsProperty.AddOwner( typeof( DetailConfiguration ) );
 
     public bool AutoRemoveColumnsAndDetailConfigurations
@@ -394,7 +358,7 @@ namespace Xceed.Wpf.DataGrid
       this.SetValue( DetailConfiguration.ColumnsPropertyKey, value );
     }
 
-    #endregion Columns Read-Only Property
+    #endregion
 
     #region DefaultDetailConfiguration Property
 
@@ -812,16 +776,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-
-    #region Events
-
-    internal event EventHandler<EventArgs> RequestingDelayBringIntoViewAndFocusCurrent;
-
-    #endregion
-
-
-    // INTERNAL PROPERTIES
-
     #region CurrentColumn Property
 
     internal ColumnBase CurrentColumn
@@ -910,6 +864,7 @@ namespace Xceed.Wpf.DataGrid
         {
           m_sortDescriptionsSyncContext = new SortDescriptionsSyncContext();
         }
+
         return m_sortDescriptionsSyncContext;
       }
     }
@@ -928,6 +883,8 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private SortDescriptionCollection m_sortDescriptions; // = null
+
     #endregion
 
     #region GroupDescriptions Read-Only Property
@@ -940,24 +897,43 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private ObservableCollection<GroupDescription> m_groupDescriptions; // = null
+
     #endregion
 
-    #region DataGridControl Property
+    #region DataGridControl Internal Property
 
     internal DataGridControl DataGridControl
     {
       get
       {
-        if( m_containingCollection == null )
-          return null;
+        var collection = this.ContainingCollection;
+        if( collection != null )
+          return collection.DataGridControl;
 
-        return m_containingCollection.DataGridControl;
+        return null;
+      }
+      private set
+      {
+        if( this.Columns != null )
+        {
+          this.Columns.DataGridControl = value;
+        }
+
+        if( this.DetailConfigurations != null )
+        {
+          this.DetailConfigurations.DataGridControl = value;
+        }
+
+        m_fieldNameMap.SetSource( value, this.DetailDescription );
+
+        this.OnPropertyChanged( "DataGridControl" );
       }
     }
 
-    #endregion DataGridControl Property
+    #endregion
 
-    #region ParentDetailConfiguration Property
+    #region ParentDetailConfiguration Internal Property
 
     internal DetailConfiguration ParentDetailConfiguration
     {
@@ -970,9 +946,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion ParentDetailConfiguration Property
+    #endregion
 
-    #region IsAutoCreated Property
+    #region IsAutoCreated Internal Property
 
     internal bool IsAutoCreated
     {
@@ -991,7 +967,85 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region RecyclingManager Read-Only property
+    #region IsAttachedToDetailDescription Internal Read-Only Property
+
+    internal bool IsAttachedToDetailDescription
+    {
+      get
+      {
+        return m_isAttachedToDetailDescription;
+      }
+      private set
+      {
+        if( value == m_isAttachedToDetailDescription )
+          return;
+
+        m_isAttachedToDetailDescription = value;
+        this.OnPropertyChanged( "IsAttachedToDetailDescription" );
+      }
+    }
+
+    private bool m_isAttachedToDetailDescription; //false
+
+    #endregion
+
+    #region ItemPropertyMap Internal Property
+
+    internal FieldNameMap ItemPropertyMap
+    {
+      get
+      {
+        return m_fieldNameMap;
+      }
+    }
+
+    private readonly FieldNameMapProxy m_fieldNameMap = new FieldNameMapProxy();
+
+    #endregion
+
+    #region UpdateColumnSortCommand Internal Property
+
+    internal UpdateColumnSortCommand UpdateColumnSortCommand
+    {
+      get
+      {
+        if( m_updateColumnSortCommand == null )
+        {
+          m_updateColumnSortCommand = new DetailConfigurationUpdateColumnSortCommand( this );
+        }
+
+        Debug.Assert( m_updateColumnSortCommand != null );
+
+        return m_updateColumnSortCommand;
+      }
+    }
+
+    private UpdateColumnSortCommand m_updateColumnSortCommand;
+
+    #endregion
+
+    #region AddGroupCommand Internal Property
+
+    internal ColumnAddGroupCommand AddGroupCommand
+    {
+      get
+      {
+        if( m_addGroupCommand == null )
+        {
+          m_addGroupCommand = new DetailConfigurationAddGroupCommand( this );
+        }
+
+        Debug.Assert( m_addGroupCommand != null );
+
+        return m_addGroupCommand;
+      }
+    }
+
+    private ColumnAddGroupCommand m_addGroupCommand;
+
+    #endregion
+
+    #region RecyclingManager Internal Read-Only property
 
     internal RecyclingManager RecyclingManager
     {
@@ -1030,7 +1084,111 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion IsDeleteCommandEnabled Property
 
-    #region Protected Methods
+    #region DetailDescription Private Property
+
+    private DataGridDetailDescription DetailDescription
+    {
+      get
+      {
+        return m_detailDescription;
+      }
+      set
+      {
+        if( value == m_detailDescription )
+          return;
+
+        m_detailDescription = value;
+        this.OnPropertyChanged( "DetailDescription" );
+
+        this.IsAttachedToDetailDescription = ( value != null );
+      }
+    }
+
+    private DataGridDetailDescription m_detailDescription; // = null 
+
+    #endregion
+
+    #region ContainingCollection Private Property
+
+    private DetailConfigurationCollection ContainingCollection
+    {
+      get
+      {
+        return m_containingCollection;
+      }
+      set
+      {
+        if( value == m_containingCollection )
+          return;
+
+        if( m_containingCollection != null )
+        {
+          ( ( INotifyPropertyChanged )m_containingCollection ).PropertyChanged -= new PropertyChangedEventHandler( this.OnContainingCollectionPropertyChanged );
+        }
+
+        m_containingCollection = value;
+
+        if( m_containingCollection != null )
+        {
+          ( ( INotifyPropertyChanged )m_containingCollection ).PropertyChanged += new PropertyChangedEventHandler( this.OnContainingCollectionPropertyChanged );
+
+          this.DataGridControl = m_containingCollection.DataGridControl;
+        }
+        else
+        {
+          this.DataGridControl = null;
+        }
+      }
+    }
+
+    private void OnContainingCollectionPropertyChanged( object sender, PropertyChangedEventArgs e )
+    {
+      var containingCollection = ( DetailConfigurationCollection )sender;
+      Debug.Assert( containingCollection == this.ContainingCollection );
+
+      var propertyName = e.PropertyName;
+      bool mayHaveChanged = string.IsNullOrEmpty( propertyName );
+
+      if( mayHaveChanged || ( propertyName == "DataGridControl" ) )
+      {
+        this.DataGridControl = containingCollection.DataGridControl;
+      }
+    }
+
+    private DetailConfigurationCollection m_containingCollection; // = null
+
+    #endregion
+
+    #region ColumnSynchronizationManager Private Read-Only Property
+
+    private ColumnSynchronizationManager ColumnSynchronizationManager
+    {
+      get
+      {
+        return m_columnSynchronizationManager;
+      }
+    }
+
+    private readonly ColumnSynchronizationManager m_columnSynchronizationManager;
+
+    #endregion
+
+    #region IsSettingFixedColumnCount Property
+
+    internal bool IsSettingFixedColumnCount
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region Events
+
+    internal event EventHandler<RequestingDelayBringIntoViewAndFocusCurrentEventArgs> RequestingDelayBringIntoViewAndFocusCurrent;
+    internal event EventHandler FixedColumnCountChanged;
+
+    #endregion
 
     protected override void OnPropertyChanged( DependencyPropertyChangedEventArgs e )
     {
@@ -1045,10 +1203,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion
-
-    #region Internal Methods
-
     internal void AddDefaultHeadersFooters()
     {
       if( m_defaultHeadersFootersAdded )
@@ -1056,56 +1210,79 @@ namespace Xceed.Wpf.DataGrid
 
       m_defaultHeadersFootersAdded = true;
 
-      DetailConfiguration.AddDefaultHeadersFooters( this.Headers, this.Footers );
+      DetailConfiguration.AddDefaultHeadersFooters( this.Headers, this.DataGridControl.AreDetailsFlatten );
     }
 
     internal void SynchronizeForeignKeyConfigurations()
     {
-      if( m_detailDescription == null )
+      var detailDescription = this.DetailDescription;
+      if( detailDescription == null )
         return;
 
       ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView(
         this.Columns.FieldNameToColumnDictionary,
-        m_detailDescription.ItemProperties,
+        detailDescription.ItemProperties,
         this.AutoCreateForeignKeyConfigurations );
     }
 
-    #endregion
+    internal void AttachToContainingCollection( DetailConfigurationCollection detailConfigurationCollection )
+    {
+      if( detailConfigurationCollection == null )
+        throw new ArgumentNullException( "detailConfigurationCollection" );
+
+      this.ContainingCollection = detailConfigurationCollection;
+    }
+
+    internal void DetachFromContainingCollection()
+    {
+      this.ContainingCollection = null;
+    }
+
+    internal void RaiseFixedColumnCountChanged( FixedColumnCountInfoEventArgs infoEventArgs )
+    {
+      this.IsSettingFixedColumnCount = true;
 
-    #region Private Methods
+      if( this.FixedColumnCountChanged != null )
+      {
+        this.FixedColumnCountChanged( this, infoEventArgs );
+      }
+    }
 
     private void SynchronizeWithDetailDescription( DataGridDetailDescription detailDescription )
     {
-      if( detailDescription != m_detailDescription )
+      if( detailDescription != this.DetailDescription )
       {
         this.DetachFromDetailDescription();
 
         m_shouldCreateColumns = true;
-        m_detailDescription = detailDescription;
+        this.DetailDescription = detailDescription;
 
-        DataGridSortDescriptionCollection dataGridSortDescriptionCollection = null;
+        DataGridSortDescriptionCollection dataGridSortDescriptionCollection;
+        ObservableCollection<GroupDescription> groupDescriptionCollection;
 
         if( detailDescription != null )
         {
+          groupDescriptionCollection = detailDescription.GroupDescriptions;
+
           //register to the collectionchanged of the DataGridDetailDescription collection of the detailDescription matching this one.
           dataGridSortDescriptionCollection = detailDescription.DataGridSortDescriptions;
-          m_groupDescriptions = detailDescription.GroupDescriptions;
 
           CollectionChangedEventManager.AddListener( detailDescription.ItemProperties, this );
           CollectionChangedEventManager.AddListener( detailDescription.DetailDescriptions, this );
         }
         else
         {
+          groupDescriptionCollection = new GroupDescriptionCollection();
           dataGridSortDescriptionCollection = new DataGridSortDescriptionCollection();
-          m_groupDescriptions = new GroupDescriptionCollection();
         }
 
+        m_groupDescriptions = groupDescriptionCollection;
         m_sortDescriptions = dataGridSortDescriptionCollection;
         m_sortDescriptionsSyncContext = null; //clear it, if it was ever set!
-
+        m_fieldNameMap.SetSource( this.DataGridControl, detailDescription );
 
         //This update is required since there might be some columns in the Columns collection after the XAML parsing of the DetailConfiguration
-        DataGridContext.SynchronizeSortProperties( dataGridSortDescriptionCollection.SyncContext, m_sortDescriptions, this.Columns );
+        this.UpdateColumnSortOrder();
 
         //This update is required since we want the GroupLevelDescriptions to be created if DetailConfiguration in XAML
         //contains GroupDescriptions
@@ -1154,10 +1331,11 @@ namespace Xceed.Wpf.DataGrid
 
     private void DetachFromDetailDescription()
     {
-      if( m_detailDescription != null )
+      var detailDescription = this.DetailDescription;
+      if( detailDescription != null )
       {
-        CollectionChangedEventManager.RemoveListener( m_detailDescription.ItemProperties, this );
-        CollectionChangedEventManager.RemoveListener( m_detailDescription.DetailDescriptions, this );
+        CollectionChangedEventManager.RemoveListener( detailDescription.ItemProperties, this );
+        CollectionChangedEventManager.RemoveListener( detailDescription.DetailDescriptions, this );
       }
 
       if( m_sortDescriptions != null )
@@ -1172,32 +1350,30 @@ namespace Xceed.Wpf.DataGrid
 
       m_sortDescriptions = null;
       m_groupDescriptions = null;
-      m_detailDescription = null;
+      m_fieldNameMap.SetSource( this.DataGridControl, null );
+      this.DetailDescription = null;
 
       m_recyclingManager.Clear();
     }
 
-    private void SortDescriptions_CollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+    private void UpdateColumnSortOrder()
     {
-      bool runSynchronization = true;
-
-      this.RequestDelayBringIntoViewAndFocusCurrent();
-
-      //If the resort is defered, it's because another section of code is already taking care of the update... Do not process the change notification
-      DataGridSortDescriptionCollection dataGridSortDescriptions = m_sortDescriptions as DataGridSortDescriptionCollection;
-      if( dataGridSortDescriptions != null )
-        runSynchronization = !dataGridSortDescriptions.IsResortDefered;
-
-      if( runSynchronization == true )
+      var updateColumnSortCommand = this.UpdateColumnSortCommand;
+      if( updateColumnSortCommand.CanExecute() )
       {
-        //No need to protect against SortDescriptions being null, since this reacts to the sort descriptions changes
-        DataGridContext.SynchronizeSortProperties( this.SortDescriptionsSyncContext, m_sortDescriptions, this.Columns );
+        this.UpdateColumnSortCommand.Execute();
       }
     }
 
+    private void SortDescriptions_CollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+    {
+      this.RequestDelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.SortChanged );
+      this.UpdateColumnSortOrder();
+    }
+
     private void GroupDescriptions_CollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
-      this.RequestDelayBringIntoViewAndFocusCurrent();
+      this.RequestDelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.GroupChanged );
       DataGridContext.UpdateGroupLevelDescriptions( this.GroupLevelDescriptions, e, m_groupDescriptions, this.Columns );
     }
 
@@ -1206,16 +1382,14 @@ namespace Xceed.Wpf.DataGrid
       //call the method that will detect if the CurrentColumn should be removed based on the changes in the Columns collection.
       this.HandleCurrentColumnRemove( e );
 
-      this.RequestDelayBringIntoViewAndFocusCurrent();
+      this.RequestDelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers.ColumnsCollectionChanged );
+      this.UpdateColumnSortOrder();
 
       //Then call the method that will update the VisibleColumns
-      DataGridContext.HandleColumnsCollectionChanged( e, this.Columns,
-        this.VisibleColumns as ReadOnlyColumnCollection,
-        this.ColumnsByVisiblePosition,
-        this.SortDescriptionsSyncContext,
-        m_sortDescriptions );
+      DataGridContext.HandleColumnsCollectionChanged( e, this.Columns, this.VisibleColumns as ReadOnlyColumnCollection, this.ColumnsByVisiblePosition );
 
-      if( m_detailDescription != null )
+      var detailDescription = this.DetailDescription;
+      if( detailDescription != null )
       {
         switch( e.Action )
         {
@@ -1223,7 +1397,7 @@ namespace Xceed.Wpf.DataGrid
             {
               ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView(
                 this.Columns.FieldNameToColumnDictionary,
-                m_detailDescription.ItemProperties,
+                detailDescription.ItemProperties,
                 this.AutoCreateForeignKeyConfigurations );
 
               break;
@@ -1244,7 +1418,7 @@ namespace Xceed.Wpf.DataGrid
 
               ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView(
                 newColumns,
-                m_detailDescription.ItemProperties,
+                detailDescription.ItemProperties,
                 this.AutoCreateForeignKeyConfigurations );
 
               break;
@@ -1286,11 +1460,8 @@ namespace Xceed.Wpf.DataGrid
 
     private void OnDetailConfigurationsChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
-      DataGridDetailDescriptionCollection detailDescriptions = null;
-      if( m_detailDescription != null )
-      {
-        detailDescriptions = m_detailDescription.DetailDescriptions;
-      }
+      var detailDescription = this.DetailDescription;
+      var detailDescriptions = ( detailDescription != null ) ? detailDescription.DetailDescriptions : null;
 
       switch( e.Action )
       {
@@ -1306,15 +1477,14 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void RequestDelayBringIntoViewAndFocusCurrent()
+    private void RequestDelayBringIntoViewAndFocusCurrent( AutoScrollCurrentItemSourceTriggers trigger )
     {
-      if( this.RequestingDelayBringIntoViewAndFocusCurrent != null )
-      {
-        this.RequestingDelayBringIntoViewAndFocusCurrent( this, EventArgs.Empty );
-      }
-    }
+      var handler = this.RequestingDelayBringIntoViewAndFocusCurrent;
+      if( handler == null )
+        return;
 
-    #endregion
+      handler.Invoke( this, new RequestingDelayBringIntoViewAndFocusCurrentEventArgs( trigger ) );
+    }
 
     #region IWeakEventListener Members
 
@@ -1342,10 +1512,11 @@ namespace Xceed.Wpf.DataGrid
         }
         else if( sender is DataGridDetailDescriptionCollection )
         {
-          if( m_detailDescription != null )
+          var detailDescription = this.DetailDescription;
+          if( detailDescription != null )
           {
             DetailConfiguration.SynchronizeDetailConfigurations(
-              m_detailDescription.DetailDescriptions,
+              detailDescription.DetailDescriptions,
               this.DetailConfigurations,
               this.AutoCreateDetailConfigurations,
               this.AutoCreateForeignKeyConfigurations,
@@ -1358,18 +1529,18 @@ namespace Xceed.Wpf.DataGrid
         {
           // Ensure to update ForeignKeyDescriptions and ForeignKeyConfigurations
           // when ItemProperties change on DetailDescription
-          if( m_detailDescription != null )
+          var detailDescription = this.DetailDescription;
+          if( detailDescription != null )
           {
             ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView(
               this.Columns.FieldNameToColumnDictionary,
-              m_detailDescription.ItemProperties,
+              detailDescription.ItemProperties,
               this.AutoCreateForeignKeyConfigurations );
           }
           return true;
         }
       }
-
-      if( managerType == typeof( VisibilityChangedEventManager ) )
+      else if( managerType == typeof( VisibilityChangedEventManager ) )
       {
         var wrappedEventArgs = ( ColumnCollection.WrappedEventEventArgs )e;
 
@@ -1431,59 +1602,434 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region ContainingCollection Methods
+    private bool m_shouldCreateColumns = true;
+    private IDisposable m_columnsInitDisposable; // = null
+    private bool m_defaultHeadersFootersAdded; // = false
 
-    internal void AttachToContainingCollection( DetailConfigurationCollection detailConfigurationCollection )
+    private readonly RecyclingManager m_recyclingManager = new RecyclingManager();
+
+    private sealed class DetailConfigurationUpdateColumnSortCommand : UpdateColumnSortCommand
     {
-      if( m_containingCollection == detailConfigurationCollection )
-        return;
+      private static void ThrowIfDetailsNotFlatten( DetailConfiguration detailConfiguration )
+      {
+        Debug.Assert( detailConfiguration != null );
 
-      Debug.Assert( detailConfigurationCollection != null, "For clarity purposes, you should use Detach in this context... or remove this assert." );
+        var dataGridControl = detailConfiguration.DataGridControl;
+        if( ( dataGridControl != null ) && ( !dataGridControl.AreDetailsFlatten ) )
+          throw new InvalidOperationException( "This method cannot be invoked when details are not flattened." );
+      }
 
-      if( detailConfigurationCollection == null )
+      internal DetailConfigurationUpdateColumnSortCommand( DetailConfiguration detailConfiguration )
       {
-        this.DetachFromContainingCollection();
+        DetailConfigurationUpdateColumnSortCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" );
+
+        m_detailConfiguration = new WeakReference( detailConfiguration );
       }
-      else
+
+      #region SortDescriptionsSyncContext Protected Property
+
+      protected override SortDescriptionsSyncContext SortDescriptionsSyncContext
       {
-        m_containingCollection = detailConfigurationCollection;
+        get
+        {
+          var detailConfiguration = this.DetailConfiguration;
+          if( detailConfiguration == null )
+            return null;
 
-        if( this.Columns != null )
-          this.Columns.DataGridControl = this.DataGridControl;
+          return detailConfiguration.SortDescriptionsSyncContext;
+        }
+      }
 
-        if( this.DetailConfigurations != null )
-          this.DetailConfigurations.DataGridControl = this.DataGridControl;
+      #endregion
+
+      #region DetailConfiguration Private Property
+
+      private DetailConfiguration DetailConfiguration
+      {
+        get
+        {
+          return m_detailConfiguration.Target as DetailConfiguration;
+        }
+      }
+
+      private readonly WeakReference m_detailConfiguration;
+
+      #endregion
+
+      protected override bool CanExecuteCore()
+      {
+        var detailConfiguration = this.DetailConfiguration;
+        if( detailConfiguration == null )
+          return false;
+
+        var dataGridControl = detailConfiguration.DataGridControl;
+        if( dataGridControl == null )
+          return false;
+
+        var detailDescription = detailConfiguration.DetailDescription;
+        if( detailDescription == null )
+          return false;
+
+        return true;
+      }
+
+      protected override void ExecuteCore()
+      {
+        DetailConfiguration detailConfiguration = this.DetailConfiguration;
+        if( detailConfiguration == null )
+          return;
+
+        var dataGridControl = detailConfiguration.DataGridControl;
+        if( dataGridControl == null )
+          return;
+
+        using( var synchronizationContext = this.StartSynchronizing( detailConfiguration.SortDescriptionsSyncContext ) )
+        {
+          // The SortDescription collection is already being updated.
+          if( !synchronizationContext.Own )
+            return;
+
+          // The sort order of the flatten details is driven by the master.  Flatten details are not
+          // allowed to modify the sort order at their level.
+          if( dataGridControl.AreDetailsFlatten )
+          {
+            this.SynchronizeDetailSortDescriptions( synchronizationContext, detailConfiguration );
+          }
+
+          this.SynchronizeColumnSort(
+            synchronizationContext,
+            detailConfiguration.SortDescriptions,
+            detailConfiguration.Columns );
+        }
+      }
+
+      private static IEnumerable<DataGridContext> GetDataGridContexts( DetailConfiguration detailConfiguration )
+      {
+        Debug.Assert( detailConfiguration != null );
+
+        var dataGridControl = detailConfiguration.DataGridControl;
+        Debug.Assert( dataGridControl != null );
+
+        var queue = new Queue<DataGridContext>();
+        queue.Enqueue( dataGridControl.DataGridContext );
+
+        while( queue.Count > 0 )
+        {
+          DataGridContext dataGridContext = queue.Dequeue();
+
+          if( dataGridContext.SourceDetailConfiguration == detailConfiguration )
+          {
+            yield return dataGridContext;
+          }
+          else
+          {
+            foreach( var childContext in dataGridContext.GetChildContexts() )
+            {
+              queue.Enqueue( childContext );
+            }
+          }
+        }
+      }
+
+      private IDisposable DeferResortHelper( DetailConfiguration detailConfiguration )
+      {
+        ColumnSortCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" );
+
+        IDisposable defer;
+        if( this.TryDeferResort( detailConfiguration, out defer ) )
+          return defer;
+
+        var disposer = new Disposer();
+
+        foreach( var dataGridContext in DetailConfigurationUpdateColumnSortCommand.GetDataGridContexts( detailConfiguration ) )
+        {
+          disposer.Add( this.DeferResortHelper( dataGridContext.ItemsSourceCollection, dataGridContext.Items ), DisposableType.DeferResort );
+        }
+
+        return disposer;
+      }
+
+      private void SynchronizeDetailSortDescriptions( SynchronizationContext synchronizationContext, DetailConfiguration detailConfiguration )
+      {
+        ColumnSortCommand.ThrowIfNull( synchronizationContext, "synchronizationContext" );
+        ColumnSortCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" );
+        DetailConfigurationUpdateColumnSortCommand.ThrowIfDetailsNotFlatten( detailConfiguration );
+
+        if( !synchronizationContext.Own )
+          return;
+
+        if( !detailConfiguration.IsAttachedToDetailDescription )
+          return;
+
+        var dataGridControl = detailConfiguration.DataGridControl;
+        if( dataGridControl == null )
+          return;
+
+        var rootDataGridContext = dataGridControl.DataGridContext;
+        var masterSortDescriptions = rootDataGridContext.Items.SortDescriptions;
+        var detailSortDescriptions = detailConfiguration.SortDescriptions;
+
+        // There is nothing to synchronize.
+        if( ( masterSortDescriptions.Count == 0 ) && ( detailSortDescriptions.Count == 0 ) )
+          return;
+
+        using( this.DeferResortHelper( detailConfiguration ) )
+        {
+          this.SynchronizeDetailSortDescriptions( masterSortDescriptions, detailSortDescriptions, detailConfiguration.ItemPropertyMap );
+        }
+      }
+
+      private void SynchronizeDetailSortDescriptions( SortDescriptionCollection masterSortDescriptions, SortDescriptionCollection detailSortDescriptions,
+                                                      FieldNameMap itemPropertyMap )
+      {
+        ColumnSortCommand.ThrowIfNull( masterSortDescriptions, "masterSortDescriptions" );
+        ColumnSortCommand.ThrowIfNull( detailSortDescriptions, "detailSortDescriptions" );
+        ColumnSortCommand.ThrowIfNull( itemPropertyMap, "itemPropertyMap" );
+
+        int masterSortDescriptionsCount = masterSortDescriptions.Count;
+        if( masterSortDescriptionsCount > 0 )
+        {
+          int insertionIndex = 0;
+
+          for( int i = 0; i < masterSortDescriptionsCount; i++ )
+          {
+            var sortDescription = masterSortDescriptions[ i ];
+
+            string detailPropertyName;
+            if( !itemPropertyMap.TryGetItemPropertyName( sortDescription.PropertyName, out detailPropertyName ) )
+              continue;
+
+            var detailDirection = sortDescription.Direction;
+
+            if( insertionIndex < detailSortDescriptions.Count )
+            {
+              var detailSortDescription = detailSortDescriptions[ insertionIndex ];
+
+              if( ( detailSortDescription.PropertyName != detailPropertyName ) || ( detailSortDescription.Direction != detailDirection ) )
+              {
+                detailSortDescriptions[ insertionIndex ] = new SortDescription( detailPropertyName, detailDirection );
+              }
+            }
+            else
+            {
+              detailSortDescriptions.Add( new SortDescription( detailPropertyName, detailDirection ) );
+            }
+
+            insertionIndex++;
+          }
+
+          while( insertionIndex < detailSortDescriptions.Count )
+          {
+            detailSortDescriptions.RemoveAt( insertionIndex );
+          }
+        }
+        else if( detailSortDescriptions.Count > 0 )
+        {
+          detailSortDescriptions.Clear();
+        }
       }
     }
 
-    internal void DetachFromContainingCollection()
+    private sealed class DetailConfigurationAddGroupCommand : ColumnAddGroupCommand
     {
-      m_containingCollection = null;
+      internal DetailConfigurationAddGroupCommand( DetailConfiguration detailConfiguration )
+      {
+        DetailConfigurationAddGroupCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" );
+
+        m_detailConfiguration = new WeakReference( detailConfiguration );
+      }
+
+      #region GroupDescriptions Protected Property
+
+      protected override ObservableCollection<GroupDescription> GroupDescriptions
+      {
+        get
+        {
+          var detailConfiguration = this.DetailConfiguration;
+          if( detailConfiguration == null )
+            return null;
+
+          return detailConfiguration.GroupDescriptions;
+        }
+      }
+
+      #endregion
+
+      #region DetailConfiguration Private Property
+
+      private DetailConfiguration DetailConfiguration
+      {
+        get
+        {
+          return m_detailConfiguration.Target as DetailConfiguration;
+        }
+      }
+
+      private readonly WeakReference m_detailConfiguration;
+
+      #endregion
+
+      protected override string GetColumnName( ColumnBase column )
+      {
+        var detailConfiguration = this.DetailConfiguration;
+        if( detailConfiguration == null )
+          return null;
+
+        var fieldNameMap = detailConfiguration.ItemPropertyMap;
+        string fieldName;
 
-      if( this.Columns != null )
-        this.Columns.DataGridControl = this.DataGridControl;
+        if( !fieldNameMap.TryGetItemPropertyName( column, out fieldName ) )
+          return null;
+
+        return fieldName;
+      }
+
+      protected override GroupDescription GetGroupDescription( ColumnBase column )
+      {
+        var detailConfiguration = this.DetailConfiguration;
+        if( detailConfiguration == null )
+          return null;
+
+        return base.GetGroupDescription( column );
+      }
+
+      protected override GroupConfiguration GetGroupConfiguration( ColumnBase column )
+      {
+        var detailConfiguration = this.DetailConfiguration;
+        if( detailConfiguration == null )
+          return null;
 
-      if( this.DetailConfigurations != null )
-        this.DetailConfigurations.DataGridControl = this.DataGridControl;
+        return base.GetGroupConfiguration( column );
+      }
+
+      protected override bool CanExecuteCore( ColumnBase column, int index )
+      {
+        if( this.DetailConfiguration == null )
+          return false;
+
+        return base.CanExecuteCore( column, index );
+      }
+
+      protected override void ExecuteCore( ColumnBase column, int index )
+      {
+        var detailConfig = this.DetailConfiguration;
+        if( detailConfig == null )
+          return;
+
+        var dataGridControl = detailConfig.DataGridControl;
+        IDisposable disposable = null;
+
+        try
+        {
+          if( dataGridControl != null )
+          {
+            disposable = dataGridControl.SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged );
+          }
+
+          base.ExecuteCore( column, index );
+        }
+        finally
+        {
+          if( disposable != null )
+          {
+            disposable.Dispose();
+          }
+        }
+      }
     }
 
-    #endregion ContainingCollection Methods
+    private sealed class FieldNameMapProxy : FieldNameMap, INotifyCollectionChanged
+    {
+      #region Source Private Property
 
-    #region Private Fields
+      private FieldNameMap Source
+      {
+        get
+        {
+          return m_source;
+        }
+        set
+        {
+          if( value == m_source )
+            return;
 
-    private DetailConfigurationCollection m_containingCollection; // = null
+          var oldSource = m_source as INotifyCollectionChanged;
+          if( oldSource != null )
+          {
+            oldSource.CollectionChanged -= new NotifyCollectionChangedEventHandler( this.OnSourceCollectionChanged );
+          }
 
-    private SortDescriptionCollection m_sortDescriptions; // = null
-    private ObservableCollection<GroupDescription> m_groupDescriptions; // = null
+          m_source = value;
 
-    private bool m_shouldCreateColumns = true;
-    private IDisposable m_columnsInitDisposable; // = null
-    private bool m_defaultHeadersFootersAdded; // = false
+          var newSource = m_source as INotifyCollectionChanged;
+          if( newSource != null )
+          {
+            newSource.CollectionChanged += new NotifyCollectionChangedEventHandler( this.OnSourceCollectionChanged );
+          }
 
-    private readonly RecyclingManager m_recyclingManager = new RecyclingManager();
+          this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+        }
+      }
 
-    private DataGridDetailDescription m_detailDescription; // = null 
+      private FieldNameMap m_source;
 
-    #endregion
+      #endregion
+
+      protected override bool TryGetSource( string targetName, out string sourceName )
+      {
+        var source = this.Source;
+        if( source != null )
+          return source.TryGetItemPropertyName( targetName, out sourceName );
+
+        return base.TryGetSource( targetName, out sourceName );
+      }
+
+      protected override bool TryGetTarget( string sourceName, out string targetName )
+      {
+        var source = this.Source;
+        if( source != null )
+          return source.TryGetColumnFieldName( sourceName, out targetName );
+
+        return base.TryGetTarget( sourceName, out targetName );
+      }
+
+      internal void SetSource( DataGridControl dataGridControl, DataGridDetailDescription detailDescription )
+      {
+        if( ( dataGridControl == null ) || ( detailDescription == null ) || ( !dataGridControl.AreDetailsFlatten ) )
+        {
+          this.Source = null;
+        }
+        else
+        {
+          var map = this.Source as ItemPropertyNameMap;
+          var itemProperties = detailDescription.ItemProperties;
+
+          if( ( map == null ) || ( map.ItemProperties != detailDescription.ItemProperties ) )
+          {
+            this.Source = new ItemPropertyNameMap( itemProperties );
+          }
+        }
+      }
+
+      private void OnSourceCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+      {
+        this.RaiseCollectionChanged( e );
+      }
+
+      #region INotifyCollectionChanged Members
+
+      public event NotifyCollectionChangedEventHandler CollectionChanged;
+
+      private void RaiseCollectionChanged( NotifyCollectionChangedEventArgs e )
+      {
+        var handler = this.CollectionChanged;
+        if( handler == null )
+          return;
+
+        handler.Invoke( this, e );
+      }
+
+      #endregion
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfigurationCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfigurationCollection.cs
index be1a210e..b3cf167b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfigurationCollection.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DetailConfigurationCollection.cs
@@ -15,11 +15,9 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Windows;
-using System.Collections.Specialized;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -36,7 +34,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion CONSTRUCTORS
 
-    public DetailConfiguration this[ string relationName]
+    public DetailConfiguration this[ string relationName ]
     {
       get
       {
@@ -139,24 +137,13 @@ namespace Xceed.Wpf.DataGrid
 
         m_dataGridControl = value;
 
-        foreach( DetailConfiguration detail in this.Items )
-        {
-          if( detail.Columns != null )
-          {
-            detail.Columns.DataGridControl = value;
-          }
-
-          if( detail.DetailConfigurations != null )
-          {
-            detail.DetailConfigurations.DataGridControl = value;
-          }
-        }
+        this.OnPropertyChanged( new PropertyChangedEventArgs( "DataGridControl" ) );
       }
     }
 
     private DataGridControl m_dataGridControl;
 
-    #endregion DataGridControl Property
+    #endregion
 
     #region ParentDetailConfiguration Property
 
@@ -166,6 +153,6 @@ namespace Xceed.Wpf.DataGrid
       set;
     }
 
-    #endregion ParentDetailConfiguration Property
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DropMarkAdorner.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DropMarkAdorner.cs
index 9ad2463c..f5b8a937 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DropMarkAdorner.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/DropMarkAdorner.cs
@@ -44,8 +44,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    // This Property does not use the Alignment paradigm. It allows to manually set the
-    // position of the drop mark.
+    // This Property does not use the Alignment paradigm. It allows to manually set the position of the drop mark.
     #region HorizontalPosition Property
 
     public static readonly DependencyProperty HorizontalPositionProperty = DependencyProperty.Register(
@@ -80,7 +79,6 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-
     public void ForceAlignment( DropMarkAlignment alignment )
     {
       m_alignment = alignment;
@@ -143,8 +141,6 @@ namespace Xceed.Wpf.DataGrid
           case DropMarkOrientation.Horizontal:
             size = new Size( this.AdornedElement.RenderSize.Width, m_pen.Thickness );
             break;
-          default:
-            throw new DataGridInternalException();
         }
       }
 
@@ -197,8 +193,8 @@ namespace Xceed.Wpf.DataGrid
       if( m_pen != null )
       {
         Size renderSize = this.RenderSize;
-        Point startPoint;
-        Point endPoint;
+        Point startPoint = new Point();
+        Point endPoint = new Point();
 
         switch( m_orientation )
         {
@@ -211,8 +207,6 @@ namespace Xceed.Wpf.DataGrid
             startPoint = new Point( 0d, renderSize.Height / 2 );
             endPoint = new Point( renderSize.Width, startPoint.Y );
             break;
-          default:
-            throw new DataGridInternalException();
         }
 
         drawingContext.DrawLine( m_pen, startPoint, endPoint );
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/(Clipboard)/ClipboardExporterBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/(Clipboard)/ClipboardExporterBase.cs
index 8a075453..e34bab80 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/(Clipboard)/ClipboardExporterBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/(Clipboard)/ClipboardExporterBase.cs
@@ -15,30 +15,23 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows;
-using System.Diagnostics;
-using System.IO;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Windows.Data;
+using System.Diagnostics;
+using System.Globalization;
+using System.Windows;
 
 namespace Xceed.Wpf.DataGrid.Export
 {
   public abstract class ClipboardExporterBase
   {
-    #region CONSTRUCTORS
-
     protected ClipboardExporterBase()
     {
       this.UseFieldNamesInHeader = false;
     }
 
-    #endregion
-
-    #region PUBLIC PROPERTIES
+    #region IncludeColumnHeaders Property
 
     public bool IncludeColumnHeaders
     {
@@ -46,6 +39,10 @@ namespace Xceed.Wpf.DataGrid.Export
       set;
     }
 
+    #endregion
+
+    #region UseFieldNamesInHeader Property
+
     public bool UseFieldNamesInHeader
     {
       get;
@@ -54,7 +51,7 @@ namespace Xceed.Wpf.DataGrid.Export
 
     #endregion
 
-    #region PROTECTED PROPERTIES
+    #region ClipboardData Property
 
     protected abstract object ClipboardData
     {
@@ -63,8 +60,6 @@ namespace Xceed.Wpf.DataGrid.Export
 
     #endregion
 
-    #region PROTECTED METHODS
-
     protected virtual void Indent()
     {
     }
@@ -117,10 +112,6 @@ namespace Xceed.Wpf.DataGrid.Export
     {
     }
 
-    #endregion
-
-    #region INTERNAL STATIC METHODS
-
     internal static IDataObject CreateDataObject( DataGridControl dataGridControl )
     {
       if( dataGridControl == null )
@@ -158,7 +149,9 @@ namespace Xceed.Wpf.DataGrid.Export
           keyPair.Value.EndExporter( keyPair.Key );
 
           if( dataObject == null )
+          {
             dataObject = new XceedDataObject();
+          }
 
           object clipboardExporterValue = keyPair.Value.ClipboardData;
 
@@ -184,14 +177,8 @@ namespace Xceed.Wpf.DataGrid.Export
       return null;
     }
 
-    #endregion
-
-    #region PRIVATE CLASS ManualExporter
-
     private class ManualExporter : IDisposable
     {
-      #region PUBLIC CONSTRUCTORS
-
       public ManualExporter( IEnumerable<ClipboardExporterBase> clipboardExporters )
       {
         m_columnToBindingPathExtractor = new Dictionary<Column, BindingPathValueExtractor>();
@@ -200,8 +187,6 @@ namespace Xceed.Wpf.DataGrid.Export
         m_visitedDetailVisibleColumnsCache = new Dictionary<int, ColumnBase[]>();
       }
 
-      #endregion
-
       #region HasItems Property
 
       public bool HasItems
@@ -210,20 +195,105 @@ namespace Xceed.Wpf.DataGrid.Export
         set;
       }
 
-      #endregion HasItems Property
+      #endregion
+
+      internal void Export( DataGridContext dataGridContext )
+      {
+        if( dataGridContext == null )
+          return;
+
+        // Get the detail level for the current DataGridContext
+        int detailLevel = dataGridContext.DetailLevel;
+
+        // Update indentation of ClipboardExporters for this detail level
+        this.UpdateExporterIndentation( detailLevel );
+
+        // Get master indexes that have mapped expanded details
+        List<int> indexesToMasterItemList = dataGridContext.CustomItemContainerGenerator.GetMasterIndexexWithExpandedDetails();
+
+        // Get the index of the next detail to export in case
+        // it is expanded before the first selected index of the
+        // current dataGridContext
+        int nextDetailIndex = ( indexesToMasterItemList.Count > 0 ) ? indexesToMasterItemList[ 0 ] : -1;
+
+        // Get informations on columns, visible positions and selected item indexes
+        // for this dataGridContext
+        int[] exportedVisiblePositions = this.GetVisiblePositionsForContext( dataGridContext );
+        ColumnBase[] columnsByVisiblePosition = this.GetVisibleColumnsArrayForContext( dataGridContext );
+        SelectionRange[] selectedItemsRanges = this.GetSelectedItemsStoreForDataGridContext( dataGridContext );
+
+        Debug.Assert( exportedVisiblePositions != null );
+        Debug.Assert( columnsByVisiblePosition != null );
+        Debug.Assert( selectedItemsRanges != null );
+
+        int selectedItemsRangesCount = selectedItemsRanges.Length;
+
+        // Ensure to flag the exporter has items
+        this.HasItems = this.HasItems || ( selectedItemsRangesCount > 0 );
+
+        for( int i = 0; i < selectedItemsRangesCount; i++ )
+        {
+          // For the first level, ensure to export the headers
+          // before anything else
+          if( detailLevel == 0 )
+          {
+            this.ExportHeaders( dataGridContext, detailLevel, exportedVisiblePositions, columnsByVisiblePosition );
+          }
+
+          SelectionRange range = selectedItemsRanges[ i ];
+
+          int startIndex = range.StartIndex;
+          int endIndex = range.EndIndex;
+
+          // If range is inverted
+          if( startIndex > endIndex )
+          {
+            startIndex = range.EndIndex;
+            endIndex = range.StartIndex;
+          }
+
+          // For each index in the range
+          for( int itemIndex = startIndex; itemIndex <= endIndex; itemIndex++ )
+          {
+            // Export details that are before the itemIndex
+            while( ( nextDetailIndex != -1 ) && ( itemIndex > nextDetailIndex ) )
+            {
+              this.ExportDetailForMasterIndex( dataGridContext, detailLevel, nextDetailIndex );
+
+              // Remove it since the detail is processed
+              indexesToMasterItemList.Remove( nextDetailIndex );
+
+              nextDetailIndex = ( indexesToMasterItemList.Count > 0 ) ? indexesToMasterItemList[ 0 ] : -1;
+            }
+
+            // Ensure to re-export the headers if a detail was previously exported
+            this.ExportHeaders( dataGridContext, detailLevel, exportedVisiblePositions, columnsByVisiblePosition );
+
+            object exportedItem = dataGridContext.Items.GetItemAt( itemIndex );
+
+            this.ExportDataItem( dataGridContext, itemIndex, exportedItem, detailLevel, exportedVisiblePositions, columnsByVisiblePosition );
+          }
+        }
+
+        nextDetailIndex = ( indexesToMasterItemList.Count > 0 ) ? indexesToMasterItemList[ 0 ] : -1;
+
+        // Export all remaining details since none are before the context's
+        // selected index ranges
+        while( nextDetailIndex != -1 )
+        {
+          this.ExportDetailForMasterIndex( dataGridContext, detailLevel, nextDetailIndex );
 
-      #region PRIVATE METHODS
+          // Remove it since the detail is processed
+          indexesToMasterItemList.Remove( nextDetailIndex );
+
+          nextDetailIndex = ( indexesToMasterItemList.Count > 0 ) ? indexesToMasterItemList[ 0 ] : -1;
+        }
+      }
 
-      private void ExportDataItemCore(
-        DataGridContext dataGridContext,
-        ClipboardExporterBase clipboardExporter,
-        int itemIndex,
-        object item,
-        int[] exportedVisiblePositions,
-        ColumnBase[] columnsByVisiblePosition )
+      private void ExportDataItemCore( DataGridContext dataGridContext, ClipboardExporterBase clipboardExporter, int itemIndex, object item, int[] exportedVisiblePositions,
+                                       ColumnBase[] columnsByVisiblePosition )
       {
-        DataGridCollectionViewBase dataGridCollectionViewBase =
-          dataGridContext.ItemsSourceCollection as DataGridCollectionViewBase;
+        DataGridCollectionViewBase dataGridCollectionViewBase = dataGridContext.ItemsSourceCollection as DataGridCollectionViewBase;
 
         clipboardExporter.StartDataItem( dataGridContext, item );
 
@@ -231,16 +301,16 @@ namespace Xceed.Wpf.DataGrid.Export
         int exportedVisiblePositionsCount = exportedVisiblePositions.Length;
         exportedVisiblePositionsCount = Math.Min( exportedVisiblePositionsCount, columnsByVisiblePosition.Length );
 
-        HashSet<int> intersectedIndexes = this.GetIntersectedRangesForIndex( dataGridContext,
-            itemIndex,
-            exportedVisiblePositions,
-            exportedVisiblePositionsCount );
+        HashSet<int> intersectedIndexes = this.GetIntersectedRangesForIndex( dataGridContext, itemIndex, exportedVisiblePositions, exportedVisiblePositionsCount );
 
         object fieldValue = null;
         Column column = null;
 
         for( int i = 0; i < exportedVisiblePositionsCount; i++ )
         {
+          // Reset field value
+          fieldValue = null;
+
           int visiblePosition = exportedVisiblePositions[ i ];
 
           // Export null if not intersected by a SelectionRange
@@ -252,9 +322,6 @@ namespace Xceed.Wpf.DataGrid.Export
             if( column == null )
               continue;
 
-            // Reset field value
-            fieldValue = null;
-
             // Use DataGridCollectionView directly since the DataGridItemProperty uses PropertyDescriptor which increase
             // the read of the field value
             DataGridItemPropertyBase dataGridItemProperty = null;
@@ -266,7 +333,9 @@ namespace Xceed.Wpf.DataGrid.Export
               dataGridItemProperty = dataGridCollectionViewBase.ItemProperties[ column.FieldName ];
 
               if( dataGridItemProperty != null )
+              {
                 fieldValue = dataGridItemProperty.GetValue( item );
+              }
             }
 
             // If none was found, create a BindingPathValueExtractor from this column
@@ -287,6 +356,25 @@ namespace Xceed.Wpf.DataGrid.Export
             }
           }
 
+          if( fieldValue != null )
+          {
+            //Verify if the value should be converted to the displayed value for exporting.
+            ForeignKeyConfiguration foreignKeyConfiguration = column.ForeignKeyConfiguration;
+
+            if( foreignKeyConfiguration != null && foreignKeyConfiguration.UseDisplayedValueWhenExporting )
+            {
+              fieldValue = foreignKeyConfiguration.GetDisplayMemberValue( fieldValue );
+            }
+            else if( column.DisplayedValueConverter != null )
+            {
+              fieldValue = column.DisplayedValueConverter.Convert( fieldValue, typeof( object ), column.DisplayedValueConverterParameter, column.GetCulture( column.DisplayedValueConverterCulture ) );
+            }
+            else if( !string.IsNullOrEmpty( column.CellContentStringFormat ) )
+            {
+              fieldValue = string.Format( column.GetCulture(), column.CellContentStringFormat, fieldValue );
+            }
+          }
+
           clipboardExporter.StartDataItemField( dataGridContext, column, fieldValue );
           clipboardExporter.EndDataItemField( dataGridContext, column, fieldValue );
         }
@@ -294,11 +382,8 @@ namespace Xceed.Wpf.DataGrid.Export
         clipboardExporter.EndDataItem( dataGridContext, item );
       }
 
-      private void ExportHeadersCore(
-        DataGridContext dataGridContext,
-        ClipboardExporterBase clipboardExporter,
-        int[] exportedVisiblePositions,
-        ColumnBase[] columnsByVisiblePosition )
+      private void ExportHeadersCore( DataGridContext dataGridContext, ClipboardExporterBase clipboardExporter, int[] exportedVisiblePositions,
+                                      ColumnBase[] columnsByVisiblePosition )
       {
         clipboardExporter.StartHeader( dataGridContext );
 
@@ -323,11 +408,7 @@ namespace Xceed.Wpf.DataGrid.Export
         clipboardExporter.EndHeader( dataGridContext );
       }
 
-      private HashSet<int> GetIntersectedRangesForIndex(
-        DataGridContext dataGridContext,
-        int itemIndex,
-        int[] exportedVisiblePositions,
-        int correctedExportedVisiblePositionsCount )
+      private HashSet<int> GetIntersectedRangesForIndex( DataGridContext dataGridContext, int itemIndex, int[] exportedVisiblePositions, int correctedExportedVisiblePositionsCount )
       {
         HashSet<int> intersectedIndexes = null;
 
@@ -344,13 +425,10 @@ namespace Xceed.Wpf.DataGrid.Export
         {
           intersectedIndexes = new HashSet<int>();
 
-          SelectionCellRange columnsRange = new SelectionCellRange( itemIndex,
-             exportedVisiblePositions[ 0 ],
-             itemIndex,
-             exportedVisiblePositions[ correctedExportedVisiblePositionsCount - 1 ] );
+          SelectionCellRange columnsRange = new SelectionCellRange( itemIndex, exportedVisiblePositions[ 0 ], itemIndex,
+                                                                    exportedVisiblePositions[ correctedExportedVisiblePositionsCount - 1 ] );
 
-          List<SelectionRange> intersectedRanges =
-            dataGridContext.SelectedCellsStore.GetIntersectedColumnRanges( columnsRange );
+          IEnumerable<SelectionRange> intersectedRanges = dataGridContext.SelectedCellsStore.GetIntersectedColumnRanges( columnsRange );
 
           foreach( SelectionRange range in intersectedRanges )
           {
@@ -366,7 +444,9 @@ namespace Xceed.Wpf.DataGrid.Export
             for( int i = startIndex; i <= endIndex; i++ )
             {
               if( !intersectedIndexes.Contains( i ) )
+              {
                 intersectedIndexes.Add( i );
+              }
             }
           }
         }
@@ -374,18 +454,17 @@ namespace Xceed.Wpf.DataGrid.Export
         return intersectedIndexes;
       }
 
-      private void GetAllVisibleColumnsVisiblePosition(
-        DataGridContext dataGridContext,
-        ref HashSet<int> exportedColumnPositions )
+      private void GetAllVisibleColumnsVisiblePosition( DataGridContext dataGridContext, ref HashSet<int> exportedColumnPositions )
       {
         if( exportedColumnPositions == null )
+        {
           exportedColumnPositions = new HashSet<int>();
+        }
 
         if( dataGridContext == null )
           return;
 
-        ReadOnlyObservableCollection<ColumnBase> visibleColumns =
-            dataGridContext.VisibleColumns;
+        ReadOnlyObservableCollection<ColumnBase> visibleColumns = dataGridContext.VisibleColumns;
 
         int visibleColumnsCount = visibleColumns.Count;
 
@@ -400,32 +479,18 @@ namespace Xceed.Wpf.DataGrid.Export
         }
       }
 
-      private void ExportDataItem(
-       DataGridContext dataGridContext,
-       int itemIndex,
-       object item,
-       int detailLevel,
-       int[] exportedVisiblePositions,
-       ColumnBase[] columnsByVisiblePosition )
+      private void ExportDataItem( DataGridContext dataGridContext, int itemIndex, object item, int detailLevel, int[] exportedVisiblePositions,
+                                   ColumnBase[] columnsByVisiblePosition )
       {
         Debug.WriteLine( string.Format( "ExportDataItem for detail level {0}, itemIndex {1}", detailLevel, itemIndex ) );
 
         foreach( ClipboardExporterBase clipboardExporter in m_clipboardExporters )
         {
-          this.ExportDataItemCore( dataGridContext,
-            clipboardExporter,
-            itemIndex,
-            item,
-            exportedVisiblePositions,
-            columnsByVisiblePosition );
+          this.ExportDataItemCore( dataGridContext, clipboardExporter, itemIndex, item, exportedVisiblePositions, columnsByVisiblePosition );
         }
       }
 
-      private void ExportHeaders(
-        DataGridContext dataGridContext,
-        int detailLevel,
-        int[] exportedVisiblePositions,
-        ColumnBase[] columnsByVisiblePosition )
+      private void ExportHeaders( DataGridContext dataGridContext, int detailLevel, int[] exportedVisiblePositions, ColumnBase[] columnsByVisiblePosition )
       {
         // Master level was already exported, only update the lastExportedHeaderDetailLevel
         if( ( m_lastExportedHeaderDetailLevel != -1 ) && ( detailLevel == 0 ) )
@@ -445,25 +510,18 @@ namespace Xceed.Wpf.DataGrid.Export
           // We always add the headers for detail levels every time
           if( clipboardExporter.IncludeColumnHeaders )
           {
-            this.ExportHeadersCore( dataGridContext,
-              clipboardExporter,
-              exportedVisiblePositions,
-              columnsByVisiblePosition );
+            this.ExportHeadersCore( dataGridContext, clipboardExporter, exportedVisiblePositions, columnsByVisiblePosition );
           }
         }
 
         m_lastExportedHeaderDetailLevel = detailLevel;
       }
 
-      private void ExportDetailForMasterIndex(
-        DataGridContext dataGridContext,
-        int detailLevel,
-        int masterIndexForDetail )
+      private void ExportDetailForMasterIndex( DataGridContext dataGridContext, int detailLevel, int masterIndexForDetail )
       {
         object item = dataGridContext.Items.GetItemAt( masterIndexForDetail );
 
-        IEnumerable<DataGridContext> dataGridContexts =
-           dataGridContext.CustomItemContainerGenerator.GetChildContextsForMasterItem( item );
+        IEnumerable<DataGridContext> dataGridContexts = dataGridContext.CustomItemContainerGenerator.GetChildContextsForMasterItem( item );
 
         foreach( DataGridContext childContext in dataGridContexts )
         {
@@ -473,8 +531,7 @@ namespace Xceed.Wpf.DataGrid.Export
         this.UpdateExporterIndentation( detailLevel );
       }
 
-      private ColumnBase[] GetVisibleColumnsArrayForContext(
-        DataGridContext dataGridContext )
+      private ColumnBase[] GetVisibleColumnsArrayForContext( DataGridContext dataGridContext )
       {
         if( dataGridContext == null )
           throw new ArgumentNullException( "sourceContext" );
@@ -482,9 +539,7 @@ namespace Xceed.Wpf.DataGrid.Export
         int detailLevel = dataGridContext.DetailLevel;
 
         if( m_visitedDetailVisibleColumnsCache.ContainsKey( detailLevel ) )
-        {
           return m_visitedDetailVisibleColumnsCache[ detailLevel ];
-        }
 
         int columnsByVisiblePositionCount = dataGridContext.ColumnsByVisiblePosition.Count;
         ColumnBase[] columnsByVisiblePosition = new ColumnBase[ columnsByVisiblePositionCount ];
@@ -495,8 +550,7 @@ namespace Xceed.Wpf.DataGrid.Export
         return columnsByVisiblePosition;
       }
 
-      private int[] GetVisiblePositionsForContext(
-        DataGridContext dataGridContext )
+      private int[] GetVisiblePositionsForContext( DataGridContext dataGridContext )
       {
         if( dataGridContext == null )
           throw new ArgumentNullException( "dataGridContext" );
@@ -511,9 +565,7 @@ namespace Xceed.Wpf.DataGrid.Export
 
         DataGridContext rootDataGridContext = dataGridContext.DataGridControl.DataGridContext;
 
-        this.GetVisiblePositionsForContextDetailLevel( rootDataGridContext,
-          detailLevel,
-          exportedColumnPositions );
+        this.GetVisiblePositionsForContextDetailLevel( rootDataGridContext, detailLevel, exportedColumnPositions );
 
         int exportedColumnPositionsCount = exportedColumnPositions.Count;
         int[] exportedVisiblePositionsArray = null;
@@ -528,10 +580,7 @@ namespace Xceed.Wpf.DataGrid.Export
       }
 
       // Parse all the expanded details recursively
-      private void GetVisiblePositionsForContextDetailLevel(
-        DataGridContext dataGridContext,
-        int desiredDetailLevel,
-        HashSet<int> exportedColumnPositions )
+      private void GetVisiblePositionsForContextDetailLevel( DataGridContext dataGridContext, int desiredDetailLevel, HashSet<int> exportedColumnPositions )
       {
         int dataGridContextDetailLevel = dataGridContext.DetailLevel;
 
@@ -546,15 +595,13 @@ namespace Xceed.Wpf.DataGrid.Export
 
           if( parentDataGridContext == null )
           {
-            this.GetVisibleColumnsVisiblePositionForDataGridContext( dataGridContext,
-                  exportedColumnPositions );
+            this.GetVisibleColumnsVisiblePositionForDataGridContext( dataGridContext, exportedColumnPositions );
           }
           else
           {
             foreach( DataGridContext childContext in parentDataGridContext.GetChildContexts() )
             {
-              if( this.GetVisibleColumnsVisiblePositionForDataGridContext( childContext,
-                    exportedColumnPositions ) )
+              if( this.GetVisibleColumnsVisiblePositionForDataGridContext( childContext, exportedColumnPositions ) )
               {
                 // All columns need to be exported, stop parsing child DataGridContexts
                 break;
@@ -567,20 +614,17 @@ namespace Xceed.Wpf.DataGrid.Export
           // The detail level differs, parse the child contexts recursively
           foreach( DataGridContext childContext in dataGridContext.GetChildContexts() )
           {
-            this.GetVisiblePositionsForContextDetailLevel( childContext,
-              desiredDetailLevel,
-              exportedColumnPositions );
+            this.GetVisiblePositionsForContextDetailLevel( childContext, desiredDetailLevel, exportedColumnPositions );
           }
         }
       }
 
-      private SelectionRange[] GetSelectedItemsStoreForDataGridContext(
-        DataGridContext dataGridContext )
+      private SelectionRange[] GetSelectedItemsStoreForDataGridContext( DataGridContext dataGridContext )
       {
         if( dataGridContext == null )
           return null;
 
-        SelectedItemsStorage itemStorage = new SelectedItemsStorage( null, 16 );
+        SelectedItemsStorage itemStorage = new SelectedItemsStorage( null );
 
         foreach( SelectionRange range in dataGridContext.SelectedItemRanges )
         {
@@ -589,11 +633,12 @@ namespace Xceed.Wpf.DataGrid.Export
 
         foreach( SelectionCellRange range in dataGridContext.SelectedCellRanges )
         {
-          SelectionRangeWithItems itemRange =
-            new SelectionRangeWithItems( range.ItemRange, null );
+          SelectionRangeWithItems itemRange = new SelectionRangeWithItems( range.ItemRange, null );
 
           if( !itemStorage.Contains( itemRange ) )
+          {
             itemStorage.Add( itemRange );
+          }
         }
 
         SelectionRange[] itemStorageArray = itemStorage.ToSelectionRangeArray();
@@ -602,22 +647,21 @@ namespace Xceed.Wpf.DataGrid.Export
         return itemStorageArray;
       }
 
-      private bool GetVisibleColumnsVisiblePositionForDataGridContext(
-        DataGridContext dataGridContext,
-        HashSet<int> exportedColumnPositions )
+      private bool GetVisibleColumnsVisiblePositionForDataGridContext( DataGridContext dataGridContext, HashSet<int> exportedColumnPositions )
       {
         if( dataGridContext == null )
           return false;
 
         if( exportedColumnPositions == null )
+        {
           exportedColumnPositions = new HashSet<int>();
+        }
 
         // At least 1 row was completely selected, add
         // all VisibleColumns' VisiblePosition 
         if( dataGridContext.SelectedItemRanges.Count > 0 )
         {
-          this.GetAllVisibleColumnsVisiblePosition( dataGridContext,
-            ref exportedColumnPositions );
+          this.GetAllVisibleColumnsVisiblePosition( dataGridContext, ref exportedColumnPositions );
 
           // Ensure to set the allColumnExported
           return true;
@@ -641,7 +685,9 @@ namespace Xceed.Wpf.DataGrid.Export
           for( int i = startIndex; i <= endIndex; i++ )
           {
             if( !exportedColumnPositions.Contains( i ) )
+            {
               exportedColumnPositions.Add( i );
+            }
           }
         }
 
@@ -657,7 +703,9 @@ namespace Xceed.Wpf.DataGrid.Export
           while( m_currentIndentationLevel < detailLevel )
           {
             foreach( ClipboardExporterBase clipboardExporter in m_clipboardExporters )
+            {
               clipboardExporter.Indent();
+            }
 
             Debug.Indent();
             m_currentIndentationLevel++;
@@ -670,7 +718,9 @@ namespace Xceed.Wpf.DataGrid.Export
           while( m_currentIndentationLevel > detailLevel )
           {
             foreach( ClipboardExporterBase clipboardExporter in m_clipboardExporters )
+            {
               clipboardExporter.Unindent();
+            }
 
             Debug.Unindent();
             m_currentIndentationLevel--;
@@ -682,8 +732,6 @@ namespace Xceed.Wpf.DataGrid.Export
         return false;
       }
 
-      #endregion PRIVATE METHODS
-
       #region IDisposable Members
 
       public void Dispose()
@@ -696,135 +744,12 @@ namespace Xceed.Wpf.DataGrid.Export
 
       #endregion IDisposable Members
 
-      #region PRIVATE FIELDS
-
       private Dictionary<Column, BindingPathValueExtractor> m_columnToBindingPathExtractor; // = null;
       private Dictionary<int, int[]> m_visitedDetailExportedVisiblePositions; // = null; 
       private Dictionary<int, ColumnBase[]> m_visitedDetailVisibleColumnsCache; // = null; 
       private List<ClipboardExporterBase> m_clipboardExporters; // = null;
       private int m_currentIndentationLevel; // = 0;
       private int m_lastExportedHeaderDetailLevel = -1;
-
-      #endregion PRIVATE FIELDS
-
-      internal void Export( DataGridContext dataGridContext )
-      {
-        if( dataGridContext == null )
-          return;
-
-        // Get the detail level for the current DataGridContext
-        int detailLevel = dataGridContext.DetailLevel;
-
-        // Update indentation of ClipboardExporters for this detail level
-        this.UpdateExporterIndentation( detailLevel );
-
-        // Get master indexes that have mapped expanded details
-        List<int> indexesToMasterItemList =
-          dataGridContext.CustomItemContainerGenerator.GetMasterIndexexWithExpandedDetails();
-
-        // Get the index of the next detail to export in case
-        // it is expanded before the first selected index of the
-        // current dataGridContext
-        int nextDetailIndex = ( indexesToMasterItemList.Count > 0 )
-          ? indexesToMasterItemList[ 0 ]
-          : -1;
-
-        // Get informations on columns, visible positions and selected item indexes
-        // for this dataGridContext
-        int[] exportedVisiblePositions = this.GetVisiblePositionsForContext( dataGridContext );
-        ColumnBase[] columnsByVisiblePosition = this.GetVisibleColumnsArrayForContext( dataGridContext );
-        SelectionRange[] selectedItemsRanges = this.GetSelectedItemsStoreForDataGridContext( dataGridContext );
-
-        Debug.Assert( exportedVisiblePositions != null );
-        Debug.Assert( columnsByVisiblePosition != null );
-        Debug.Assert( selectedItemsRanges != null );
-
-        int selectedItemsRangesCount = selectedItemsRanges.Length;
-
-        // Ensure to flag the exporter has items
-        this.HasItems |= ( selectedItemsRangesCount > 0 );
-
-        for( int i = 0; i < selectedItemsRangesCount; i++ )
-        {
-          // For the first level, ensure to export the headers
-          // before anything else
-          if( detailLevel == 0 )
-          {
-            this.ExportHeaders( dataGridContext,
-              detailLevel,
-              exportedVisiblePositions,
-              columnsByVisiblePosition );
-          }
-
-          SelectionRange range = selectedItemsRanges[ i ];
-
-          int startIndex = range.StartIndex;
-          int endIndex = range.EndIndex;
-
-          // If range is inverted
-          if( startIndex > endIndex )
-          {
-            startIndex = range.EndIndex;
-            endIndex = range.StartIndex;
-          }
-
-          // For each index in the range
-          for( int itemIndex = startIndex; itemIndex <= endIndex; itemIndex++ )
-          {
-            // Export details that are before the itemIndex
-            while( ( nextDetailIndex != -1 ) && ( itemIndex > nextDetailIndex ) )
-            {
-              this.ExportDetailForMasterIndex( dataGridContext,
-                detailLevel,
-                nextDetailIndex );
-
-              // Remove it since the detail is processed
-              indexesToMasterItemList.Remove( nextDetailIndex );
-
-              nextDetailIndex = ( indexesToMasterItemList.Count > 0 )
-                ? indexesToMasterItemList[ 0 ]
-                : -1;
-            }
-
-            // Ensure to re-export the headers if a detail was previously exported
-            this.ExportHeaders( dataGridContext,
-              detailLevel,
-              exportedVisiblePositions,
-              columnsByVisiblePosition );
-
-            object exportedItem = dataGridContext.Items.GetItemAt( itemIndex );
-
-            this.ExportDataItem( dataGridContext,
-              itemIndex,
-              exportedItem,
-              detailLevel,
-              exportedVisiblePositions,
-              columnsByVisiblePosition );
-          }
-        }
-
-        nextDetailIndex = ( indexesToMasterItemList.Count > 0 )
-            ? indexesToMasterItemList[ 0 ]
-            : -1;
-
-        // Export all remaining details since none are before the context's
-        // selected index ranges
-        while( nextDetailIndex != -1 )
-        {
-          this.ExportDetailForMasterIndex( dataGridContext,
-            detailLevel,
-            nextDetailIndex );
-
-          // Remove it since the detail is processed
-          indexesToMasterItemList.Remove( nextDetailIndex );
-
-          nextDetailIndex = ( indexesToMasterItemList.Count > 0 )
-            ? indexesToMasterItemList[ 0 ]
-            : -1;
-        }
-      }
     }
-
-    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/FormatHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/FormatHelper.cs
index fc1a7df7..65ee071e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/FormatHelper.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Export/FormatHelper.cs
@@ -147,41 +147,6 @@ namespace Xceed.Wpf.DataGrid.Export
       return outputString;
     }
 
-    public static void FormatHtmlData( StringBuilder htmlDataStringBuilder )
-    {
-      string htmlDataString = htmlDataStringBuilder.ToString();
-
-      StringBuilder headerStringBuilder = new StringBuilder();
-      headerStringBuilder.Append( "Version:1.0" );
-      headerStringBuilder.Append( Environment.NewLine );
-      headerStringBuilder.Append( "StartHTML:-1" ); // This is optional according to MSDN documentation
-      headerStringBuilder.Append( Environment.NewLine );
-      headerStringBuilder.Append( "EndHTML:-1" ); // This is optional according to MSDN documentation
-      headerStringBuilder.Append( Environment.NewLine );
-      headerStringBuilder.Append( "StartFragment:0000000109" ); // Always 109 bytes from start of Version to the end of <!--StartFragment--> tag
-      headerStringBuilder.Append( Environment.NewLine );
-      headerStringBuilder.Append( "EndFragment:{0}" ); // need + 7 to "emulate" the 10 digits ( "{x}" is already 3 of the 10 chars )
-      headerStringBuilder.Append( Environment.NewLine );
-      headerStringBuilder.Append( "<!--StartFragment-->" );
-
-      // We assure the StartFramgment offset is correct
-      string headerString = headerStringBuilder.ToString();
-      int startFragmentByteCounts = headerString.Length + 7; //  +7 chars as mentionned above
-      Debug.Assert( startFragmentByteCounts == 109 );
-
-      // Compute the EndFragment offset => header size + html data size + final end line (after data) length (\r\n)
-      int endFragmentByteCounts = startFragmentByteCounts + htmlDataString.Length + Environment.NewLine.Length;
-      string endFragmentOffset = endFragmentByteCounts.ToString( "0000000000", CultureInfo.InvariantCulture );
-      headerString = string.Format( CultureInfo.InvariantCulture, headerString, endFragmentOffset );
-
-      // Insert header at the beginning of the htmlDataStringBuilder
-      htmlDataStringBuilder.Insert( 0, headerString );
-
-      // Append the final end line and EndFragment tag
-      htmlDataStringBuilder.Append( Environment.NewLine );
-      htmlDataStringBuilder.Append( "<!--EndFragment-->" );
-    }
-
     public static string FormatPlainTextAsHtml( string plainText )
     {
       StringBuilder htmlStringBuilder = new StringBuilder();
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FieldNameMap.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FieldNameMap.cs
new file mode 100644
index 00000000..8e6109ab
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FieldNameMap.cs
@@ -0,0 +1,77 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class FieldNameMap
+  {
+    public bool TryGetColumnFieldName( string name, out string columnName )
+    {
+      return this.TryGetTarget( name, out columnName );
+    }
+
+    public bool TryGetColumnFieldName( ColumnBase column, out string columnName )
+    {
+      if( column != null )
+        return this.TryGetTarget( column.FieldName, out columnName );
+
+      columnName = null;
+
+      return false;
+    }
+
+    public bool TryGetColumnFieldName( SortDescription sortDescription, out string columnName )
+    {
+      return this.TryGetTarget( sortDescription.PropertyName, out columnName );
+    }
+
+    public bool TryGetItemPropertyName( string name, out string itemPropertyName )
+    {
+      return this.TryGetSource( name, out itemPropertyName );
+    }
+
+    public bool TryGetItemPropertyName( ColumnBase column, out string itemPropertyName )
+    {
+      if( column != null )
+        return this.TryGetSource( column.FieldName, out itemPropertyName );
+
+      itemPropertyName = null;
+
+      return false;
+    }
+
+    public bool TryGetItemPropertyName( SortDescription sortDescription, out string itemPropertyName )
+    {
+      return this.TryGetSource( sortDescription.PropertyName, out itemPropertyName );
+    }
+
+    protected virtual bool TryGetSource( string targetName, out string sourceName )
+    {
+      sourceName = targetName;
+
+      return !string.IsNullOrEmpty( targetName );
+    }
+
+    protected virtual bool TryGetTarget( string sourceName, out string targetName )
+    {
+      targetName = sourceName;
+
+      return !string.IsNullOrEmpty( sourceName );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/AndFilterCriterion.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/AndFilterCriterion.cs
index 0e15ef1c..1e7e6c11 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/AndFilterCriterion.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/AndFilterCriterion.cs
@@ -199,11 +199,10 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
       Debug.Assert( parameters.Length == 2, "Should have been caught earlier during BuildCriterion." );
 
       if( parameters.Length != 2 )
-        throw new DataGridInternalException( "Missing operand for the AND operator." ); 
+        throw new DataGridInternalException( "Missing operand for the AND operator." );
 
       this.FirstFilterCriterion = FilterParser.ProduceCriterion( parameters[ 0 ], defaultComparisonFilterCriterionType );
       this.SecondFilterCriterion = FilterParser.ProduceCriterion( parameters[ 1 ], defaultComparisonFilterCriterionType );
     }
-
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/EndsWithFilterCriterion.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/EndsWithFilterCriterion.cs
index b7e02434..d8675daa 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/EndsWithFilterCriterion.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/EndsWithFilterCriterion.cs
@@ -24,7 +24,7 @@ using System.Globalization;
 
 namespace Xceed.Wpf.DataGrid.FilterCriteria
 {
-  [CriterionDescriptor( "*@", FilterOperatorPrecedence.RelationalOperator, FilterTokenPriority.RelationalOperator)]
+  [CriterionDescriptor( "*@", FilterOperatorPrecedence.RelationalOperator, FilterTokenPriority.RelationalOperator )]
   [DebuggerDisplay( "EndsWith( {Value} )" )]
   public class EndsWithFilterCriterion : RelationalFilterCriterion
   {
@@ -45,7 +45,6 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
       return ( strValue == null ) ? "" : "*" + strValue;
     }
 
-    // TODO: to be tested
     public override Expression ToLinqExpression( IQueryable queryable, ParameterExpression parameterExpression, string propertyName )
     {
       if( queryable == null )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterCriterion.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterCriterion.cs
index 52fc32e8..ceeec6cd 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterCriterion.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterCriterion.cs
@@ -22,7 +22,7 @@ using System.Linq;
 
 namespace Xceed.Wpf.DataGrid.FilterCriteria
 {
-  [ CriterionDescriptor( "", FilterOperatorPrecedence.Default, FilterTokenPriority.Default ) ]
+  [CriterionDescriptor( "", FilterOperatorPrecedence.Default, FilterTokenPriority.Default )]
   public abstract class FilterCriterion : INotifyPropertyChanged
   {
 #if DEBUG
@@ -67,7 +67,7 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
 
     public abstract bool IsMatch( object value );
 
-    public abstract string ToExpression( CultureInfo culture);
+    public abstract string ToExpression( CultureInfo culture );
 
     public abstract Expression ToLinqExpression( IQueryable queryable, ParameterExpression parameterExpression, string propertyName );
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterExpressionHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterExpressionHelper.cs
new file mode 100644
index 00000000..ca593616
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/FilterExpressionHelper.cs
@@ -0,0 +1,108 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.FilterCriteria
+{
+  internal class FilterExpressionHelper
+  {
+    #region LastValue Property
+
+    internal static long LastValue
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region IsConsecutive Property
+
+    internal static bool IsConsecutive
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region GreaterThanAdded Property
+
+    internal static bool GreaterThanAdded
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    internal static string BuildExpressionFromIntValue( string expression, long currentValue )
+    {
+      //If we have an int value, let's try to find ranges of values, in oreder to build a more efficent expression than having all values separated by an OR criterion.
+      if( currentValue - 1 < FilterExpressionHelper.LastValue )
+      {
+        expression = currentValue.ToString();
+      }
+      else if( currentValue - 1 > FilterExpressionHelper.LastValue )
+      {
+        if( FilterExpressionHelper.IsConsecutive )
+        {
+          expression += " AND <" + ( FilterExpressionHelper.LastValue + 1 ).ToString() + " OR " + currentValue.ToString();
+          FilterExpressionHelper.IsConsecutive = false;
+        }
+        else
+        {
+          expression += " OR " + currentValue.ToString();
+        }
+        FilterExpressionHelper.GreaterThanAdded = false;
+      }
+      else if( currentValue - 1 == FilterExpressionHelper.LastValue )
+      {
+        if( !FilterExpressionHelper.GreaterThanAdded )
+        {
+          expression = expression.Remove( expression.IndexOf( FilterExpressionHelper.LastValue.ToString() ) );
+          expression += ">" + ( FilterExpressionHelper.LastValue - 1 ).ToString();
+          FilterExpressionHelper.GreaterThanAdded = true;
+        }
+        FilterExpressionHelper.IsConsecutive = true;
+      }
+
+      FilterExpressionHelper.LastValue = currentValue;
+
+      return expression;
+    }
+
+    internal static bool GetIsIntValuePathType( Type valuePathDataType )
+    {
+      return valuePathDataType == typeof( sbyte ) ||
+             valuePathDataType == typeof( byte ) ||
+             valuePathDataType == typeof( short ) ||
+             valuePathDataType == typeof( ushort ) ||
+             valuePathDataType == typeof( int ) ||
+             valuePathDataType == typeof( uint ) ||
+             valuePathDataType == typeof( long ) ||
+             valuePathDataType == typeof( ulong );
+    }
+  }
+
+  internal class EmptyCriterionObject
+  {
+    internal EmptyCriterionObject()
+    {
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/OrFilterCriterion.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/OrFilterCriterion.cs
index 96544b74..34523662 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/OrFilterCriterion.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/OrFilterCriterion.cs
@@ -136,7 +136,7 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
         throw new ArgumentException( "PropertyName must not be empty.", "propertyName" );
       }
 
-      System.Linq.Expressions.Expression firstFilterLINQExpression = 
+      System.Linq.Expressions.Expression firstFilterLINQExpression =
         ( m_firstFilterCriterion == null ) ? null : m_firstFilterCriterion.ToLinqExpression( queryable, parameterExpression, propertyName );
 
       System.Linq.Expressions.Expression secondFilterLINQExpression =
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/RelationalFilterCriterion.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/RelationalFilterCriterion.cs
index bff39a05..094f2859 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/RelationalFilterCriterion.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/RelationalFilterCriterion.cs
@@ -64,7 +64,7 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
     private object m_value;
     private IComparable m_comparableValue;
 
-    #endregion Value Property
+    #endregion
 
     public override bool Equals( object obj )
     {
@@ -169,10 +169,10 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
       if( parameters.Length != 1 )
         throw new DataGridException( string.Format( FilterParser.MissingRightOperandErrorText, this.GetType().Name ) );
 
-      Debug.Assert( !( parameters[ 0 ] is FilterCriterion), "Should have been caught earlier during BuildCriterion." );
+      Debug.Assert( !( parameters[ 0 ] is FilterCriterion ), "Should have been caught earlier during BuildCriterion." );
 
       if( parameters[ 0 ] is FilterCriterion )
-        throw new DataGridInternalException( "Comparison with the result of a filter criterion is not allowed." ); 
+        throw new DataGridInternalException( "Comparison with the result of a filter criterion is not allowed." );
 
       this.Value = parameters[ 0 ];
     }
@@ -185,7 +185,7 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
     {
       object value2 = this.Value;
 
-      if( ( value == null ) || ( value == DBNull.Value ) || (value as string == string.Empty) )
+      if( ( value == null ) || ( value == DBNull.Value ) || ( value as string == string.Empty ) )
       {
         if( ( value2 == null ) || ( value2 == DBNull.Value ) || ( ( value2 as string ) == string.Empty ) )
         {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/StartsWithFilterCriterion.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/StartsWithFilterCriterion.cs
index 200374d0..4ebc046f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/StartsWithFilterCriterion.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterCriteria/StartsWithFilterCriterion.cs
@@ -45,7 +45,6 @@ namespace Xceed.Wpf.DataGrid.FilterCriteria
       return ( strValue == null ) ? "" : strValue + "*";
     }
 
-    // TODO: to be tested
     public override Expression ToLinqExpression( IQueryable queryable, ParameterExpression parameterExpression, string propertyName )
     {
       if( queryable == null )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterParser.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterParser.cs
index 919bb6e7..3ded1d98 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterParser.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FilterParser.cs
@@ -20,7 +20,6 @@ using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.Text;
-
 using Xceed.Wpf.DataGrid.FilterCriteria;
 
 namespace Xceed.Wpf.DataGrid
@@ -77,20 +76,8 @@ namespace Xceed.Wpf.DataGrid
     // If culture is null, CurrentThread.CurrentCulture will be used when necessary.
     public static FilterCriterion Parse( string expression, Type dataType, CultureInfo culture )
     {
-     FilterCriterion filterCriterion = null;
-      List<Token> tokens = new List<Token>();
-
-      FilterParser.LastError = null;
-
-      FilterParser.PrepareExpressionTokens( expression, tokens );
-
-      Type defaultCriterionType = ( dataType == typeof( string ) ) ? typeof( ContainsFilterCriterion ) : typeof( EqualToFilterCriterion );
-
-      FilterParser.Tokenize( tokens, dataType, defaultCriterionType );
-      FilterParser.TrimTokens( tokens );
-      filterCriterion = FilterParser.BuildCriterion( tokens, dataType, defaultCriterionType, culture );
-
-      return filterCriterion;
+      List<Token> tokens = FilterParser.GetTokens( expression, dataType );
+      return FilterParser.BuildCriterion( tokens, dataType, FilterParser.GetDefaultCriterionType( dataType ), culture );
     }
 
     public static FilterCriterion TryParse( string expression, Type dataType, CultureInfo culture )
@@ -110,6 +97,18 @@ namespace Xceed.Wpf.DataGrid
       return filterCriterion;
     }
 
+    private static List<Token> GetTokens( string expression, Type dataType )
+    {
+      List<Token> tokens = new List<Token>();
+      FilterParser.LastError = null;
+
+      FilterParser.PrepareExpressionTokens( expression, tokens );
+      FilterParser.Tokenize( tokens, dataType, FilterParser.GetDefaultCriterionType( dataType ) );
+      FilterParser.TrimTokens( tokens );
+
+      return tokens;
+    }
+
     private static void TrimTokens( List<Token> tokens )
     {
       RawToken rawToken;
@@ -148,7 +147,9 @@ namespace Xceed.Wpf.DataGrid
         CriterionDescriptorAttribute attribute = ( CriterionDescriptorAttribute )type.GetCustomAttributes( typeof( CriterionDescriptorAttribute ), true )[ 0 ];
 
         if( !parserPriorities.Contains( ( int )attribute.ParserPriority ) )
+        {
           parserPriorities.Add( ( int )attribute.ParserPriority );
+        }
       }
 
       parserPriorities.Sort();
@@ -189,7 +190,7 @@ namespace Xceed.Wpf.DataGrid
           quotesEnd++;
         }
 
-        if( ( (( quotesEnd - quoteIndex > 1 ) && ( quoteOpened ) ) ) )
+        if( ( ( ( quotesEnd - quoteIndex > 1 ) && ( quoteOpened ) ) ) )
         {
           // Transform the " couples to a single ".
           StringBuilder temp = new StringBuilder( expression.Substring( 0, quoteIndex ) );
@@ -197,7 +198,7 @@ namespace Xceed.Wpf.DataGrid
           for( int i = 0; i < ( quotesEnd - quoteIndex ) / 2; i++ )
           {
             temp.Append( '"' );
-            quotesCounter++ ;
+            quotesCounter++;
           }
           temp.Append( expression.Substring( quotesEnd ) );
 
@@ -329,7 +330,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    //private static bool ExtractFirstCriterion( List<Token> rawTokens, int tokenIndex, int parserPriority, out FilterCriterionToken filterToken, out int startIndex, out int length )
     private static bool ExtractFirstCriterion( Token precedentToken, RawToken rawToken, int parserPriority, out FilterCriterionToken filterToken, out int startIndex, out int length )
     {
       //RawToken rawToken = rawTokens[ tokenIndex ] as RawToken;
@@ -570,6 +570,11 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private static Type GetDefaultCriterionType( Type dataType )
+    {
+      return dataType == typeof( string ) ? typeof( ContainsFilterCriterion ) : typeof( EqualToFilterCriterion );
+    }
+
     private static CriterionTypeCollection RegisteredFilterCriterionTypes = new CriterionTypeCollection();
     private static string LastErrorString = null;
     internal static string MissingClosingQuotesErrorText = "Missing closing quotes.";
@@ -577,10 +582,10 @@ namespace Xceed.Wpf.DataGrid
     internal static string MissingLeftOperandErrorText = "Missing left operand for filter {0}.";
     internal static string InvalidExpressionErrorText = "The expression cannot be resolved. Are you missing a logical operator?";
     internal static string InvalidCharValueErrorText = "{0} is not a valid character value.";
-    internal static string InvalidDateTimeValueErrorText = "Invalid date/time value. It is recommended to use the following format: yyyy-MM-ddTHH:mm:ss.fff."; 
+    internal static string InvalidDateTimeValueErrorText = "Invalid date/time value. It is recommended to use the following format: yyyy-MM-ddTHH:mm:ss.fff.";
     internal static string InvalidNumberFormatErrorText = "Invalid number format.";
-    internal static string InvalidEnumValueErrorText = "Invalid enum value."; 
-    internal static string NumberOverflowErrorText = "Number value is out of range."; 
+    internal static string InvalidEnumValueErrorText = "Invalid enum value.";
+    internal static string NumberOverflowErrorText = "Number value is out of range.";
 
     #region CriterionTypeCollection Nested Type
 
@@ -589,7 +594,7 @@ namespace Xceed.Wpf.DataGrid
       protected override void InsertItem( int index, Type item )
       {
         if( !typeof( FilterCriterion ).IsAssignableFrom( item ) )
-          throw new ArgumentException( "Must be derived from FilterCriterion.", "item" ); 
+          throw new ArgumentException( "Must be derived from FilterCriterion.", "item" );
 
         if( item.GetCustomAttributes( typeof( CriterionDescriptorAttribute ), false ).Length == 0 )
           throw new ArgumentException( "Must have the CriterionDescriptor attribute.", "item" );
@@ -600,7 +605,7 @@ namespace Xceed.Wpf.DataGrid
       protected override void SetItem( int index, Type item )
       {
         if( !typeof( FilterCriterion ).IsAssignableFrom( item ) )
-          throw new ArgumentException( "Must be derived from FilterCriterion.", "item" ); 
+          throw new ArgumentException( "Must be derived from FilterCriterion.", "item" );
 
         if( item.GetCustomAttributes( typeof( CriterionDescriptorAttribute ), false ).Length == 0 )
           throw new ArgumentException( "Must have the CriterionDescriptor attribute.", "item" );
@@ -617,7 +622,7 @@ namespace Xceed.Wpf.DataGrid
     {
     }
 
-    #endregion Token Nested Type
+    #endregion
 
     #region ValueToken Nested Type
 
@@ -639,7 +644,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion ValueToken Nested Type
+    #endregion
 
     #region RawToken Nested Type
 
@@ -659,9 +664,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion RawToken Nested Type
+    #endregion
 
-    #region AtomicStringToken Nested Type
+    #region AtomicStringToken
 
     /// <summary>
     /// A token containing a value that will not be processed by the parser because it
@@ -679,7 +684,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion AtomicStringToken Nested Type
+    #endregion
 
     #region FilterCriterionToken Nested Type
 
@@ -701,15 +706,13 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion FilterCriterionToken Nested Type
+    #endregion
 
     #region ReferenceList Nested Type
 
     // This list will prevent the same object of being added twice.
-    // To compare objects (in IndexOf, Add, Remove and Contains), it will use the 
-    // ReferenceEquals() method.
-    // Naturally, this class won't behave properly with ValueType because
-    // of boxing.
+    // To compare objects (in IndexOf, Add, Remove and Contains), it will use the ReferenceEquals() method.
+    // Naturally, this class won't behave properly with ValueType because of boxing.
     private class ReferenceList<T> : ICollection<T>
     {
       public int IndexOf( T item )
@@ -733,7 +736,7 @@ namespace Xceed.Wpf.DataGrid
       public void Add( T item )
       {
         if( this.Contains( item ) )
-          throw new InvalidOperationException( "An attempt was made to add an item that is already contained in the list." ); 
+          throw new InvalidOperationException( "An attempt was made to add an item that is already contained in the list." );
 
         m_internalList.Add( item );
       }
@@ -804,6 +807,6 @@ namespace Xceed.Wpf.DataGrid
       private List<T> m_internalList = new List<T>();
     }
 
-    #endregion ReferenceList Nested Type
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FittedWidthRequestedEventArgs.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FittedWidthRequestedEventArgs.cs
new file mode 100644
index 00000000..7a0843c0
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/FittedWidthRequestedEventArgs.cs
@@ -0,0 +1,51 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class FittedWidthRequestedEventArgs : EventArgs
+  {
+    #region Value Internal Read-Only Property
+
+    internal Nullable<double> Value
+    {
+      get
+      {
+        return m_value;
+      }
+    }
+
+    internal void SetValue( double value )
+    {
+      if( m_value.HasValue )
+      {
+        // We keep the highest of the two values.
+        if( m_value.Value >= value )
+          return;
+      }
+
+      m_value = value;
+    }
+
+    private Nullable<double> m_value;
+
+    #endregion
+  }
+
+  internal delegate void FittedWidthRequestedEventHandler( object sender, FittedWidthRequestedEventArgs e );
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ForeignKeyConfigNotifyCollectionChangedEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ForeignKeyConfigNotifyCollectionChangedEventManager.cs
new file mode 100644
index 00000000..a30082b8
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ForeignKeyConfigNotifyCollectionChangedEventManager.cs
@@ -0,0 +1,68 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class ForeignKeyConfigNotifyCollectionChangedEventManager : WeakEventManager
+  {
+    public static void AddListener( ForeignKeyConfiguration source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( ForeignKeyConfiguration source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var configuration = ( ForeignKeyConfiguration )source;
+      configuration.NotifiyCollectionChanged += new EventHandler( this.OnNotifiyCollectionChanged );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var configuration = ( ForeignKeyConfiguration )source;
+      configuration.NotifiyCollectionChanged -= new EventHandler( this.OnNotifiyCollectionChanged );
+    }
+
+    private static ForeignKeyConfigNotifyCollectionChangedEventManager CurrentManager
+    {
+      get
+      {
+        Type managerType = typeof( ForeignKeyConfigNotifyCollectionChangedEventManager );
+        var currentManager = ( ForeignKeyConfigNotifyCollectionChangedEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new ForeignKeyConfigNotifyCollectionChangedEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    private void OnNotifiyCollectionChanged( object sender, EventArgs args )
+    {
+      this.DeliverEvent( sender, args );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GenericContentTemplateSelector.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GenericContentTemplateSelector.cs
new file mode 100644
index 00000000..a63c558f
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GenericContentTemplateSelector.cs
@@ -0,0 +1,400 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Media;
+using System.Xml;
+using Xceed.Wpf.DataGrid.Converters;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class GenericContentTemplateSelector : DataTemplateSelector
+  {
+    #region Static Fields
+
+    internal static readonly DataTemplate ForeignKeyCellContentTemplate;
+    internal static readonly DataTemplate ForeignKeyGroupValueTemplate;
+    internal static readonly DataTemplate ForeignKeyScrollTipContentTemplate;
+
+    private static readonly DataTemplate BoolTemplate;
+    private static readonly DataTemplate CommonTemplate;
+    private static readonly DataTemplate ImageTemplate;
+
+    private static readonly List<KeyValuePair<Type, WeakReference>> DefaultTemplates = new List<KeyValuePair<Type, WeakReference>>( 0 );
+
+    private static readonly GenericContentTemplateSelectorResources GenericContentTemplateResources = new GenericContentTemplateSelectorResources();
+
+    private static Func<DependencyObject, object, Type, object> FindTemplateResource; //null
+
+    #endregion
+
+    #region Constructors
+
+    static GenericContentTemplateSelector()
+    {
+      // We need to initalize the ResourceDictionary before accessing since we access
+      // it in a static constructor and will be called before the Layout was performed
+      GenericContentTemplateSelector.GenericContentTemplateResources.InitializeComponent();
+
+      GenericContentTemplateSelector.BoolTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "booleanDefaultContentTemplate" ] as DataTemplate;
+      Debug.Assert( GenericContentTemplateSelector.BoolTemplate != null );
+      GenericContentTemplateSelector.BoolTemplate.Seal();
+
+      GenericContentTemplateSelector.CommonTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "commonDefaultContentTemplate" ] as DataTemplate;
+      Debug.Assert( GenericContentTemplateSelector.CommonTemplate != null );
+      GenericContentTemplateSelector.CommonTemplate.Seal();
+
+      GenericContentTemplateSelector.ImageTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "imageDefaultContentTemplate" ] as DataTemplate;
+      Debug.Assert( GenericContentTemplateSelector.ImageTemplate != null );
+      GenericContentTemplateSelector.ImageTemplate.Seal();
+
+      GenericContentTemplateSelector.ForeignKeyCellContentTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "foreignKeyDefaultContentTemplate" ] as DataTemplate;
+      Debug.Assert( GenericContentTemplateSelector.ForeignKeyCellContentTemplate != null );
+      GenericContentTemplateSelector.ForeignKeyCellContentTemplate.Seal();
+
+      GenericContentTemplateSelector.ForeignKeyGroupValueTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "foreignKeyGroupValueDefaultContentTemplate" ] as DataTemplate;
+      Debug.Assert( GenericContentTemplateSelector.ForeignKeyGroupValueTemplate != null );
+      GenericContentTemplateSelector.ForeignKeyGroupValueTemplate.Seal();
+
+      GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate = GenericContentTemplateSelector.GenericContentTemplateResources[ "foreignKeyScrollTipDefaultContentTemplate" ] as DataTemplate;
+      Debug.Assert( GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate != null );
+      GenericContentTemplateSelector.ForeignKeyScrollTipContentTemplate.Seal();
+    }
+
+    private GenericContentTemplateSelector()
+    {
+    }
+
+    #endregion
+
+    #region Instance Static Property
+
+    public static GenericContentTemplateSelector Instance
+    {
+      get
+      {
+        return m_instance;
+      }
+    }
+
+    private static GenericContentTemplateSelector m_instance = new GenericContentTemplateSelector();
+
+    #endregion
+
+    public override DataTemplate SelectTemplate( object item, DependencyObject container )
+    {
+      if( item == null )
+        return base.SelectTemplate( item, container );
+
+      DataTemplate template = null;
+
+      if( ( item is byte[] ) || ( item is System.Drawing.Image ) )
+      {
+        bool useImageTemplate = false;
+
+        try
+        {
+          var converter = new ImageConverter();
+          useImageTemplate = ( converter.Convert( item, typeof( ImageSource ), null, CultureInfo.CurrentCulture ) != null );
+        }
+        catch( NotSupportedException )
+        {
+          //suppress the exception, the byte[] is not an image. convertedValue will remain null
+        }
+
+        if( useImageTemplate )
+        {
+          template = GenericContentTemplateSelector.GetImageTemplate( container );
+        }
+      }
+      else if( item is ImageSource )
+      {
+        template = GenericContentTemplateSelector.GetImageTemplate( container );
+      }
+      else if( item is bool )
+      {
+        template = GenericContentTemplateSelector.BoolTemplate;
+      }
+
+      if( template == null )
+      {
+        template = GenericContentTemplateSelector.GetCommonTemplate( item, container );
+      }
+
+      if( template != null )
+        return template;
+
+      return base.SelectTemplate( item, container );
+    }
+
+    private static DataTemplate GetImageTemplate( DependencyObject container )
+    {
+      return GenericContentTemplateSelector.ImageTemplate;
+    }
+
+    private static DataTemplate GetCommonTemplate( object item, DependencyObject container )
+    {
+      Debug.Assert( item != null );
+
+      var itemType = item.GetType();
+
+      // Do not provide a template for data types that are already optimized by the framework or
+      // for data types that have a default template.
+      if( GenericContentTemplateSelector.IsTypeOptimized( itemType )
+        || GenericContentTemplateSelector.HasImplicitTemplate( item, itemType, container ) )
+        return null;
+
+      return GenericContentTemplateSelector.GetDefaultTemplate( itemType );
+    }
+
+    private static DataTemplate GetDefaultTemplate( Type type )
+    {
+      Debug.Assert( type != null );
+
+      var converter = TypeDescriptor.GetConverter( type );
+      if( ( converter == null ) || ( !converter.CanConvertTo( typeof( string ) ) ) )
+        return GenericContentTemplateSelector.CommonTemplate;
+
+      var templates = GenericContentTemplateSelector.DefaultTemplates;
+      lock( ( ( ICollection )templates ).SyncRoot )
+      {
+        for( int i = templates.Count - 1; i >= 0; i-- )
+        {
+          var target = templates[ i ];
+          var targetTemplate = target.Value.Target as DataTemplate;
+
+          // We have found the desired template.
+          if( target.Key == type )
+          {
+            if( targetTemplate != null )
+              return targetTemplate;
+
+            // Unfortunately, the template has been garbage collected.
+            templates.RemoveAt( i );
+            break;
+          }
+        }
+
+        templates.TrimExcess();
+
+        var template = GenericContentTemplateSelector.CreateDefaultTemplate( type, converter );
+
+        templates.Add( new KeyValuePair<Type, WeakReference>( type, new WeakReference( template ) ) );
+
+        return template;
+      }
+    }
+
+    private static DataTemplate CreateDefaultTemplate( Type type, TypeConverter converter )
+    {
+      Debug.Assert( type != null );
+      Debug.Assert( converter != null );
+
+      var template = new DataTemplate();
+      var factory = new FrameworkElementFactory( typeof( TextBlock ) );
+
+      var binding = new Binding();
+      binding.Mode = BindingMode.OneWay;
+      binding.Converter = new DefaultConverter( converter );
+      binding.ConverterCulture = CultureInfo.CurrentCulture;
+
+      factory.SetBinding( TextBlock.TextProperty, binding );
+
+      template.VisualTree = factory;
+      template.Seal();
+
+      return template;
+    }
+
+    private static bool IsTypeOptimized( Type type )
+    {
+      Debug.Assert( type != null );
+
+      if( typeof( string ).IsAssignableFrom( type )
+        || typeof( UIElement ).IsAssignableFrom( type )
+        || typeof( XmlNode ).IsAssignableFrom( type ) )
+        return true;
+
+      if( !typeof( Inline ).IsAssignableFrom( type ) )
+      {
+        var converter = TypeDescriptor.GetConverter( type );
+        if( ( converter != null ) && ( converter.CanConvertTo( typeof( UIElement ) ) ) )
+          return true;
+      }
+
+      return false;
+    }
+
+    private static bool HasImplicitTemplate( object item, Type type, DependencyObject container )
+    {
+      Debug.Assert( type != null );
+
+      var finder = GenericContentTemplateSelector.FindTemplateResource;
+
+      if( finder == null )
+      {
+        finder = GenericContentTemplateSelector.GetFindTemplateResourceInternal();
+
+        if( finder == null )
+        {
+          finder = GenericContentTemplateSelector.FindTemplateResourceFallback;
+        }
+
+        GenericContentTemplateSelector.FindTemplateResource = finder;
+      }
+
+      Debug.Assert( finder != null );
+
+      return ( finder.Invoke( container, item, type ) != null );
+    }
+
+    private static Func<DependencyObject, object, Type, object> GetFindTemplateResourceInternal()
+    {
+      try
+      {
+        var methodInfo = typeof( FrameworkElement ).GetMethod(
+                           "FindTemplateResourceInternal",
+                           BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static,
+                           null,
+                           CallingConventions.Any,
+                           new Type[] { typeof( DependencyObject ), typeof( object ), typeof( Type ) },
+                           null );
+
+        if( methodInfo != null )
+        {
+          var finder = ( Func<DependencyObject, object, Type, object> )Delegate.CreateDelegate( typeof( Func<DependencyObject, object, Type, object> ), methodInfo );
+
+          return ( container, item, type ) => finder.Invoke( container, item, typeof( DataTemplate ) );
+        }
+      }
+      catch( AmbiguousMatchException )
+      {
+        // We swallow the exception and use a fallback method instead.
+      }
+      catch( MethodAccessException )
+      {
+        // We swallow the exception and use a fallback method instead.
+      }
+
+      return null;
+    }
+
+    private static object FindTemplateResourceFallback( DependencyObject container, object item, Type type )
+    {
+      var fe = container as FrameworkElement;
+      if( fe == null )
+        return null;
+
+      return fe.TryFindResource( new DataTemplateKey( type ) );
+    }
+
+    #region DefaultConverter Private Class
+
+    private sealed class DefaultConverter : IValueConverter
+    {
+      internal DefaultConverter( TypeConverter converter )
+      {
+        if( converter == null )
+          throw new ArgumentNullException( "converter" );
+
+        m_converter = converter;
+      }
+
+      public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
+      {
+        object result;
+
+        if( DefaultConverter.TryConvertTo( value, targetType, culture, m_converter, out result ) )
+          return result;
+
+        if( value != null )
+        {
+          var valueType = value.GetType();
+
+          if( DefaultConverter.TryConvertTo( value, targetType, culture, TypeDescriptor.GetConverter( valueType ), out result ) )
+            return result;
+
+          if( targetType.IsAssignableFrom( valueType ) )
+            return value;
+        }
+        else if( DefaultConverter.IsNullableType( targetType ) )
+        {
+          return value;
+        }
+
+        throw new ArgumentException( "Cannot convert to type " + targetType.FullName + ".", "value" );
+      }
+
+      public object ConvertBack( object value, Type targetType, object parameter, CultureInfo culture )
+      {
+        throw new NotSupportedException();
+      }
+
+      private static bool TryConvertTo( object value, Type targetType, CultureInfo culture, TypeConverter converter, out object result )
+      {
+        if( converter != null )
+        {
+          try
+          {
+            result = converter.ConvertTo( null, culture, value, targetType );
+            return true;
+          }
+          catch
+          {
+            // We'll try to convert the value another way.
+          }
+
+          if( ( value != null ) && ( converter.CanConvertFrom( value.GetType() ) ) )
+          {
+            try
+            {
+              var newValue = converter.ConvertFrom( null, culture, value );
+              result = converter.ConvertTo( null, culture, newValue, targetType );
+
+              return true;
+            }
+            catch
+            {
+            }
+          }
+        }
+
+        result = null;
+        return false;
+      }
+
+      private static bool IsNullableType( Type type )
+      {
+        return ( !type.IsValueType )
+            || ( type.IsGenericType && ( type.GetGenericTypeDefinition() == typeof( Nullable<> ) ) );
+      }
+
+      private readonly TypeConverter m_converter;
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GlobalSuppressions.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GlobalSuppressions.cs
index f43d76a5..caef2c8a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GlobalSuppressions.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GlobalSuppressions.cs
@@ -57,13 +57,6 @@ using System.Diagnostics.CodeAnalysis;
   Scope = "namespace", 
   Target = "Xceed.Utils.Wpf.Markup" )]
 
-[assembly: SuppressMessage( 
-  "Microsoft.Security", 
-  "CA2116:AptcaMethodsShouldOnlyCallAptcaMethods", 
-  Scope = "member", 
-  Target = "Xceed.Wpf.DataGrid.Print.DataGridPaginator.InitializeSettings(System.Printing.PrintQueue,System.Printing.PrintTicket):System.Void",
-  Justification = "A permission demand for FullTrust has been added to InitializeSettings()." )]
-
 [assembly: SuppressMessage( 
   "Microsoft.Design", 
   "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", 
@@ -210,12 +203,6 @@ using System.Diagnostics.CodeAnalysis;
   Scope = "member", 
   Target = "Xceed.Wpf.DataGrid.Views.ScrollingCellsDecorator..ctor(Xceed.Wpf.DataGrid.Views.FixedCellPanel)" )]
 
-[assembly: SuppressMessage( 
-  "Microsoft.Usage", 
-  "CA2214:DoNotCallOverridableMethodsInConstructors", 
-  Scope = "member", 
-  Target = "Xceed.Wpf.DataGrid.Print.DataGridPageControl..ctor(Xceed.Wpf.DataGrid.DataGridControl)" )]
-
 [assembly: SuppressMessage( 
   "Microsoft.Usage", 
   "CA2214:DoNotCallOverridableMethodsInConstructors", 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Group.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Group.cs
index ab7aa123..9faa51bc 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Group.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Group.cs
@@ -17,22 +17,41 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Text;
 using System.Collections.ObjectModel;
-using System.Windows.Data;
-using System.Windows.Controls.Primitives;
 using System.ComponentModel;
+using System.Globalization;
+using System.Threading;
 using System.Windows;
 using System.Windows.Controls;
+using System.Windows.Data;
 using Xceed.Wpf.DataGrid.Automation;
-using System.Windows.Automation.Peers;
-using System.Windows.Automation;
+using Xceed.Wpf.DataGrid.Utils;
+using System.Linq;
 
 namespace Xceed.Wpf.DataGrid
 {
-  public class Group : INotifyPropertyChanged
+  public class Group : IGroupLevelDescription, INotifyPropertyChanged
   {
-    internal Group( GroupGeneratorNode node, CollectionViewGroup group, IList<GroupLevelDescription> groupLevelDescriptions, DataGridContext dataGridContext )
+    #region Static Fields
+
+    private static readonly string IsExpandedPropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.IsExpanded );
+    private static readonly string ItemCountPropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.ItemCount );
+    private static readonly string GroupByPropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.GroupBy );
+    private static readonly string TitlePropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.Title );
+    private static readonly string TitleTemplatePropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.TitleTemplate );
+    private static readonly string TitleTemplateSelectorPropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.TitleTemplateSelector );
+    private static readonly string ValueTemplatePropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.ValueTemplate );
+    private static readonly string ValueTemplateSelectorPropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.ValueTemplateSelector );
+    private static readonly string ValueStringFormatPropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.ValueStringFormat );
+    private static readonly string ValueStringFormatCulturePropertyName = PropertyHelper.GetPropertyName( ( Group g ) => g.ValueStringFormatCulture );
+
+    #endregion
+
+    internal Group(
+      GroupGeneratorNode node,
+      CollectionViewGroup group,
+      LateGroupLevelDescription groupLevelDescription,
+      DataGridContext dataGridContext )
     {
       if( node == null )
         throw new ArgumentNullException( "node" );
@@ -40,27 +59,18 @@ namespace Xceed.Wpf.DataGrid
       if( group == null )
         throw new ArgumentNullException( "group" );
 
-      if( groupLevelDescriptions == null )
-        throw new ArgumentNullException( "groupLevelDescriptions" );
+      if( groupLevelDescription == null )
+        throw new ArgumentNullException( "groupLevelDescription" );
 
       if( dataGridContext == null )
         throw new ArgumentNullException( "dataGridContext" );
 
-      m_generatorNode = node;
       m_collectionViewGroup = group;
-      m_groupDescriptionsCollection = groupLevelDescriptions;
-      m_dataGridContext = dataGridContext;
 
-      //In case no late bingding is to happen, and if we already have everything to get the groupLevelDescription immediately, let's do!
-      int level = m_generatorNode.Level;
-      if( m_groupDescriptionsCollection.Count > level )
-      {
-        m_groupLevelDescription = m_groupDescriptionsCollection[ level ];
-      }
-      m_lateGroupLevelDescriptionBindingPerformed = false;
-
-      m_generatorNode.TotalLeafCountChanged += OnTotalItemCountChanged;
-      m_generatorNode.IsExpandedChanged += OnIsExpandedChanged;
+      // Initialization is done through setters to register for events.
+      this.DataGridContext = dataGridContext;
+      this.GeneratorNode = node;
+      this.GroupLevelDescription = groupLevelDescription;
     }
 
     #region IsExpanded Property
@@ -76,8 +86,10 @@ namespace Xceed.Wpf.DataGrid
       }
       set
       {
-        if( m_generatorNode != null )
-          m_generatorNode.IsExpanded = value;
+        if( m_generatorNode == null )
+          return;
+
+        m_generatorNode.IsExpanded = value;
       }
     }
 
@@ -92,7 +104,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion IsExpanded Property
+    #endregion
 
     #region Level Property
 
@@ -107,7 +119,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion Level Property
+    #endregion
 
     #region ItemCount Property
 
@@ -122,7 +134,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion ItemCount Property
+    #endregion
 
     #region ParentGroups Property
 
@@ -130,30 +142,26 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        List<Group> list = new List<Group>();
+        if( m_generatorNode == null )
+          return ( new List<Group>( 0 ) ).AsReadOnly();
 
-        if( m_generatorNode != null )
+        var list = new List<Group>();
+        var nodeHelper = new GeneratorNodeHelper( m_generatorNode, 0, 0 ); //index is not important
+
+        while( nodeHelper.MoveToParent() )
         {
-          GeneratorNodeHelper nodeHelper = new GeneratorNodeHelper( m_generatorNode, 0, 0 ); //index is not important
+          GroupGeneratorNode parentGroup = nodeHelper.CurrentNode as GroupGeneratorNode;
+          if( parentGroup == null )
+            break;
 
-          while( nodeHelper.MoveToParent() )
-          {
-            GroupGeneratorNode parentGroup = nodeHelper.CurrentNode as GroupGeneratorNode;
-            if( parentGroup != null )
-            {
-              list.Insert( 0, parentGroup.UIGroup );
-            }
-            else
-            {
-              break;
-            }
-          }
+          list.Insert( 0, parentGroup.UIGroup );
         }
+
         return list.AsReadOnly();
       }
     }
 
-    #endregion ParentGroups Property
+    #endregion
 
     #region SiblingGroups Property
 
@@ -164,18 +172,16 @@ namespace Xceed.Wpf.DataGrid
         if( m_generatorNode == null )
           return null;
 
-        HeadersFootersGeneratorNode headersFootersGeneratorNode = HeadersFootersGeneratorNode.GetSameLevelFirstHeaderNode( m_generatorNode );
-
+        var headersFootersGeneratorNode = HeadersFootersGeneratorNode.GetSameLevelFirstHeaderNode( m_generatorNode );
         if( headersFootersGeneratorNode == null )
           return null;
 
-        int currentGeneratorContentGeneration = this.DataGridContext.CustomItemContainerGenerator.CurrentGeneratorContentGeneration;
-
+        var currentGeneratorContentGeneration = this.DataGridContext.CustomItemContainerGenerator.CurrentGeneratorContentGeneration;
         return headersFootersGeneratorNode.GetImmediateUIGroups( currentGeneratorContentGeneration );
       }
     }
 
-    #endregion SiblingGroups
+    #endregion
 
     #region Value Property
 
@@ -190,7 +196,39 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion Value Property
+    #endregion
+
+    #region ValueStringFormat Property
+
+    public string ValueStringFormat
+    {
+      get
+      {
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.ValueStringFormat;
+
+        return null;
+      }
+    }
+
+    #endregion
+
+    #region ValueStringFormatCulture Property
+
+    public CultureInfo ValueStringFormatCulture
+    {
+      get
+      {
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.ValueStringFormatCulture;
+
+        return null;
+      }
+    }
+
+    #endregion
 
     #region ValueTemplate Property
 
@@ -198,18 +236,15 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        this.PerformLateGroupLevelDescriptionBinding();
-
-        if( m_groupLevelDescription != null )
-        {
-          return m_groupLevelDescription.ValueTemplate;
-        }
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.ValueTemplate;
 
         return null;
       }
     }
 
-    #endregion ValueTemplate Property
+    #endregion
 
     #region ValueTemplateSelector Property
 
@@ -217,18 +252,15 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        this.PerformLateGroupLevelDescriptionBinding();
-
-        if( m_groupLevelDescription != null )
-        {
-          return m_groupLevelDescription.ValueTemplateSelector;
-        }
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.ValueTemplateSelector;
 
         return null;
       }
     }
 
-    #endregion ValueTemplateSelector Property
+    #endregion
 
     #region IsBottomLevel Property
 
@@ -243,7 +275,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion IsBottomLevel Property
+    #endregion
 
     #region Items Property [Obsoleted]
 
@@ -261,7 +293,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion Items Property [Obsoleted]
+    #endregion
 
     #region Title Property
 
@@ -269,18 +301,15 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        this.PerformLateGroupLevelDescriptionBinding();
-
-        if( m_groupLevelDescription != null )
-        {
-          return m_groupLevelDescription.Title;
-        }
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.Title;
 
         return null;
       }
     }
 
-    #endregion Title Property
+    #endregion
 
     #region TitleTemplate Property
 
@@ -288,18 +317,15 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        this.PerformLateGroupLevelDescriptionBinding();
-
-        if( m_groupLevelDescription != null )
-        {
-          return m_groupLevelDescription.TitleTemplate;
-        }
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.TitleTemplate;
 
         return null;
       }
     }
 
-    #endregion TitleTemplate Property
+    #endregion
 
     #region TitleTemplateSelector Property
 
@@ -307,18 +333,15 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        this.PerformLateGroupLevelDescriptionBinding();
-
-        if( m_groupLevelDescription != null )
-        {
-          return m_groupLevelDescription.TitleTemplateSelector;
-        }
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.TitleTemplateSelector;
 
         return null;
       }
     }
 
-    #endregion TitleTemplateSelector Property
+    #endregion
 
     #region StatContext Property
 
@@ -330,7 +353,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion StatContext Property
+    #endregion
 
     #region GroupConfiguration Property
 
@@ -345,9 +368,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion GroupConfiguration Property
+    #endregion
 
-    #region GeneratorNode Property
+    #region GeneratorNode Internal Property
 
     internal GroupGeneratorNode GeneratorNode
     {
@@ -355,30 +378,48 @@ namespace Xceed.Wpf.DataGrid
       {
         return m_generatorNode;
       }
+      private set
+      {
+        if( value == m_generatorNode )
+          return;
+
+        if( m_generatorNode != null )
+        {
+          this.UnregisterItemCountEvent( m_generatorNode );
+          this.UnregisterIsExpandedEvent( m_generatorNode );
+        }
+
+        m_generatorNode = value;
+
+        if( m_generatorNode != null )
+        {
+          this.RegisterItemCountEvent( m_generatorNode, false );
+          this.RegisterIsExpandedEvent( m_generatorNode, false );
+        }
+      }
     }
 
-    #endregion GeneratorNode Property
+    private GroupGeneratorNode m_generatorNode; // = null
+
+    #endregion
 
-    #region GroupBy Property
+    #region GroupBy Internal Property
 
     internal string GroupBy
     {
       get
       {
-        this.PerformLateGroupLevelDescriptionBinding();
-
-        if( m_groupLevelDescription == null )
-        {
-          return string.Empty;
-        }
+        var description = this.GroupLevelDescription;
+        if( description != null )
+          return description.FieldName;
 
-        return m_groupLevelDescription.FieldName;
+        return string.Empty;
       }
     }
 
-    #endregion GroupBy Property
+    #endregion
 
-    #region DataGridContext Property
+    #region DataGridContext Internal Property
 
     internal DataGridContext DataGridContext
     {
@@ -386,150 +427,282 @@ namespace Xceed.Wpf.DataGrid
       {
         return m_dataGridContext;
       }
+      private set
+      {
+        m_dataGridContext = value;
+      }
     }
 
-    #endregion DataGridContext Property
+    private DataGridContext m_dataGridContext;
 
-    internal DataGridGroupAutomationPeer CreateAutomationPeer()
+    #endregion
+
+    #region CollectionViewGroup Internal Property
+
+    internal CollectionViewGroup CollectionViewGroup
     {
-      return new DataGridGroupAutomationPeer( this );
+      get
+      {
+        return m_collectionViewGroup;
+      }
     }
 
-    internal void ClearGroup()
+    private CollectionViewGroup m_collectionViewGroup;
+
+    #endregion
+
+    #region GroupDescription Private Property
+
+    private GroupDescription GroupDescription
     {
-      m_generatorNode.TotalLeafCountChanged -= OnTotalItemCountChanged;
-      m_generatorNode.IsExpandedChanged -= OnIsExpandedChanged;
+      get
+      {
+        return m_groupDescription;
+      }
+    }
+
+    private GroupDescription m_groupDescription;
+
+    #endregion
 
-      if( m_groupLevelDescription != null )
+    #region GroupLevelDescription Private Property
+
+    private LateGroupLevelDescription GroupLevelDescription
+    {
+      get
       {
-        m_groupLevelDescription.PropertyChanged -= GroupLevelDescriptionChangedHandler;
+        return m_groupLevelDescription;
       }
+      set
+      {
+        if( value == m_groupLevelDescription )
+          return;
 
-      m_groupLevelDescription = null;
-      m_generatorNode = null;
-      m_collectionViewGroup = null;
+        if( m_groupLevelDescription != null )
+        {
+          this.UnregisterGroupLevelDescriptionEvent( m_groupLevelDescription );
+        }
+
+        m_groupLevelDescription = value;
+
+        if( m_groupLevelDescription != null )
+        {
+          this.RegisterGroupLevelDescriptionEvent( m_groupLevelDescription, false );
+        }
+
+        this.OnGroupLevelDescriptionPropertyChanged();
+      }
     }
 
-    internal CollectionViewGroup CollectionViewGroup
+    private LateGroupLevelDescription m_groupLevelDescription;
+
+    #endregion
+
+    #region SyncRoot Private Property
+
+    private object SyncRoot
     {
       get
       {
-        return m_collectionViewGroup;
+        if( m_syncRoot == null )
+        {
+          Interlocked.CompareExchange( ref m_syncRoot, new object(), null );
+        }
+
+        return m_syncRoot;
       }
     }
 
-    private void GroupLevelDescriptionChangedHandler( object sender, PropertyChangedEventArgs e )
+    private object m_syncRoot;
+
+    #endregion
+
+    #region ItemCount Event Handling
+
+    private void RegisterItemCountEvent( GroupGeneratorNode item, bool force )
     {
-      // Simply relay this property changed to this Group instance.
-      this.NotifyPropertyChanged( e );
+      if( item == null )
+        return;
+
+      lock( this.SyncRoot )
+      {
+        if( !force && ( m_propertyChanged == null ) )
+          return;
+
+        item.TotalLeafCountChanged += new EventHandler( this.OnItemCountChanged );
+      }
     }
 
-    private void OnTotalItemCountChanged( object sender, EventArgs e )
+    private void UnregisterItemCountEvent( GroupGeneratorNode item )
     {
-      this.NotifyPropertyChanged( "ItemCount" );
+      if( item == null )
+        return;
+
+      item.TotalLeafCountChanged -= new EventHandler( this.OnItemCountChanged );
     }
 
-    private void OnIsExpandedChanged( object sender, EventArgs e )
+    private void OnItemCountChanged( object sender, EventArgs e )
     {
-      this.NotifyPropertyChanged( "IsExpanded" );
+      this.OnPropertyChanged( Group.ItemCountPropertyName );
+    }
 
-      if( AutomationPeer.ListenerExists( AutomationEvents.PropertyChanged ) )
-      {
-        DataGridGroupAutomationPeer groupAutomationPeer = this.CreateAutomationPeer();
+    #endregion
 
-        ExpandCollapseState oldExpandCollapseState;
-        ExpandCollapseState newExpandCollapseState;
+    #region IsExpanded Event Handling
 
-        if( this.IsExpanded )
-        {
-          oldExpandCollapseState = ExpandCollapseState.Collapsed;
-          newExpandCollapseState = ExpandCollapseState.Expanded;
-        }
-        else
-        {
-          oldExpandCollapseState = ExpandCollapseState.Expanded;
-          newExpandCollapseState = ExpandCollapseState.Collapsed;
-        }
+    private void RegisterIsExpandedEvent( GroupGeneratorNode item, bool force )
+    {
+      if( item == null )
+        return;
+
+      lock( this.SyncRoot )
+      {
+        if( !force && ( m_propertyChanged == null ) )
+          return;
 
-        groupAutomationPeer.RaisePropertyChangedEvent(
-          ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty,
-          oldExpandCollapseState, newExpandCollapseState );
+        item.IsExpandedChanged += new EventHandler( this.OnIsExpandedChanged );
       }
     }
 
-    private void PerformLateGroupLevelDescriptionBinding()
+    private void UnregisterIsExpandedEvent( GroupGeneratorNode item )
     {
-      int level = this.Level;
-
-      if( m_lateGroupLevelDescriptionBindingPerformed && this.ValidateGroupLevelDescription( level ) )
+      if( item == null )
         return;
 
-      m_lateGroupLevelDescriptionBindingPerformed = true;
+      item.IsExpandedChanged -= new EventHandler( this.OnIsExpandedChanged );
+    }
 
+    private void OnIsExpandedChanged( object sender, EventArgs e )
+    {
+      this.OnPropertyChanged( Group.IsExpandedPropertyName );
+    }
 
-      if( m_groupDescriptionsCollection.Count > level )
-      {
-        m_groupLevelDescription = m_groupDescriptionsCollection[ level ];
-      }
+    #endregion
+
+    #region GroupLevelDescription Event Handling
+
+    private void RegisterGroupLevelDescriptionEvent( LateGroupLevelDescription item, bool force )
+    {
+      if( item == null )
+        return;
 
-      if( m_groupLevelDescription != null )
+      lock( this.SyncRoot )
       {
-        m_groupLevelDescription.PropertyChanged += new PropertyChangedEventHandler( GroupLevelDescriptionChangedHandler );
+        if( !force && ( m_propertyChanged == null ) )
+          return;
 
-        this.NotifyPropertyChanged( "Title" );
-        this.NotifyPropertyChanged( "TitleTemplate" );
-        this.NotifyPropertyChanged( "TitleTemplateSelector" );
-        this.NotifyPropertyChanged( "ValueTemplate" );
-        this.NotifyPropertyChanged( "ValueTemplateSelector" );
+        item.PropertyChanged += new PropertyChangedEventHandler( this.OnGroupLevelDescriptionChanged );
       }
     }
 
-    private bool ValidateGroupLevelDescription( int level )
+    private void UnregisterGroupLevelDescriptionEvent( LateGroupLevelDescription item )
+    {
+      if( item == null )
+        return;
+
+      item.PropertyChanged -= new PropertyChangedEventHandler( this.OnGroupLevelDescriptionChanged );
+    }
+
+    private void OnGroupLevelDescriptionChanged( object sender, PropertyChangedEventArgs e )
     {
-      //Returns false if the m_groupLevelDescription has changed since it was first initialized, and will be updated in the calling method.
-      if( m_groupDescriptionsCollection.Count > level )
+      if( string.IsNullOrEmpty( e.PropertyName ) )
       {
-        return ( m_groupLevelDescription == m_groupDescriptionsCollection[ level ] );
+        this.OnGroupLevelDescriptionPropertyChanged();
       }
-
-      //If there is no GroupDescription corresponding to the level this group is at, then lets make sure we do not leak on the old GroupDescription
-      if( m_groupLevelDescription != null )
+      else
       {
-        m_groupLevelDescription.PropertyChanged -= new PropertyChangedEventHandler( GroupLevelDescriptionChangedHandler );
-        m_groupLevelDescription = null;
+        // Simply relay this property changed to this Group instance.
+        this.OnPropertyChanged( e.PropertyName );
       }
+    }
 
-      //Return true because there is nothing else to do anyway.
-      return true;
+    private void OnGroupLevelDescriptionPropertyChanged()
+    {
+      this.OnPropertyChanged( Group.GroupByPropertyName );
+      this.OnPropertyChanged( Group.TitlePropertyName );
+      this.OnPropertyChanged( Group.TitleTemplatePropertyName );
+      this.OnPropertyChanged( Group.TitleTemplateSelectorPropertyName );
+      this.OnPropertyChanged( Group.ValueTemplatePropertyName );
+      this.OnPropertyChanged( Group.ValueTemplateSelectorPropertyName );
+      this.OnPropertyChanged( Group.ValueStringFormatPropertyName );
+      this.OnPropertyChanged( Group.ValueStringFormatCulturePropertyName );
     }
 
-    #region INotifyPropertyChanged Members
+    #endregion
+
+    internal DataGridGroupAutomationPeer CreateAutomationPeer()
+    {
+      return new DataGridGroupAutomationPeer( this );
+    }
+
+    internal void ClearGroup()
+    {
+      m_groupDescription = null;
+      m_collectionViewGroup = null;
+      m_propertyChanged = null;
+
+      this.DataGridContext = null;
+      this.GeneratorNode = null;
+      this.GroupLevelDescription = null;
+    }
 
-    public event PropertyChangedEventHandler PropertyChanged;
+    #region IGroupLevelDescription Members
 
-    private void NotifyPropertyChanged( String propertyName )
+    string IGroupLevelDescription.FieldName
     {
-      if( this.PropertyChanged != null )
+      get
       {
-        this.PropertyChanged( this, new PropertyChangedEventArgs( propertyName ) );
+        return this.GroupBy;
       }
     }
 
-    private void NotifyPropertyChanged( PropertyChangedEventArgs e )
+    #endregion
+
+    #region INotifyPropertyChanged Members
+
+    public event PropertyChangedEventHandler PropertyChanged
     {
-      if( this.PropertyChanged != null )
+      add
+      {
+        lock( this.SyncRoot )
+        {
+          if( m_propertyChanged == null )
+          {
+            this.RegisterItemCountEvent( this.GeneratorNode, true );
+            this.RegisterIsExpandedEvent( this.GeneratorNode, true );
+            this.RegisterGroupLevelDescriptionEvent( this.GroupLevelDescription, true );
+          }
+
+          m_propertyChanged += value;
+        }
+      }
+      remove
       {
-        this.PropertyChanged( this, e );
+        lock( this.SyncRoot )
+        {
+          m_propertyChanged -= value;
+
+          if( m_propertyChanged == null )
+          {
+            this.UnregisterItemCountEvent( this.GeneratorNode );
+            this.UnregisterIsExpandedEvent( this.GeneratorNode );
+            this.UnregisterGroupLevelDescriptionEvent( this.GroupLevelDescription );
+          }
+        }
       }
     }
 
-    #endregion INotifyPropertyChanged Members
+    private PropertyChangedEventHandler m_propertyChanged;
 
-    private GroupLevelDescription m_groupLevelDescription; // = null
-    private GroupGeneratorNode m_generatorNode; // = null
-    private CollectionViewGroup m_collectionViewGroup; // = null
-    private IList<GroupLevelDescription> m_groupDescriptionsCollection; // = null
-    private DataGridContext m_dataGridContext;
-    private bool m_lateGroupLevelDescriptionBindingPerformed;
+    private void OnPropertyChanged( string propertyName )
+    {
+      var handler = m_propertyChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, new PropertyChangedEventArgs( propertyName ) );
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByControl.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByControl.cs
index 7ad250ba..161e7bdb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByControl.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByControl.cs
@@ -14,20 +14,14 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Diagnostics;
 using System.Windows;
-using System.Collections.ObjectModel;
 using System.Windows.Controls;
-using System.Collections.Specialized;
-using System.ComponentModel;
 using System.Windows.Data;
+using System.Windows.Documents;
 using System.Windows.Media;
 using Xceed.Utils.Wpf.DragDrop;
-using System.Diagnostics;
 using Xceed.Wpf.DataGrid.Views;
-using System.Windows.Documents;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -437,7 +431,7 @@ namespace Xceed.Wpf.DataGrid
 
         Debug.Assert( groupByItem != null );
         if( groupByItem == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "groupByItem is null." );
 
         groupByItem.ShowDropMark( mousePosition );
       }
@@ -459,7 +453,7 @@ namespace Xceed.Wpf.DataGrid
 
         Debug.Assert( groupByItem != null );
         if( groupByItem == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "groupByItem is null." );
 
         groupByItem.HideDropMark();
       }
@@ -485,7 +479,7 @@ namespace Xceed.Wpf.DataGrid
 
         Debug.Assert( groupByItem != null );
         if( groupByItem == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "groupByItem is null." );
 
         groupByItem.HideDropMark();
       }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByItem.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByItem.cs
index d13817a9..18c7dc59 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByItem.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupByItem.cs
@@ -320,23 +320,23 @@ namespace Xceed.Wpf.DataGrid
 
           if( allowSort )
           {
-            DataGridContext gridContext = DataGridControl.GetDataGridContext( this );
+            DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
             GroupLevelDescription groupInfo = this.Content as GroupLevelDescription;
-            Debug.Assert( ( gridContext != null ) && ( groupInfo != null ) );
+            Debug.Assert( ( dataGridContext != null ) && ( groupInfo != null ) );
 
-            if( ( gridContext != null ) && ( groupInfo != null ) )
+            if( ( dataGridContext != null ) && ( groupInfo != null ) )
             {
-              ColumnBase column = gridContext.Columns[ groupInfo.FieldName ];
+              ColumnBase column = dataGridContext.Columns[ groupInfo.FieldName ];
 
               if( ( column != null ) && ( column.AllowSort ) )
               {
-                DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-                SortDescriptionCollection sortDescriptions = dataGridContext.Items.SortDescriptions;
-                ColumnCollection columns = dataGridContext.Columns;
+                bool shiftUnpressed = ( ( Keyboard.Modifiers & ModifierKeys.Shift ) != ModifierKeys.Shift );
 
-                SortingHelper.ToggleColumnSort(
-                  dataGridContext, sortDescriptions,
-                  columns, column, ( ( Keyboard.Modifiers & ModifierKeys.Shift ) != ModifierKeys.Shift ) );
+                var toggleColumnSort = dataGridContext.ToggleColumnSortCommand;
+                if( toggleColumnSort.CanExecute( column, shiftUnpressed ) )
+                {
+                  toggleColumnSort.Execute( column, shiftUnpressed );
+                }
 
                 e.Handled = true;
               }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupExtensions.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupExtensions.cs
index 036964b1..62900b12 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupExtensions.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupExtensions.cs
@@ -33,5 +33,25 @@ namespace Xceed.Wpf.DataGrid
 
       return collectionViewGroup.GetItems();
     }
+
+    public static IEnumerable<object> GetLeafItems( this Group group )
+    {
+      CollectionViewGroup collectionViewGroup = group.CollectionViewGroup;
+
+      if( collectionViewGroup == null )
+        return new object[0];
+
+      return collectionViewGroup.GetLeafItems();
+    }
+
+    public static SelectionRange GetRange( this Group group )
+    {
+      CollectionViewGroup collectionViewGroup = group.CollectionViewGroup;
+
+      if( collectionViewGroup == null )
+        return SelectionRange.Empty;
+
+      return collectionViewGroup.GetRange( group.DataGridContext );
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupHeaderControl.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupHeaderControl.cs
index 5c7c4b98..fb5221ad 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupHeaderControl.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupHeaderControl.cs
@@ -14,14 +14,16 @@
 
   ***********************************************************************************/
 
+using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics;
+using System.Drawing;
+using System.Linq;
 using System.Windows;
+using System.Windows.Automation.Peers;
 using System.Windows.Controls;
 using System.Windows.Input;
-using System.Windows.Automation.Peers;
-using System.Collections.Specialized;
-using System;
-using System.Diagnostics;
+using Xceed.Utils.Wpf;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -53,6 +55,8 @@ namespace Xceed.Wpf.DataGrid
       this.CommandBindings.Add( new CommandBinding( DataGridCommands.ToggleGroupExpansion,
                                                     this.OnToggleExecuted,
                                                     this.OnToggleCanExecute ) );
+
+      m_itemContainerManager = new DataGridItemContainerManager( this );
     }
 
     #endregion
@@ -77,8 +81,6 @@ namespace Xceed.Wpf.DataGrid
 
     #region Group Property
 
-    private Group m_group;
-
     public Group Group
     {
       get
@@ -93,13 +95,95 @@ namespace Xceed.Wpf.DataGrid
       this.Content = m_group;
       GroupHeaderControl.SetGroup( this, group );
 
-      if( this.PropertyChanged != null )
+      this.RaisePropertyChanged( "Group" );
+    }
+
+    private Group m_group;
+
+    #endregion
+
+    #region SelectionBackground Property
+
+    public static readonly DependencyProperty SelectionBackgroundProperty = Cell.SelectionBackgroundProperty.AddOwner( typeof( GroupHeaderControl ) );
+
+    public Brush SelectionBackground
+    {
+      get
+      {
+        return ( Brush )this.GetValue( GroupHeaderControl.SelectionBackgroundProperty );
+      }
+      set
+      {
+        this.SetValue( GroupHeaderControl.SelectionBackgroundProperty, value );
+      }
+    }
+
+    #endregion SelectionBackground Property
+
+    #region SelectionForeground Property
+
+    public static readonly DependencyProperty SelectionForegroundProperty = Cell.SelectionForegroundProperty.AddOwner( typeof( GroupHeaderControl ) );
+
+    public Brush SelectionForeground
+    {
+      get
+      {
+        return ( Brush )this.GetValue( GroupHeaderControl.SelectionForegroundProperty );
+      }
+      set
+      {
+        this.SetValue( GroupHeaderControl.SelectionForegroundProperty, value );
+      }
+    }
+
+    #endregion SelectionForeground Property
+
+    #region InactiveSelectionBackground Property
+
+    public static readonly DependencyProperty InactiveSelectionBackgroundProperty = Cell.InactiveSelectionBackgroundProperty.AddOwner( typeof( GroupHeaderControl ) );
+
+    public Brush InactiveSelectionBackground
+    {
+      get
+      {
+        return ( Brush )this.GetValue( GroupHeaderControl.InactiveSelectionBackgroundProperty );
+      }
+      set
       {
-        this.PropertyChanged( this, new PropertyChangedEventArgs( "Group" ) );
+        this.SetValue( GroupHeaderControl.InactiveSelectionBackgroundProperty, value );
       }
     }
 
-    #endregion Group Property
+    #endregion InactiveSelectionBackground Property
+
+    #region InactiveSelectionForeground Property
+
+    public static readonly DependencyProperty InactiveSelectionForegroundProperty = Cell.InactiveSelectionForegroundProperty.AddOwner( typeof( GroupHeaderControl ) );
+
+    public Brush InactiveSelectionForeground
+    {
+      get
+      {
+        return ( Brush )this.GetValue( GroupHeaderControl.InactiveSelectionForegroundProperty );
+      }
+      set
+      {
+        this.SetValue( GroupHeaderControl.InactiveSelectionForegroundProperty, value );
+      }
+    }
+
+    #endregion InactiveSelectionForeground Property
+
+    #region Public Overrides Methods
+
+    public override void OnApplyTemplate()
+    {
+      base.OnApplyTemplate();
+
+      m_itemContainerManager.Update();
+    }
+
+    #endregion
 
     #region Protected Overrides Methods
 
@@ -126,7 +210,7 @@ namespace Xceed.Wpf.DataGrid
           {
             try
             {
-              dataGridContext.SetCurrent( item, null, -1, dataGridContext.CurrentColumn, true, true, false );
+              dataGridContext.SetCurrent( item, null, -1, dataGridContext.CurrentColumn, true, true, false, AutoScrollCurrentItemSourceTriggers.FocusChanged );
             }
             catch( DataGridException )
             {
@@ -140,21 +224,16 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region Protected Internal Methods
-
-    protected internal virtual void PrepareDefaultStyleKey( Xceed.Wpf.DataGrid.Views.ViewBase view )
-    {
-      this.DefaultStyleKey = view.GetDefaultStyleKey( typeof( GroupHeaderControl ) );
-    }
+    #region Protected Methods
 
-    protected internal virtual void PrepareContainer( DataGridContext dataGridContext, object item )
+    protected virtual void PrepareContainer( DataGridContext dataGridContext, object item )
     {
       if( m_isContainerPrepared )
         Debug.Fail( "A GroupHeaderControl can't be prepared twice, it must be cleaned before PrepareContainer is called again" );
 
       Group group = null;
-
       DataGridContext gridContext = DataGridControl.GetDataGridContext( this );
+
       if( gridContext != null )
       {
         object dataItem = gridContext.GetItemFromContainer( this );
@@ -166,15 +245,32 @@ namespace Xceed.Wpf.DataGrid
 
       this.SetGroup( group );
 
+      m_itemContainerManager.Prepare( gridContext, item );
+
       m_isContainerPrepared = true;
     }
 
-    protected internal virtual void ClearContainer()
+    protected virtual void ClearContainer()
     {
-      //Do nothing!
+      m_itemContainerManager.Clear();
       m_isContainerPrepared = false;
     }
 
+    protected internal virtual void PrepareDefaultStyleKey( Xceed.Wpf.DataGrid.Views.ViewBase view )
+    {
+      this.DefaultStyleKey = view.GetDefaultStyleKey( typeof( GroupHeaderControl ) );
+    }
+
+    protected internal virtual bool ShouldHandleSelectionEvent( InputEventArgs eventArgs )
+    {
+      var targetChild = eventArgs.OriginalSource as DependencyObject;
+      // If the event is comming from a control inside the header, ignore the event
+      // since it is not for selection purposes that the user targeted this control. 
+      // This handle the expand collapse butto, and the GroupNavigationControl
+      return TreeHelper.FindParent<Control>( targetChild, true, null, this ) == null;
+    }
+
+
     #endregion
 
     #region Private Static Methods
@@ -278,14 +374,24 @@ namespace Xceed.Wpf.DataGrid
 
     #region Private Fields
 
+    private readonly DataGridItemContainerManager m_itemContainerManager;
     private bool m_isContainerPrepared;
 
-    #endregion Private Fields
+    #endregion
 
     #region INotifyPropertyChanged Members
 
     public event PropertyChangedEventHandler PropertyChanged;
 
+    private void RaisePropertyChanged( string propertyName )
+    {
+      var handler = this.PropertyChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, new PropertyChangedEventArgs( propertyName ) );
+    }
+
     #endregion
 
     #region IDataGridItemContainer Members
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelDescription.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelDescription.cs
index 78f3bd6d..c055d037 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelDescription.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelDescription.cs
@@ -14,16 +14,14 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.ComponentModel;
+using System.Globalization;
 using System.Windows;
 using System.Windows.Controls;
-using System.ComponentModel;
 
 namespace Xceed.Wpf.DataGrid
 {
-  public class GroupLevelDescription : DependencyObject, INotifyPropertyChanged
+  public class GroupLevelDescription : DependencyObject, IGroupLevelDescription, INotifyPropertyChanged
   {
     #region CONSTRUCTORS
 
@@ -48,6 +46,8 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private readonly string m_fieldName;
+
     #endregion
 
     #region GroupDescription Property
@@ -60,12 +60,17 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private readonly GroupDescription m_groupDescription;
+
     #endregion
 
     #region Title Property
 
-    internal static readonly DependencyProperty TitleProperty =
-        DependencyProperty.Register( "Title", typeof( object ), typeof( GroupLevelDescription ), new UIPropertyMetadata( null, new PropertyChangedCallback( GroupPropertiesChangedHandler ) ) );
+    internal static readonly DependencyProperty TitleProperty = DependencyProperty.Register(
+      "Title",
+      typeof( object ),
+      typeof( GroupLevelDescription ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( GroupLevelDescription.OnPropertyChanged ) ) );
 
     public object Title
     {
@@ -84,8 +89,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region TitleTemplate Property
 
-    internal static readonly DependencyProperty TitleTemplateProperty =
-        DependencyProperty.Register( "TitleTemplate", typeof( DataTemplate ), typeof( GroupLevelDescription ), new UIPropertyMetadata( null, new PropertyChangedCallback( GroupPropertiesChangedHandler ) ) );
+    internal static readonly DependencyProperty TitleTemplateProperty = DependencyProperty.Register(
+      "TitleTemplate",
+      typeof( DataTemplate ),
+      typeof( GroupLevelDescription ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( GroupLevelDescription.OnPropertyChanged ) ) );
 
     public DataTemplate TitleTemplate
     {
@@ -95,17 +103,15 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    internal void SetTitleTemplate( DataTemplate titleTemplate )
-    {
-      this.SetValue( GroupLevelDescription.TitleTemplateProperty, titleTemplate );
-    }
-
     #endregion TitleTemplate Property
 
     #region TitleTemplateSelector Property
 
-    internal static readonly DependencyProperty TitleTemplateSelectorProperty =
-        DependencyProperty.Register( "TitleTemplateSelector", typeof( DataTemplateSelector ), typeof( GroupLevelDescription ), new UIPropertyMetadata( null, new PropertyChangedCallback( GroupPropertiesChangedHandler ) ) );
+    internal static readonly DependencyProperty TitleTemplateSelectorProperty = DependencyProperty.Register(
+      "TitleTemplateSelector",
+      typeof( DataTemplateSelector ),
+      typeof( GroupLevelDescription ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( GroupLevelDescription.OnPropertyChanged ) ) );
 
     public DataTemplateSelector TitleTemplateSelector
     {
@@ -115,17 +121,51 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    internal void SetTitleTemplateSelector( DataTemplateSelector titleTemplateSelector )
+    #endregion TitleTemplateSelector Property
+
+    #region ValueStringFormat Property
+
+    internal static readonly DependencyProperty ValueStringFormatProperty = DependencyProperty.Register(
+      "ValueStringFormat",
+      typeof( string ),
+      typeof( GroupLevelDescription ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( GroupLevelDescription.OnPropertyChanged ) ) );
+
+    public string ValueStringFormat
     {
-      this.SetValue( GroupLevelDescription.TitleTemplateSelectorProperty, titleTemplateSelector );
+      get
+      {
+        return ( string )this.GetValue( GroupLevelDescription.ValueStringFormatProperty );
+      }
     }
 
-    #endregion TitleTemplateSelector Property
+    #endregion ValueStringFormat Property
+
+    #region ValueStringFormatCulture Property
+
+    internal static readonly DependencyProperty ValueStringFormatCultureProperty = DependencyProperty.Register(
+      "ValueStringFormatCulture",
+      typeof( CultureInfo ),
+      typeof( GroupLevelDescription ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( GroupLevelDescription.OnPropertyChanged ) ) );
+
+    public CultureInfo ValueStringFormatCulture
+    {
+      get
+      {
+        return ( CultureInfo )this.GetValue( GroupLevelDescription.ValueStringFormatCultureProperty );
+      }
+    }
+
+    #endregion ValueStringFormatCulture Property
 
     #region ValueTemplate Property
 
-    public static readonly DependencyProperty ValueTemplateProperty =
-        DependencyProperty.Register( "ValueTemplate", typeof( DataTemplate ), typeof( GroupLevelDescription ), new UIPropertyMetadata( null, new PropertyChangedCallback( GroupPropertiesChangedHandler ) ) );
+    internal static readonly DependencyProperty ValueTemplateProperty = DependencyProperty.Register(
+      "ValueTemplate",
+      typeof( DataTemplate ),
+      typeof( GroupLevelDescription ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( GroupLevelDescription.OnPropertyChanged ) ) );
 
     public DataTemplate ValueTemplate
     {
@@ -133,18 +173,17 @@ namespace Xceed.Wpf.DataGrid
       {
         return ( DataTemplate )this.GetValue( GroupLevelDescription.ValueTemplateProperty );
       }
-      set
-      {
-        this.SetValue( GroupLevelDescription.ValueTemplateProperty, value );
-      }
     }
 
     #endregion ValueTemplate Property
 
     #region ValueTemplateSelector Property
 
-    public static readonly DependencyProperty ValueTemplateSelectorProperty =
-        DependencyProperty.Register( "ValueTemplateSelector", typeof( DataTemplateSelector ), typeof( GroupLevelDescription ), new UIPropertyMetadata( null, new PropertyChangedCallback( GroupPropertiesChangedHandler ) ) );
+    internal static readonly DependencyProperty ValueTemplateSelectorProperty = DependencyProperty.Register(
+      "ValueTemplateSelector",
+      typeof( DataTemplateSelector ),
+      typeof( GroupLevelDescription ),
+      new UIPropertyMetadata( null, new PropertyChangedCallback( GroupLevelDescription.OnPropertyChanged ) ) );
 
     public DataTemplateSelector ValueTemplateSelector
     {
@@ -152,38 +191,23 @@ namespace Xceed.Wpf.DataGrid
       {
         return ( DataTemplateSelector )this.GetValue( GroupLevelDescription.ValueTemplateSelectorProperty );
       }
-      set
-      {
-        this.SetValue( GroupLevelDescription.ValueTemplateSelectorProperty, value );
-      }
     }
 
     #endregion ValueTemplateSelector Property
 
-    #region PRIVATE METHODS
-
-    private static void GroupPropertiesChangedHandler( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      GroupLevelDescription info = ( GroupLevelDescription )sender;
-
-      if( info.PropertyChanged != null )
-      {
-        info.PropertyChanged( info, new PropertyChangedEventArgs( e.Property.Name ) );
-      }
-    }
-
-    #endregion
-
     #region INotifyPropertyChanged Members
 
     public event PropertyChangedEventHandler PropertyChanged;
 
-    #endregion
-
-    #region PRIVATE FIELDS
+    private static void OnPropertyChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var self = ( GroupLevelDescription )sender;
+      var handler = self.PropertyChanged;
+      if( handler == null )
+        return;
 
-    private string m_fieldName;
-    private GroupDescription m_groupDescription;
+      handler.Invoke( self, new PropertyChangedEventArgs( e.Property.Name ) );
+    }
 
     #endregion
   }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelIndicatorPane.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelIndicatorPane.cs
index f99f62f2..6604487b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelIndicatorPane.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupLevelIndicatorPane.cs
@@ -15,17 +15,15 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
-using System.Diagnostics;
-using Xceed.Wpf.DataGrid.Views;
 using System.Windows.Data;
-using System.Collections.Specialized;
-using System.ComponentModel;
-using System.Collections.ObjectModel;
 using System.Windows.Media;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -94,11 +92,13 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private Panel m_storedGroupLevelIndicatorPaneHost; //null
+
     #endregion GroupLevelIndicatorPaneHost Read-Only Property
 
     #region ShowIndicators Attached Property
 
-    public static readonly DependencyProperty ShowIndicatorsProperty = DependencyProperty.RegisterAttached( 
+    public static readonly DependencyProperty ShowIndicatorsProperty = DependencyProperty.RegisterAttached(
       "ShowIndicators", typeof( bool ), typeof( GroupLevelIndicatorPane ),
       new FrameworkPropertyMetadata( true, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure ) );
 
@@ -154,7 +154,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region GroupLevel Attached Property
 
-    public static readonly DependencyProperty GroupLevelProperty = DependencyProperty.RegisterAttached( 
+    public static readonly DependencyProperty GroupLevelProperty = DependencyProperty.RegisterAttached(
       "GroupLevel", typeof( int ), typeof( GroupLevelIndicatorPane ),
       new FrameworkPropertyMetadata( 0, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure ) );
 
@@ -222,101 +222,101 @@ namespace Xceed.Wpf.DataGrid
 
     protected override Size MeasureOverride( Size availableSize )
     {
-      Panel panel = this.GroupLevelIndicatorPaneHost;
+      var panel = this.GroupLevelIndicatorPaneHost;
+      var dataGridContext = DataGridControl.GetDataGridContext( this );
 
-      if( panel == null )
+      if( ( panel == null ) || ( dataGridContext == null ) )
         return base.MeasureOverride( availableSize );
 
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
+      var groupDescriptions = DataGridContext.GetGroupDescriptionsHelper( dataGridContext.Items );
+      var leafGroupLevel = GroupLevelIndicatorPane.GetGroupLevel( this );
 
-      if( dataGridContext != null )
+      // If Indented is true (default), we use the total groupDescriptions.Count for this DataGridContext
+      var correctedGroupLevel = ( this.Indented == true ) ? groupDescriptions.Count : leafGroupLevel;
+
+      // Ensure that the GroupLevel retrieved does not exceeds the number of group descriptions for the DataGridContext
+      correctedGroupLevel = Math.Min( correctedGroupLevel, groupDescriptions.Count );
+
+      // Then finally, if the GroupLevel is -1, then indent at maximum.
+      if( correctedGroupLevel == -1 )
       {
-        ObservableCollection<GroupDescription> groupDescriptions = DataGridContext.GetGroupDescriptionsHelper( dataGridContext.Items );
+        correctedGroupLevel = groupDescriptions.Count;
+      }
 
-        int leafGroupLevel = GroupLevelIndicatorPane.GetGroupLevel( this );
+      if( ( correctedGroupLevel > 0 ) && ( this.AreGroupsFlattened ) )
+      {
+        correctedGroupLevel = ( this.Indented ) ? 1 : 0;
+      }
 
-        // If Indented is true (default), we use the total groupDescriptions.Count for this DataGridContext
-        int correctedGroupLevel = ( this.Indented == true ) ? groupDescriptions.Count : leafGroupLevel;
+      var children = panel.Children;
+      var childrenCount = children.Count;
 
-        // Ensure that the GroupLevel retrieved does not exceeds the number of group descriptions for the DataGridContext
-        correctedGroupLevel = Math.Min( correctedGroupLevel, groupDescriptions.Count );
+      // If we need to add/remove GroupLevelIndicators from the panel
+      if( correctedGroupLevel != childrenCount )
+      {
+        // When grouping change, we take for granted that the group deepness will change, 
+        // so we initialize DataContext of the margin only in there.
 
-        // Then finally, if the GroupLevel is -1, then indent at maximum.
-        if( correctedGroupLevel == -1 )
-          correctedGroupLevel = groupDescriptions.Count;
+        // Clear all the panel's children!
+        children.Clear();
 
-        if( ( correctedGroupLevel > 0 )
-          && ( this.AreGroupsFlattened ) )
+        // Create 1 group margin content presenter for each group level
+        for( int i = correctedGroupLevel - 1; i >= 0; i-- )
         {
-          correctedGroupLevel = ( this.Indented ) ? 1 : 0;
+          GroupLevelIndicator groupMargin = new GroupLevelIndicator();
+          groupMargin.DataContext = dataGridContext.GroupLevelDescriptions[ i ];
+          children.Insert( 0, new GroupLevelIndicator() );
         }
 
-        UIElementCollection children = panel.Children;
-        int childrenCount = children.Count;
+        childrenCount = correctedGroupLevel;
+        this.SetCurrentIndicatorCount( childrenCount );
 
-        // If we need to add/remove GroupLevelIndicators from the panel
-        if( correctedGroupLevel != childrenCount )
-        {
-          // When grouping change, we take for granted that the group deepness will change, 
-          // so we initialize DataContext of the margin only in there.
+        this.InvalidateGroupLevelIndicatorPaneHostPanelMeasure();
+      }
 
-          // Clear all the panel's children!
-          children.Clear();
+      var item = dataGridContext.GetItemFromContainer( this );
 
-          // Create 1 group margin content presenter for each group level
-          for( int i = correctedGroupLevel - 1; i >= 0; i-- )
-          {
-            GroupLevelIndicator groupMargin = new GroupLevelIndicator();
-            groupMargin.DataContext = dataGridContext.GroupLevelDescriptions[ i ];
-            children.Insert( 0, new GroupLevelIndicator() );
-          }
+      for( int i = 0; i < childrenCount; i++ )
+      {
+        GroupLevelIndicator groupMargin = children[ i ] as GroupLevelIndicator;
 
-          childrenCount = correctedGroupLevel;
-          this.SetCurrentIndicatorCount( childrenCount );
-        }
+        CollectionViewGroup groupForIndicator = GroupLevelIndicatorPane.GetCollectionViewGroupHelper(
+          dataGridContext, groupDescriptions, item, i );
 
-        object item = dataGridContext.GetItemFromContainer( this );
+        GroupConfiguration groupLevelConfig = GroupConfiguration.GetGroupConfiguration(
+          dataGridContext, groupDescriptions, dataGridContext.GroupConfigurationSelector, i, groupForIndicator );
 
-        for( int i = 0; i < childrenCount; i++ )
+        if( groupLevelConfig != null )
         {
-          GroupLevelIndicator groupMargin = children[ i ] as GroupLevelIndicator;
+          Binding groupLevelIndicatorStyleBinding = BindingOperations.GetBinding( groupMargin, GroupLevelIndicator.StyleProperty );
 
-          CollectionViewGroup groupForIndicator = GroupLevelIndicatorPane.GetCollectionViewGroupHelper( 
-            dataGridContext, groupDescriptions, item, i );
+          if( ( groupLevelIndicatorStyleBinding == null ) || ( groupLevelIndicatorStyleBinding.Source != groupLevelConfig ) )
+          {
+            groupLevelIndicatorStyleBinding = new Binding( "GroupLevelIndicatorStyle" );
+            groupLevelIndicatorStyleBinding.Source = groupLevelConfig;
 
-          GroupConfiguration groupLevelConfig = GroupConfiguration.GetGroupConfiguration( 
-            dataGridContext, groupDescriptions, dataGridContext.GroupConfigurationSelector, i, groupForIndicator );
+            // Use a Converter to manage groupLevelConfig.GroupLevelIndicatorStyle == null
+            // so that an implicit syle won't be overriden by a null style.
+            groupLevelIndicatorStyleBinding.Converter = new GroupLevelIndicatorConverter();
 
-          if( groupLevelConfig != null )
-          {
-            Binding groupLevelIndicatorStyleBinding = BindingOperations.GetBinding( groupMargin, GroupLevelIndicator.StyleProperty );
-
-            if( ( groupLevelIndicatorStyleBinding == null ) || ( groupLevelIndicatorStyleBinding.Source != groupLevelConfig ) )
-            {
-              groupLevelIndicatorStyleBinding = new Binding( "GroupLevelIndicatorStyle" );
-              groupLevelIndicatorStyleBinding.Source = groupLevelConfig;
-              // Use a Converter to manage groupLevelConfig.GroupLevelIndicatorStyle == null
-              // so that an implicit syle won't be overriden by a null style.
-              groupLevelIndicatorStyleBinding.Converter = new GroupLevelIndicatorConverter();
-              groupLevelIndicatorStyleBinding.ConverterParameter = groupMargin;
-              groupMargin.SetBinding( GroupLevelIndicator.StyleProperty, groupLevelIndicatorStyleBinding );
-            }
-          }
-          else
-          {
-            groupMargin.ClearValue( GroupLevelIndicator.StyleProperty );
+            groupLevelIndicatorStyleBinding.ConverterParameter = groupMargin;
+            groupMargin.SetBinding( GroupLevelIndicator.StyleProperty, groupLevelIndicatorStyleBinding );
           }
+        }
+        else
+        {
+          groupMargin.ClearValue( GroupLevelIndicator.StyleProperty );
+        }
 
-          // If the ShowIndicators property is False or there is already leafGroupLevel GroupLevelIndicators in the panel,
-          // the current newGroupMargin must be hidden.
-          if( ( !GroupLevelIndicatorPane.GetShowIndicators( this ) ) || ( ( i >= leafGroupLevel ) && ( leafGroupLevel != -1 ) ) )
-          {
-            groupMargin.Visibility = Visibility.Hidden;
-          }
-          else
-          {
-            groupMargin.Visibility = Visibility.Visible;
-          }
+        // If the ShowIndicators property is False or there is already leafGroupLevel GroupLevelIndicators in the panel,
+        // the current newGroupMargin must be hidden.
+        if( ( !GroupLevelIndicatorPane.GetShowIndicators( this ) ) || ( ( i >= leafGroupLevel ) && ( leafGroupLevel != -1 ) ) )
+        {
+          groupMargin.Visibility = Visibility.Hidden;
+        }
+        else
+        {
+          groupMargin.Visibility = Visibility.Visible;
         }
       }
 
@@ -375,9 +375,23 @@ namespace Xceed.Wpf.DataGrid
 
     private static void OnDataItemChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      GroupLevelIndicatorPane self = sender as GroupLevelIndicatorPane;
+      var self = ( GroupLevelIndicatorPane )sender;
+      Debug.Assert( self != null );
+
+      var oldDataItemStore = ( DataItemDataProviderBase )e.OldValue;
+      var newDataItemStore = ( DataItemDataProviderBase )e.NewValue;
+
+      if( oldDataItemStore != null )
+      {
+        PropertyChangedEventManager.RemoveListener( oldDataItemStore, self, "Data" );
+      }
 
-      if( ( self != null ) && ( e.NewValue != CustomItemContainerGenerator.NotSet ) )
+      if( newDataItemStore != null )
+      {
+        PropertyChangedEventManager.AddListener( newDataItemStore, self, "Data" );
+      }
+
+      if( !newDataItemStore.IsEmpty )
       {
         self.InvalidateMeasure();
       }
@@ -407,7 +421,16 @@ namespace Xceed.Wpf.DataGrid
       return this.GetTemplateChild( "PART_GroupLevelIndicatorHost" ) as Panel;
     }
 
-    private Panel m_storedGroupLevelIndicatorPaneHost = null;
+    private void InvalidateGroupLevelIndicatorPaneHostPanelMeasure()
+    {
+      UIElement container = this.GroupLevelIndicatorPaneHost;
+
+      while( ( container != null ) && ( container != this ) )
+      {
+        container.InvalidateMeasure();
+        container = VisualTreeHelper.GetParent( container ) as UIElement;
+      }
+    }
 
     #region IWeakEventListener Members
 
@@ -423,6 +446,16 @@ namespace Xceed.Wpf.DataGrid
         this.InvalidateMeasure();
         return true;
       }
+      else if( managerType == typeof( PropertyChangedEventManager ) )
+      {
+        var dataItemStore = sender as DataItemDataProviderBase;
+        if( ( dataItemStore != null ) && !dataItemStore.IsEmpty )
+        {
+          this.InvalidateMeasure();
+        }
+
+        return true;
+      }
 
       return false;
     }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupingHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupingHelper.cs
index 7de24f0c..efd70150 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupingHelper.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/GroupingHelper.cs
@@ -14,15 +14,12 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.ComponentModel;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Windows;
-using Xceed.Utils.Wpf;
 using System.Windows.Data;
+using Xceed.Utils.Wpf;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -178,25 +175,32 @@ namespace Xceed.Wpf.DataGrid
       if( cell == null )
         return;
 
-      DataGridContext cellDataGridContext = DataGridControl.GetDataGridContext( cell );
-      DataGridControl cellParentGrid = cellDataGridContext.DataGridControl;
+      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( cell );
+      ColumnBase column = cell.ParentColumn;
 
-      if( ( cellDataGridContext == null ) ||
+      if( ( dataGridContext == null ) ||
           ( parentDataGridControl == null ) ||
-          ( parentDataGridControl != cellParentGrid ) )
+          ( column == null ) ||
+          ( parentDataGridControl != dataGridContext.DataGridControl ) )
         return;
 
-      // By default, add it at the end
-      int newPos = cellDataGridContext.GroupLevelDescriptions.Count;
+      var addGroupCommand = dataGridContext.AddGroupCommand;
 
       if( draggedOverDescription != null )
-        newPos = GroupingHelper.GetGroupDescriptionIndexFromFieldName( cellDataGridContext, draggedOverDescription.FieldName, alignment );
-
-      ColumnBase column = cell.ParentColumn;
+      {
+        var position = GroupingHelper.GetGroupDescriptionIndexFromFieldName( dataGridContext, draggedOverDescription.FieldName, alignment );
 
-      if( column != null )
+        if( addGroupCommand.CanExecute( column, position ) )
+        {
+          addGroupCommand.Execute( column, position );
+        }
+      }
+      else
       {
-        GroupingHelper.AddNewGroupFromColumn( column, cellDataGridContext.Items.GroupDescriptions, newPos );
+        if( addGroupCommand.CanExecute( column ) )
+        {
+          addGroupCommand.Execute( column );
+        }
       }
     }
 
@@ -205,21 +209,6 @@ namespace Xceed.Wpf.DataGrid
       GroupingHelper.AddNewGroupFromColumnManagerCell( cell, null, DropMarkAlignment.Far, parentDataGridControl );
     }
 
-    public static void AddNewGroupFromColumn( ColumnBase column, ObservableCollection<GroupDescription> targetGroupDescriptions, int position )
-    {
-      GroupDescription groupDescription = column.GroupDescription;
-
-      if( groupDescription == null )
-        groupDescription = new DataGridGroupDescription( column.FieldName );
-
-      DataGridGroupDescription dataGridGroupDescription = groupDescription as DataGridGroupDescription;
-
-      if( ( dataGridGroupDescription != null ) && ( dataGridGroupDescription.GroupConfiguration == null ) )
-        dataGridGroupDescription.GroupConfiguration = column.GroupConfiguration;
-
-      targetGroupDescriptions.Insert( position, groupDescription );
-    }
-
     public static void MoveGroupDescription( ColumnCollection targetColumns, ObservableCollection<GroupDescription> targetGroupDescriptions, GroupLevelDescription targetGroupLevelDescription, DropMarkAlignment targetAlignment, GroupLevelDescription movedGroupLevelDescription, DataGridControl parentDataGridControl )
     {
       Debug.Assert( targetColumns != null );
@@ -238,13 +227,18 @@ namespace Xceed.Wpf.DataGrid
       int newPos = GroupingHelper.GetGroupDescriptionIndex( targetGroupDescriptions, targetGroupLevelDescription, targetAlignment );
 
       if( newPos > oldPos )
+      {
         newPos--;
+      }
 
       if( newPos != oldPos )
       {
         Debug.Assert( oldPos < targetGroupDescriptions.Count );
 
-        targetGroupDescriptions.Move( oldPos, newPos );
+        using( parentDataGridControl.SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged ) )
+        {
+          targetGroupDescriptions.Move( oldPos, newPos );
+        }
       }
     }
 
@@ -254,7 +248,10 @@ namespace Xceed.Wpf.DataGrid
           ( parentDataGridControl == null ) )
         return;
 
-      groupDescriptions.Remove( groupLevelDescription.GroupDescription );
+      using( parentDataGridControl.SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged ) )
+      {
+        groupDescriptions.Remove( groupLevelDescription.GroupDescription );
+      }
     }
 
     public static bool ValidateMaxGroupDescriptions( DataGridContext draggedContext )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HeaderFooterItem.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HeaderFooterItem.cs
index d51981fc..bb842858 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HeaderFooterItem.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HeaderFooterItem.cs
@@ -15,26 +15,29 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Text;
+using System.Linq;
 using System.Windows;
+using System.Windows.Automation.Peers;
 using System.Windows.Controls;
 using System.Windows.Data;
 using System.Windows.Input;
 using System.Windows.Media;
 
-using Xceed.Wpf.DataGrid.Print;
-using Xceed.Utils.Wpf;
-using System.Windows.Automation.Peers;
-using Xceed.Wpf.DataGrid.Automation;
-
 namespace Xceed.Wpf.DataGrid
 {
-  internal class HeaderFooterItem : ContentPresenter, IPrintInfo, IDataGridItemContainer
+  internal class HeaderFooterItem : ContentPresenter, IDataGridItemContainer
   {
-    #region CONSTRUCTORS
+    #region Static Fields
+
+    private static readonly Binding m_sIsCurrentInternalBinding;
+    private static readonly Binding m_sItemIndexBinding;
+    private static readonly Binding m_sIsBeingEditedInternalBinding;
+    private static readonly Binding m_sHasValidationErrorInternalBinding;
+    private static readonly Binding m_sRowSelectorVisibleBinding;
+    private static readonly Binding m_sRowSelectorStyleBinding;
+
+    #endregion
 
     static HeaderFooterItem()
     {
@@ -71,11 +74,12 @@ namespace Xceed.Wpf.DataGrid
       m_sRowSelectorStyleBinding.RelativeSource = RelativeSource.Self;
       m_sRowSelectorStyleBinding.Path = new PropertyPath( "(0).(1)", HeaderFooterItem.ContainerProperty, RowSelector.RowSelectorStyleProperty );
       m_sRowSelectorStyleBinding.Mode = BindingMode.OneWay;
-
     }
 
     internal HeaderFooterItem()
     {
+      m_itemContainerManager = new DataGridItemContainerManager( this );
+
       //to prevent creation of the headerfooteritem by anybody else than us.
       BindingOperations.SetBinding( this, HeaderFooterItem.ItemIndexProperty, m_sItemIndexBinding );
       BindingOperations.SetBinding( this, HeaderFooterItem.IsBeingEditedInternalProperty, m_sIsBeingEditedInternalBinding );
@@ -86,14 +90,15 @@ namespace Xceed.Wpf.DataGrid
       BindingOperations.SetBinding( this, RowSelector.RowSelectorStyleProperty, m_sRowSelectorStyleBinding );
     }
 
-    #endregion
-
-    #region IsCurrentInternal
+    #region IsCurrentInternal Property
 
-    private static readonly DependencyProperty IsCurrentInternalProperty =
-        DependencyProperty.Register( "IsCurrentInternal", typeof( bool ), typeof( HeaderFooterItem ),
-            new FrameworkPropertyMetadata( ( bool )false,
-                new PropertyChangedCallback( OnIsCurrentInternalChanged ) ) );
+    private static readonly DependencyProperty IsCurrentInternalProperty = DependencyProperty.Register(
+      "IsCurrentInternal",
+      typeof( bool ),
+      typeof( HeaderFooterItem ),
+      new FrameworkPropertyMetadata(
+        ( bool )false,
+        new PropertyChangedCallback( OnIsCurrentInternalChanged ) ) );
 
     private static void OnIsCurrentInternalChanged( DependencyObject d, DependencyPropertyChangedEventArgs e )
     {
@@ -107,12 +112,15 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region IsBeingEditedInternal
+    #region IsBeingEditedInternal Property
 
-    private static readonly DependencyProperty IsBeingEditedInternalProperty =
-        DependencyProperty.Register( "IsBeingEditedInternal", typeof( bool ), typeof( HeaderFooterItem ),
-            new FrameworkPropertyMetadata( ( bool )false,
-                new PropertyChangedCallback( OnIsBeingEditedInternalChanged ) ) );
+    private static readonly DependencyProperty IsBeingEditedInternalProperty = DependencyProperty.Register(
+      "IsBeingEditedInternal",
+      typeof( bool ),
+      typeof( HeaderFooterItem ),
+      new FrameworkPropertyMetadata(
+        ( bool )false,
+        new PropertyChangedCallback( OnIsBeingEditedInternalChanged ) ) );
 
     private static void OnIsBeingEditedInternalChanged( DependencyObject d, DependencyPropertyChangedEventArgs e )
     {
@@ -126,12 +134,15 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region HasValidationErrorInternal
+    #region HasValidationErrorInternal Property
 
-    private static readonly DependencyProperty HasValidationErrorInternalProperty =
-        DependencyProperty.Register( "HasValidationErrorInternal", typeof( bool ), typeof( HeaderFooterItem ),
-            new FrameworkPropertyMetadata( ( bool )false,
-                new PropertyChangedCallback( OnHasValidationErrorInternalChanged ) ) );
+    private static readonly DependencyProperty HasValidationErrorInternalProperty = DependencyProperty.Register(
+      "HasValidationErrorInternal",
+      typeof( bool ),
+      typeof( HeaderFooterItem ),
+      new FrameworkPropertyMetadata(
+        ( bool )false,
+        new PropertyChangedCallback( OnHasValidationErrorInternalChanged ) ) );
 
     private static void OnHasValidationErrorInternalChanged( DependencyObject d, DependencyPropertyChangedEventArgs e )
     {
@@ -195,9 +206,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region Container Property
 
-    private static readonly DependencyPropertyKey ContainerPropertyKey
-        = DependencyProperty.RegisterReadOnly( "Container", typeof( DependencyObject ), typeof( HeaderFooterItem ),
-            new FrameworkPropertyMetadata( ( DependencyObject )null ) );
+    private static readonly DependencyPropertyKey ContainerPropertyKey = DependencyProperty.RegisterReadOnly(
+      "Container",
+      typeof( DependencyObject ),
+      typeof( HeaderFooterItem ),
+      new FrameworkPropertyMetadata( ( DependencyObject )null ) );
 
     public static readonly DependencyProperty ContainerProperty;
 
@@ -226,10 +239,14 @@ namespace Xceed.Wpf.DataGrid
         DataTemplate template = m_initializingDataItem as DataTemplate;
 
         if( template == null )
+        {
           template = this.ContentTemplate;
+        }
 
         if( ( template != null ) && ( template.VisualTree != null ) )
+        {
           elementType = template.VisualTree.Type;
+        }
 
         if( elementType == null )
         {
@@ -245,9 +262,10 @@ namespace Xceed.Wpf.DataGrid
 
           Debug.Assert( visual != null );
 
-
           if( visual != null )
+          {
             elementType = visual.GetType();
+          }
         }
 
         return elementType;
@@ -256,7 +274,12 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region PUBLIC METHODS
+    public override void OnApplyTemplate()
+    {
+      base.OnApplyTemplate();
+
+      m_itemContainerManager.Update();
+    }
 
     public Visual AsVisual()
     {
@@ -266,25 +289,20 @@ namespace Xceed.Wpf.DataGrid
       return this.GetVisualChild( 0 );
     }
 
-    #endregion
-
-    #region PROTECTED METHODS
-
     protected override AutomationPeer OnCreateAutomationPeer()
     {
       return new FrameworkElementAutomationPeer( this );
     }
 
-    protected internal void PrepareContainer( DataGridContext dataGridContext, object item )
+    protected void PrepareContainer( DataGridContext dataGridContext, object item )
     {
       if( dataGridContext == null )
         throw new ArgumentNullException( "dataGridContext" );
 
-
       m_initializingDataGridContext = dataGridContext;
       m_initializingDataItem = item;
 
-      if( this.IsLoaded == false )
+      if( !this.IsLoaded )
       {
         if( dataGridContext.DataGridControl.IsPrinting )
         {
@@ -311,20 +329,8 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    protected internal void ClearContainer()
+    protected void ClearContainer()
     {
-      Visual visual = this.AsVisual();
-
-      // If the root of a HeaderFooterItem is not a IDataGridItemContainer,
-      // drill down the VisualTree to ensure there are none
-      var container = HeaderFooterItem.FindIDataGridItemContainerInChildren( this, visual );
-
-      while( container != null )
-      {
-        container.ClearContainer();
-        container = HeaderFooterItem.FindIDataGridItemContainerInChildren( this, ( DependencyObject )container, false );
-      }
-
       // Ensure we removed the HeaderFooterItem_Loaded event handler if
       // it was not yet loaded
       if( m_loadedHandler != null )
@@ -332,6 +338,8 @@ namespace Xceed.Wpf.DataGrid
         this.Loaded -= m_loadedHandler;
         m_loadedHandler = null;
       }
+
+      m_itemContainerManager.Clear();
     }
 
     protected override void OnIsKeyboardFocusWithinChanged( DependencyPropertyChangedEventArgs e )
@@ -357,94 +365,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion
-
-    #region INTERNAL METHODS
-
-    internal static IDataGridItemContainer FindIDataGridItemContainerInChildren( HeaderFooterItem headerFooterItem, DependencyObject currentChild )
-    {
-      return HeaderFooterItem.FindIDataGridItemContainerInChildren( headerFooterItem, currentChild, true );
-    }
-
-    internal static IDataGridItemContainer FindIDataGridItemContainerInChildren( HeaderFooterItem headerFooterItem, DependencyObject currentChild, bool checkRoot )
-    {
-      if( currentChild == null )
-        return null;
-
-      IDataGridItemContainer container = currentChild as IDataGridItemContainer;
-
-      if( checkRoot )
-      {
-        if( container != null )
-          return container;
-      }
-
-      int childCount = VisualTreeHelper.GetChildrenCount( currentChild );
-
-      for( int i = 0; i < childCount; i++ )
-      {
-        DependencyObject child = VisualTreeHelper.GetChild( currentChild, i );
-
-        if( child == null )
-          continue;
-
-        if( !HeaderFooterItem.IsPartOfHeaderFooterItemTemplate( child, headerFooterItem ) )
-        {
-          // We don't want to parse further the DataTemplate
-          return null;
-        }
-
-        container = child as IDataGridItemContainer;
-
-        if( container != null )
-          return container;
-
-        int innerChildCount = VisualTreeHelper.GetChildrenCount( child );
-
-        if( innerChildCount > 0 )
-          container = HeaderFooterItem.FindIDataGridItemContainerInChildren( headerFooterItem, child, false );
-
-        if( container != null )
-          return container;
-      }
-
-      return null;
-    }
-
-    private static bool IsPartOfHeaderFooterItemTemplate( DependencyObject element, HeaderFooterItem headerFooterItem )
-    {
-      while( element != null )
-      {
-        DependencyObject templatedParent = null;
-
-        var frameworkElement = element as FrameworkElement;
-        if( frameworkElement != null )
-        {
-          templatedParent = frameworkElement.TemplatedParent;
-        }
-        else
-        {
-          var frameworkContentElement = element as FrameworkContentElement;
-
-          if( frameworkContentElement != null )
-          {
-            templatedParent = frameworkContentElement.TemplatedParent;
-          }
-        }
-
-        if( templatedParent == headerFooterItem )
-          return true;
-
-        element = templatedParent;
-      }
-
-      return false;
-    }
-
-    #endregion INTERNAL METHODS
-
-    #region PRIVATE METHODS
-
     private void HeaderFooterItem_Loaded( object sender, RoutedEventArgs e )
     {
       if( m_loadedHandler != null )
@@ -459,85 +379,15 @@ namespace Xceed.Wpf.DataGrid
 
     private void PrepareContainerWorker()
     {
-      DependencyObject visualTree = this.AsVisual();
-
-      this.SetContainer( visualTree );
-
-      // If the root of a HeaderFooterItem is not a IDataGridItemContainer,
-      // drill down the VisualTree to ensure there are none
-      var container = HeaderFooterItem.FindIDataGridItemContainerInChildren( this, visualTree, true );
-
-      // Loop to prepare all IDataGridContainer found along the way.
-      while( container != null )
-      {
-        // Row based objects apply their template though their implementation of PrepareContainer.
-        // No need to call ApplyTemplate beforehand.
-        if( !( container is Row ) )
-        {
-          var frameworkElement = container as FrameworkElement;
-
-          if( frameworkElement != null )
-            frameworkElement.ApplyTemplate();
-        }
-
-        container.PrepareContainer( m_initializingDataGridContext, m_initializingDataItem );
-        container = HeaderFooterItem.FindIDataGridItemContainerInChildren( this, ( DependencyObject )container, false );
-      }
+      var rootContainer = this.AsVisual();
 
+      this.SetContainer( rootContainer );
 
+      m_itemContainerManager.Prepare( m_initializingDataGridContext, m_initializingDataItem );
       m_initializingDataGridContext = null;
       m_initializingDataItem = null;
     }
 
-    #endregion
-
-    #region PRIVATE FIELDS
-
-    private DataGridContext m_initializingDataGridContext; // = null
-    private object m_initializingDataItem; // = null
-
-    private static readonly Binding m_sIsCurrentInternalBinding;
-    private static readonly Binding m_sItemIndexBinding;
-    private static readonly Binding m_sIsBeingEditedInternalBinding;
-    private static readonly Binding m_sHasValidationErrorInternalBinding;
-    private static readonly Binding m_sRowSelectorVisibleBinding;
-    private static readonly Binding m_sRowSelectorStyleBinding;
-
-    private RoutedEventHandler m_loadedHandler;
-
-    #endregion
-
-    #region IPrintInfo Members
-
-    double IPrintInfo.GetPageRightOffset( double horizontalOffset, double viewportWidth )
-    {
-      IPrintInfo subPrintInfo = this.Content as IPrintInfo;
-
-      if( subPrintInfo != null )
-        return subPrintInfo.GetPageRightOffset( horizontalOffset, viewportWidth );
-
-      return horizontalOffset + viewportWidth;
-    }
-
-    void IPrintInfo.UpdateElementVisibility( double horizontalOffset, double viewportWidth, object state )
-    {
-      IPrintInfo subPrintInfo = this.AsVisual() as IPrintInfo;
-
-      if( subPrintInfo != null )
-        subPrintInfo.UpdateElementVisibility( horizontalOffset, viewportWidth, state );
-    }
-
-    object IPrintInfo.CreateElementVisibilityState()
-    {
-      IPrintInfo subPrintInfo = this.AsVisual() as IPrintInfo;
-      if( subPrintInfo == null )
-        return null;
-
-      return subPrintInfo.CreateElementVisibilityState();
-    }
-
-    #endregion
-
     #region IDataGridItemContainer Members
 
     void IDataGridItemContainer.PrepareContainer( DataGridContext dataGridContext, object item )
@@ -551,5 +401,16 @@ namespace Xceed.Wpf.DataGrid
     }
 
     #endregion
+
+    #region Private Fields
+
+    private readonly DataGridItemContainerManager m_itemContainerManager;
+
+    private DataGridContext m_initializingDataGridContext; // = null
+    private object m_initializingDataItem; // = null
+
+    private RoutedEventHandler m_loadedHandler;
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControl.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControl.cs
index 740e7d4a..fdc4d981 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControl.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControl.cs
@@ -14,19 +14,14 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
-using Xceed.Utils.Wpf.DragDrop;
-using System.Diagnostics;
-using System.Windows.Media;
 using System.Windows.Data;
-using Xceed.Utils.Wpf;
 using System.Windows.Documents;
-using Xceed.Wpf.DataGrid.Views;
-using System.ComponentModel;
+using System.Windows.Media;
+using Xceed.Utils.Wpf.DragDrop;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -302,7 +297,7 @@ namespace Xceed.Wpf.DataGrid
       Debug.Assert( groupLevelDescriptions != null );
 
       if( rootItem == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "rootItem is null." );
 
       foreach( object item in rootItem.Items )
       {
@@ -339,7 +334,7 @@ namespace Xceed.Wpf.DataGrid
       Debug.Assert( groupLevelDescription != null );
 
       if( rootItem == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "rootItem is null." );
 
       foreach( object item in rootItem.Items )
       {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControlNode.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControlNode.cs
index caf8cadb..0164decb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControlNode.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByControlNode.cs
@@ -14,18 +14,15 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Media;
-using Xceed.Utils.Wpf.DragDrop;
-using System.Diagnostics;
-using System.ComponentModel;
-using System.Collections.ObjectModel;
-using Xceed.Utils.Wpf;
 using System.Windows.Data;
 using System.Windows.Documents;
+using System.Windows.Media;
+using Xceed.Utils.Wpf.DragDrop;
 using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
@@ -788,7 +785,7 @@ namespace Xceed.Wpf.DataGrid
         HierarchicalGroupByControlNode draggedHierarchicalGroupByControlNode = HierarchicalGroupByItem.GetParentHierarchicalGroupByControlNode( hierarchicalGroupByItem );
 
         if( draggedHierarchicalGroupByControlNode == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "draggedHierarchicalGroupByControlNode is null." );
 
         if( draggedHierarchicalGroupByControlNode.GroupLevelDescriptions == this.GroupLevelDescriptions )
         {
@@ -840,7 +837,7 @@ namespace Xceed.Wpf.DataGrid
         HierarchicalGroupByControlNode draggedHierarchicalGroupByControlNode = HierarchicalGroupByItem.GetParentHierarchicalGroupByControlNode( hierarchicalGroupByItem );
 
         if( draggedHierarchicalGroupByControlNode == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "draggedHierarchicalGroupByControlNode is null." );
 
         if( draggedHierarchicalGroupByControlNode.GroupLevelDescriptions == this.GroupLevelDescriptions )
         {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByItem.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByItem.cs
index 28683f91..a3a5ee4e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByItem.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupByItem.cs
@@ -15,22 +15,20 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Text;
-using Xceed.Utils.Wpf.DragDrop;
-using System.Windows.Controls.Primitives;
+using System.Collections.ObjectModel;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Windows;
-using System.Windows.Input;
-using System.Collections.ObjectModel;
-using Xceed.Wpf.DataGrid.Views;
-using System.Windows.Resources;
-using System.Windows.Documents;
+using System.Windows.Controls.Primitives;
 using System.Windows.Data;
-using System.Diagnostics;
-using System.Security;
+using System.Windows.Documents;
+using System.Windows.Input;
 using System.Windows.Media;
 using Xceed.Utils.Wpf;
+using Xceed.Utils.Wpf.DragDrop;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
 {
@@ -138,6 +136,8 @@ namespace Xceed.Wpf.DataGrid
         else
         {
           DataGridContext dataGridContext = this.ParentDataGridContext;
+          if( dataGridContext == null )
+            throw new DataGridInternalException( "The " + typeof( HierarchicalGroupByItem ).Name + "'s DataGridContext cannot be null." );
           groupLevelDescriptions = dataGridContext.GroupLevelDescriptions;
         }
 
@@ -167,6 +167,8 @@ namespace Xceed.Wpf.DataGrid
         else
         {
           DataGridContext dataGridContext = this.ParentDataGridContext;
+          if( dataGridContext == null )
+            throw new DataGridInternalException( "The " + typeof( HierarchicalGroupByItem ).Name + "'s DataGridContext cannot be null." );
           sortDescriptions = dataGridContext.Items.SortDescriptions;
         }
 
@@ -253,7 +255,7 @@ namespace Xceed.Wpf.DataGrid
       HierarchicalGroupByControlNode hierarchicalGroupByControlNode = HierarchicalGroupByItem.GetParentHierarchicalGroupByControlNode( this );
 
       if( hierarchicalGroupByControlNode == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "hierarchicalGroupByControlNode is null." );
 
       bool allowGroupingModification = hierarchicalGroupByControlNode.IsGroupingModificationAllowed;
 
@@ -379,16 +381,7 @@ namespace Xceed.Wpf.DataGrid
           // all the HierarchicalGroupByItem will share the same DataGridContext
           // which is the one of the level where the HierarchicalGroupByControl
           // is located
-          DataGridContext dataGridContext;
-
-          try
-          {
-            dataGridContext = this.ParentDataGridContext;
-          }
-          catch( DataGridInternalException )
-          {
-            dataGridContext = null;
-          }
+          DataGridContext dataGridContext = this.ParentDataGridContext;
 
           if( ( dataGridContext != null ) && ( dataGridContext.SourceDetailConfiguration == null ) )
           {
@@ -408,9 +401,14 @@ namespace Xceed.Wpf.DataGrid
 
               if( ( column != null ) && ( column.AllowSort ) )
               {
-                SortingHelper.ToggleColumnSort(
-                  dataGridContext, this.ParentSortDescriptions,
-                  columns, column, ( ( Keyboard.Modifiers & ModifierKeys.Shift ) != ModifierKeys.Shift ) );
+                bool shiftUnpressed = ( ( Keyboard.Modifiers & ModifierKeys.Shift ) != ModifierKeys.Shift );
+
+                var toggleColumnSort = new HierarchicalGroupByItemToggleColumnSortCommand( this );
+
+                if( toggleColumnSort.CanExecute( column, shiftUnpressed ) )
+                {
+                  toggleColumnSort.Execute( column, shiftUnpressed );
+                }
 
                 e.Handled = true;
               }
@@ -592,9 +590,6 @@ namespace Xceed.Wpf.DataGrid
         if( hierarchicalGroupByControlNode != null )
           dataGridContext = hierarchicalGroupByControlNode.DataGridContext;
 
-        if( dataGridContext == null )
-          throw new DataGridInternalException( "The DataGridContext property must be set on a " + typeof( HierarchicalGroupByControlNode ) + "." );
-
         return dataGridContext;
       }
     }
@@ -722,7 +717,7 @@ namespace Xceed.Wpf.DataGrid
           throw new DataGridInternalException( "A ColumnManagerCell must have a DataGridContext." );
 
         if( draggedOverHierarchicalGroupByControlNode == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "draggedOverHierarchicalGroupByControlNode is null." );
 
         if( draggedOverHierarchicalGroupByControlNode.GroupLevelDescriptions == draggedCellDataGridContext.GroupLevelDescriptions )
         {
@@ -757,10 +752,10 @@ namespace Xceed.Wpf.DataGrid
         HierarchicalGroupByControlNode draggedOverHierarchicalGroupByControlNode = HierarchicalGroupByItem.GetParentHierarchicalGroupByControlNode( this );
 
         if( draggedHierarchicalGroupByControlNode == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "draggedHierarchicalGroupByControlNode is null." );
 
         if( draggedOverHierarchicalGroupByControlNode == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "draggedOverHierarchicalGroupByControlNode is null." );
 
         if( draggedHierarchicalGroupByControlNode.GroupLevelDescriptions == draggedOverHierarchicalGroupByControlNode.GroupLevelDescriptions )
         {
@@ -831,10 +826,10 @@ namespace Xceed.Wpf.DataGrid
         HierarchicalGroupByControlNode draggedOverHierarchicalGroupByControlNode = HierarchicalGroupByItem.GetParentHierarchicalGroupByControlNode( this );
 
         if( draggedHierarchicalGroupByControlNode == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "draggedHierarchicalGroupByControlNode is null." );
 
         if( draggedOverHierarchicalGroupByControlNode == null )
-          throw new DataGridInternalException();
+          throw new DataGridInternalException( "draggedOverHierarchicalGroupByControlNode is null." );
 
         if( draggedHierarchicalGroupByControlNode.GroupLevelDescriptions == draggedOverHierarchicalGroupByControlNode.GroupLevelDescriptions )
         {
@@ -937,5 +932,209 @@ namespace Xceed.Wpf.DataGrid
     private DropMarkAdorner m_dropMarkAdorner;
 
     #endregion
+
+    #region HierarchicalGroupByItemToggleColumnSortCommand Private Class
+
+    private sealed class HierarchicalGroupByItemToggleColumnSortCommand : ToggleColumnSortCommand
+    {
+      #region Constructor
+
+      internal HierarchicalGroupByItemToggleColumnSortCommand( HierarchicalGroupByItem target )
+        : base()
+      {
+        if( target == null )
+          throw new ArgumentNullException( "owner" );
+
+        m_target = new WeakReference( target );
+
+        if( target.ParentDataGridContext != null )
+        {
+          m_dataGridContext = new WeakReference( target.ParentDataGridContext );
+        }
+
+        DataGridContext groupByItemDataGridContext = DataGridControl.GetDataGridContext( target );
+        ToggleColumnSortCommand.ThrowIfNull( groupByItemDataGridContext, "groupByItemDataGridContext" );
+
+        DataGridControl dataGridControl = groupByItemDataGridContext.DataGridControl;
+        ToggleColumnSortCommand.ThrowIfNull( dataGridControl, "dataGridControl" );
+
+        m_dataGridControl = new WeakReference( dataGridControl );
+      }
+
+      #endregion
+
+      #region Properties
+
+      #region CanSort Protected Property
+
+      protected override bool CanSort
+      {
+        get
+        {
+          var datagrid = this.DataGridControl;
+          if( datagrid == null )
+            return false;
+
+          // When details are flatten, only the master may toggle a column.
+          if( this.DataGridControl.AreDetailsFlatten )
+            return false;
+
+          if( this.DataGridContext != null )
+          {
+            return this.DataGridContext.Items.CanSort;
+          }
+
+          return true;
+        }
+      }
+
+      #endregion
+
+      #region Columns Protected Property
+
+      protected override ColumnCollection Columns
+      {
+        get
+        {
+          var target = this.Target;
+          if( target == null )
+            return null;
+
+          return target.ParentColumns;
+        }
+      }
+
+      #endregion
+
+      #region DataGridContext Protected Property
+
+      protected override DataGridContext DataGridContext
+      {
+        get
+        {
+          return ( m_dataGridContext != null ) ? m_dataGridContext.Target as DataGridContext : null;
+        }
+      }
+
+      private readonly WeakReference m_dataGridContext;
+
+      #endregion   
+
+      #region DataGridControl Private Property
+
+      private DataGridControl DataGridControl
+      {
+        get
+        {
+          return ( m_dataGridControl != null ) ? m_dataGridControl.Target as DataGridControl : null;
+        }
+      }
+
+      private readonly WeakReference m_dataGridControl;
+
+      #endregion
+
+      #region MaxSortLevels Protected Property
+
+      protected override int MaxSortLevels
+      {
+        get
+        {
+          return -1;
+        }
+      }
+
+      #endregion
+
+      #region SortDescriptions Protected Property
+
+      protected override SortDescriptionCollection SortDescriptions
+      {
+        get
+        {
+          var target = this.Target;
+          if( target == null )
+            return null;
+
+          return target.ParentSortDescriptions;
+        }
+      }
+
+      #endregion
+
+      #region Target Private Property
+
+      private HierarchicalGroupByItem Target
+      {
+        get
+        {
+          return m_target.Target as HierarchicalGroupByItem;
+        }
+      }
+
+      private readonly WeakReference m_target;
+
+      #endregion
+
+      #endregion
+
+      #region Methods Override
+
+      protected override void ValidateToggleColumnSort()
+      {
+        Debug.Assert( !this.DataGridControl.AreDetailsFlatten, "A flatten detail should not be able to toggle the column sort direction." );
+      }
+
+      protected override SortDescriptionsSyncContext GetSortDescriptionsSyncContext()
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext != null )
+          return dataGridContext.SortDescriptionsSyncContext;
+
+        return this.DataGridControl.DataGridContext.SortDescriptionsSyncContext;
+      }
+
+      protected override void ValidateSynchronizationContext( SynchronizationContext synchronizationContext )
+      {
+        if( !synchronizationContext.Own )
+          throw new DataGridInternalException( "The column is already being processed.", this.DataGridControl );
+      }
+
+      protected override void DeferRestoreStateOnLevel( Disposer disposer )
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext != null )
+        {
+          ToggleColumnSortCommand.DeferRestoreStateOnLevel( disposer, dataGridContext );
+        }
+      }
+
+      protected override IDisposable DeferResortHelperItemsSourceCollection()
+      {
+        var dataGridContext = this.DataGridContext;
+
+        return ( dataGridContext != null )
+                ? this.DeferResortHelper( dataGridContext.ItemsSourceCollection, dataGridContext.Items )
+                : this.DeferResortHelper( this.DataGridControl.ItemsSource, this.DataGridControl.DataGridContext.Items );
+      }
+
+      protected override bool TryDeferResortSourceDetailConfiguration( out IDisposable defer )
+      {
+        var dataGridContext = this.DataGridContext;
+
+        return ( dataGridContext != null )
+                ? this.TryDeferResort( dataGridContext.SourceDetailConfiguration, out defer )
+                : this.TryDeferResort( this.DataGridControl.DataGridContext.SourceDetailConfiguration, out defer );
+      }
+
+      protected override IDisposable SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers triggers )
+      {
+        return this.DataGridControl.SetQueueBringIntoViewRestrictions( triggers );
+      }
+
+      #endregion
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupLevelIndicatorPane.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupLevelIndicatorPane.cs
index e3b87e15..0eb35768 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupLevelIndicatorPane.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/HierarchicalGroupLevelIndicatorPane.cs
@@ -33,6 +33,7 @@ namespace Xceed.Wpf.DataGrid
       FocusableProperty.OverrideMetadata( typeof( HierarchicalGroupLevelIndicatorPane ), new FrameworkPropertyMetadata( false ) );
 
       DataGridControl.ParentDataGridControlPropertyKey.OverrideMetadata( typeof( HierarchicalGroupLevelIndicatorPane ), new FrameworkPropertyMetadata( new PropertyChangedCallback( OnParentDataGridControlChanged ) ) );
+      DataGridControl.DataGridContextPropertyKey.OverrideMetadata( typeof( HierarchicalGroupLevelIndicatorPane ), new FrameworkPropertyMetadata( null, FrameworkPropertyMetadataOptions.Inherits, new PropertyChangedCallback( OnDataGridContextChanged ) ) );
     }
 
     #region GroupLevelIndicatorPaneHost Read-Only Property
@@ -136,14 +137,17 @@ namespace Xceed.Wpf.DataGrid
               //insert the Spacer GroupLevelIndicator in the panel
               panel.Children.Insert( 0, newGroupMargin );
 
-              //then create the GLIP for the running DataGridContext
-              GroupLevelIndicatorPane newSubGLIP = new GroupLevelIndicatorPane();
-              DataGridControl.SetDataGridContext( newSubGLIP, runningDataGridContext );
-              newSubGLIP.SetIsLeaf( false );
-              GroupLevelIndicatorPane.SetGroupLevel( newSubGLIP, -1 );
+              if( !runningDataGridContext.AreDetailsFlatten )
+              {
+                //then create the GLIP for the running DataGridContext
+                GroupLevelIndicatorPane newSubGLIP = new GroupLevelIndicatorPane();
+                DataGridControl.SetDataGridContext( newSubGLIP, runningDataGridContext );
+                newSubGLIP.SetIsLeaf( false );
+                GroupLevelIndicatorPane.SetGroupLevel( newSubGLIP, -1 );
 
-              //and insert it in the panel.
-              panel.Children.Insert( 0, newSubGLIP );
+                //and insert it in the panel.
+                panel.Children.Insert( 0, newSubGLIP );
+              }
 
               previousContext = runningDataGridContext;
               runningDataGridContext = runningDataGridContext.ParentDataGridContext;
@@ -157,27 +161,35 @@ namespace Xceed.Wpf.DataGrid
 
     private static void OnParentDataGridControlChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      HierarchicalGroupLevelIndicatorPane self = sender as HierarchicalGroupLevelIndicatorPane;
-      if( self != null )
+      HierarchicalGroupLevelIndicatorPane self = ( HierarchicalGroupLevelIndicatorPane )sender;
+      DataGridControl grid = e.OldValue as DataGridControl;
+
+      //unsubsribe from the old DataGridControl (the GLIP was disconnected)
+      if( grid != null )
       {
-        DataGridControl grid = e.OldValue as DataGridControl;
+        DetailsChangedEventManager.RemoveListener( grid, self );
+      }
 
-        //unsubsribe from the old DataGridControl (the GLIP was disconnected)
-        if( grid != null )
-        {
-          DetailsChangedEventManager.RemoveListener( grid, self );
-        }
+      grid = e.NewValue as DataGridControl;
 
-        grid = e.NewValue as DataGridControl;
+      //register to the parent grid control's Items Collection GroupDescriptions Changed event
+      if( grid != null )
+      {
+        self.PrepareDefaultStyleKey( grid.GetView() );
 
-        //register to the parent grid control's Items Collection GroupDescriptions Changed event
-        if( grid != null )
-        {
-          self.PrepareDefaultStyleKey( grid.GetView() );
+        DetailsChangedEventManager.AddListener( grid, self );
+        self.InvalidateMeasure();
+      }
+    }
 
-          DetailsChangedEventManager.AddListener( grid, self );
-          self.InvalidateMeasure();
-        }
+    private static void OnDataGridContextChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      HierarchicalGroupLevelIndicatorPane self = ( HierarchicalGroupLevelIndicatorPane )sender;
+      Panel panel = self.GroupLevelIndicatorPaneHost;
+
+      if( panel != null )
+      {
+        panel.Children.Clear();
       }
     }
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/IDataGridItemContainerExtensions.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/IDataGridItemContainerExtensions.cs
new file mode 100644
index 00000000..c1697628
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/IDataGridItemContainerExtensions.cs
@@ -0,0 +1,121 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Windows;
+using Xceed.Utils.Wpf;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal static class IDataGridItemContainerExtensions
+  {
+    internal static IEnumerable<IDataGridItemContainer> GetTemplatedDescendantDataGridItemContainers( this IDataGridItemContainer source )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      var predicate = IDataGridItemContainerExtensions.GetTemplatedDescendantExpandPredicate( source );
+
+      return IDataGridItemContainerExtensions.GetChildDataGridItemContainers( source, predicate );
+    }
+
+    internal static IEnumerable<IDataGridItemContainer> GetTemplatedChildDataGridItemContainers( this IDataGridItemContainer source )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      var predicate = IDataGridItemContainerExtensions.GetTemplatedChildExpandPredicate( source );
+
+      return IDataGridItemContainerExtensions.GetChildDataGridItemContainers( source, predicate );
+    }
+
+    private static IEnumerable<IDataGridItemContainer> GetChildDataGridItemContainers( IDataGridItemContainer source, Func<DependencyObject, bool> expand )
+    {
+      Debug.Assert( source != null );
+
+      var root = source as DependencyObject;
+      if( root == null )
+        throw new ArgumentException( "The source object must be a DependencyObject.", "source" );
+
+      return IDataGridItemContainerExtensions.GetChildDataGridItemContainers( root, expand );
+    }
+
+    private static IEnumerable<IDataGridItemContainer> GetChildDataGridItemContainers( DependencyObject source, Func<DependencyObject, bool> expand )
+    {
+      Debug.Assert( source != null );
+
+      if( expand == null )
+        throw new ArgumentNullException( "expand" );
+
+      var strategy = new DepthFirstSearchTreeTraversalStrategy();
+
+      return TreeHelper.GetDescendants<IDataGridItemContainer>( strategy, source, null, expand );
+    }
+
+    private static Func<DependencyObject, bool> GetTemplatedDescendantExpandPredicate( IDataGridItemContainer source )
+    {
+      var fe = source as FrameworkElement;
+      if( fe == null )
+        throw new ArgumentException( "The source object must be a FrameworkElement.", "source" );
+
+      return ( DependencyObject item ) => IDataGridItemContainerExtensions.IsPartOfTargetTemplate( item, fe );
+    }
+
+    private static Func<DependencyObject, bool> GetTemplatedChildExpandPredicate( IDataGridItemContainer source )
+    {
+      var fe = source as FrameworkElement;
+      if( fe == null )
+        throw new ArgumentException( "The source object must be a FrameworkElement.", "source" );
+
+      return ( DependencyObject item ) => IDataGridItemContainerExtensions.ExpandChild( item )
+                                       && IDataGridItemContainerExtensions.IsPartOfTargetTemplate( item, fe );
+    }
+
+    private static bool ExpandChild( DependencyObject container )
+    {
+      return ( container != null ) && !( container is IDataGridItemContainer );
+    }
+
+    private static bool IsPartOfTargetTemplate( DependencyObject element, FrameworkElement target )
+    {
+      while( element != null )
+      {
+        var templatedParent = IDataGridItemContainerExtensions.GetTemplatedParent( element );
+        if( templatedParent == target )
+          return true;
+
+        element = templatedParent;
+      }
+
+      return false;
+    }
+
+    private static DependencyObject GetTemplatedParent( DependencyObject element )
+    {
+      var fe = element as FrameworkElement;
+      if( fe != null )
+        return fe.TemplatedParent;
+
+      var fce = element as FrameworkContentElement;
+      if( fce != null )
+        return fce.TemplatedParent;
+
+      return null;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ValidationRules/FilterExpressionValidationRule.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/IGroupLevelDescription.cs
similarity index 51%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ValidationRules/FilterExpressionValidationRule.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/IGroupLevelDescription.cs
index 109d0662..a67a1889 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ValidationRules/FilterExpressionValidationRule.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/IGroupLevelDescription.cs
@@ -14,32 +14,52 @@
 
   ***********************************************************************************/
 
-using System;
 using System.Globalization;
+using System.Windows;
 using System.Windows.Controls;
 
-namespace Xceed.Wpf.DataGrid.ValidationRules
+namespace Xceed.Wpf.DataGrid
 {
-  internal class FilterExpressionValidationRule : ValidationRule
+  internal interface IGroupLevelDescription
   {
-    public FilterExpressionValidationRule( Type dataType )
+    string FieldName
     {
-      m_dataType = dataType;
+      get;
     }
 
-    public override ValidationResult Validate( object value, CultureInfo culture )
+    object Title
     {
-      string content = value as string;
+      get;
+    }
+
+    DataTemplate TitleTemplate
+    {
+      get;
+    }
 
-      if( !string.IsNullOrEmpty( content ) )
-      {
-        if( FilterParser.TryParse( content, m_dataType, CultureInfo.CurrentCulture ) == null )
-          return new ValidationResult( false, FilterParser.LastError );
-      }
+    DataTemplateSelector TitleTemplateSelector
+    {
+      get;
+    }
 
-      return ValidationResult.ValidResult;
+    DataTemplate ValueTemplate
+    {
+      get;
     }
 
-    private Type m_dataType;
+    DataTemplateSelector ValueTemplateSelector
+    {
+      get;
+    }
+
+    string ValueStringFormat
+    {
+      get;
+    }
+
+    CultureInfo ValueStringFormatCulture
+    {
+      get;
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemPropertyNameMap.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemPropertyNameMap.cs
new file mode 100644
index 00000000..885d4d5e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemPropertyNameMap.cs
@@ -0,0 +1,176 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ItemPropertyNameMap : FieldNameMap, INotifyCollectionChanged, IWeakEventListener
+  {
+    #region Constructors
+
+    internal ItemPropertyNameMap( DataGridItemPropertyCollection itemProperties )
+    {
+      if( itemProperties == null )
+        throw new ArgumentNullException( "itemProperties" );
+
+      m_dataGridItemPropertyCollection = new WeakReference( itemProperties );
+
+      CollectionChangedEventManager.AddListener( itemProperties, this );
+    }
+
+    #endregion
+
+    #region ItemProperties Internal Property
+
+    internal DataGridItemPropertyCollection ItemProperties
+    {
+      get
+      {
+        return ( DataGridItemPropertyCollection )m_dataGridItemPropertyCollection.Target;
+      }
+    }
+
+    private readonly WeakReference m_dataGridItemPropertyCollection; //null
+
+    #endregion
+
+    protected override bool TryGetSource( string targetName, out string sourceName )
+    {
+      var itemProperties = this.ItemProperties;
+      if( itemProperties == null )
+        throw new InvalidOperationException( "Garbage collection has been performed on the collection." );
+
+      sourceName = null;
+
+      if( !string.IsNullOrEmpty( targetName ) )
+      {
+        foreach( var itemProperty in itemProperties )
+        {
+          if( itemProperty.Synonym == targetName )
+          {
+            sourceName = itemProperty.Name;
+            break;
+          }
+        }
+      }
+
+      return ( sourceName != null );
+    }
+
+    protected override bool TryGetTarget( string sourceName, out string targetName )
+    {
+      var itemProperties = this.ItemProperties;
+      if( itemProperties == null )
+        throw new InvalidOperationException( "Garbage collection has been performed on the collection." );
+
+      targetName = null;
+
+      if( !string.IsNullOrEmpty( sourceName ) )
+      {
+        var itemProperty = itemProperties[ sourceName ];
+        if( ( itemProperty != null ) && !string.IsNullOrEmpty( itemProperty.Synonym ) )
+        {
+          targetName = itemProperty.Synonym;
+        }
+      }
+
+      return ( targetName != null );
+    }
+
+    private void OnItemPropertyCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+    {
+      Debug.Assert( sender == this.ItemProperties );
+
+      switch( e.Action )
+      {
+        case NotifyCollectionChangedAction.Reset:
+          this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+          break;
+
+        case NotifyCollectionChangedAction.Add:
+          if( ( e.NewItems == null ) || ( e.NewItems.Count != 1 ) )
+          {
+            this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+          }
+          else
+          {
+            this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, e.NewItems[ 0 ] ) );
+          }
+          break;
+
+        case NotifyCollectionChangedAction.Remove:
+          if( ( e.OldItems == null ) || ( e.OldItems.Count != 1 ) )
+          {
+            this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+          }
+          else
+          {
+            this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Remove, e.OldItems[ 0 ] ) );
+          }
+          break;
+
+        case NotifyCollectionChangedAction.Replace:
+          if( ( e.OldItems == null ) || ( e.NewItems == null ) || ( e.OldItems.Count != 1 ) || ( e.NewItems.Count != 1 ) )
+          {
+            this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+          }
+          else
+          {
+            this.RaiseCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Replace, e.NewItems[ 0 ], e.OldItems[ 0 ] ) );
+          }
+          break;
+
+        default:
+          break;
+      }
+    }
+
+    #region INotifyCollectionChanged Members
+
+    public event NotifyCollectionChangedEventHandler CollectionChanged;
+
+    private void RaiseCollectionChanged( NotifyCollectionChangedEventArgs e )
+    {
+      var handler = this.CollectionChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, e );
+    }
+
+    #endregion
+
+    #region IWeakEventListener Members
+
+    bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      if( managerType == typeof( CollectionChangedEventManager ) )
+      {
+        this.OnItemPropertyCollectionChanged( sender, ( NotifyCollectionChangedEventArgs )e );
+
+        return true;
+      }
+
+      return false;
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemsSourceHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemsSourceHelper.cs
index efa71273..518bb197 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemsSourceHelper.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ItemsSourceHelper.cs
@@ -15,33 +15,27 @@
   ***********************************************************************************/
 
 using System;
-using System.Xml;
-using System.Xml.XPath;
-using System.Globalization;
-using System.ComponentModel;
 using System.Collections;
 using System.Collections.Generic;
-using System.Text;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Data;
+using System.Data.Objects.DataClasses;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
-
-using Xceed.Utils;
+using System.Xml;
 using Xceed.Wpf.DataGrid.Converters;
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Data;
-using System.Collections.Specialized;
-using System.Reflection;
 using Xceed.Wpf.DataGrid.ValidationRules;
-using System.Data.Objects.DataClasses;
 
 namespace Xceed.Wpf.DataGrid
 {
-  internal class ItemsSourceHelper
+  internal static class ItemsSourceHelper
   {
-    #region PUBLIC STATIC METHODS
-
     public static bool IsSourceSupportingChangeNotification( object obj )
     {
       if( obj == null )
@@ -176,9 +170,7 @@ namespace Xceed.Wpf.DataGrid
       IList list = enumerable as IList;
 
       if( list != null )
-      {
         return ( ( list.Count > 0 ) ? list[ 0 ] : null );
-      }
 
       try
       {
@@ -186,7 +178,9 @@ namespace Xceed.Wpf.DataGrid
 
 
         if( enumerator.MoveNext() )
+        {
           current = enumerator.Current;
+        }
 
       }
       catch( NotSupportedException )
@@ -197,10 +191,7 @@ namespace Xceed.Wpf.DataGrid
       return current;
     }
 
-    public static object AddNewDataItem(
-      IEnumerable itemsSourceCollection,
-      DataGridControl dataGridControl,
-      out int itemIndex )
+    public static object AddNewDataItem( IEnumerable itemsSourceCollection, DataGridControl dataGridControl, out int itemIndex )
     {
       DataGridCollectionViewBase dataGridCollectionViewBase = itemsSourceCollection as DataGridCollectionViewBase;
 
@@ -281,11 +272,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public static void CancelNewDataItem(
-      IEnumerable itemsSourceCollection,
-      DataGridControl dataGridControl,
-      object newItem,
-      int newItemIndex )
+    public static void CancelNewDataItem( IEnumerable itemsSourceCollection, DataGridControl dataGridControl, object newItem, int newItemIndex )
     {
       DataGridCollectionViewBase dataGridCollectionViewBase = itemsSourceCollection as DataGridCollectionViewBase;
 
@@ -351,11 +338,7 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public static void EndNewDataItem(
-      IEnumerable itemsSourceCollection,
-      DataGridControl dataGridControl,
-      object newItem,
-      ref int newItemIndex )
+    public static void EndNewDataItem( IEnumerable itemsSourceCollection, DataGridControl dataGridControl, object newItem, ref int newItemIndex )
     {
       DataGridCollectionViewBase dataGridCollectionViewBase = itemsSourceCollection as DataGridCollectionViewBase;
 
@@ -435,9 +418,7 @@ namespace Xceed.Wpf.DataGrid
       list.Add( newItem );
     }
 
-    public static Dictionary<string, FieldDescriptor> GetFieldDescriptors(
-      PropertyDescriptorCollection properties,
-      bool supportDBNull )
+    public static Dictionary<string, FieldDescriptor> GetFieldDescriptors( PropertyDescriptorCollection properties, bool supportDBNull )
     {
       int fieldCount = properties.Count;
 
@@ -449,11 +430,7 @@ namespace Xceed.Wpf.DataGrid
       return fieldDescriptors;
     }
 
-    public static void ExtractFieldDescriptors(
-      string namePrefix,
-      PropertyDescriptorCollection properties,
-      bool supportDBNull,
-      Dictionary<string, FieldDescriptor> fieldDescriptors )
+    public static void ExtractFieldDescriptors( string namePrefix, PropertyDescriptorCollection properties, bool supportDBNull, Dictionary<string, FieldDescriptor> fieldDescriptors )
     {
       int propertyCount = properties.Count;
 
@@ -491,14 +468,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public static void GenerateColumnsFromItemsSourceFields(
-      ColumnCollection columns,
-      IDictionary<Type, CellEditor> defaultCellEditors,
-      Dictionary<string, FieldDescriptor> fields,
-      bool autoCreateForeignKeyConfigurations )
+    public static void GenerateColumnsFromItemsSourceFields( ColumnCollection columns, IDictionary<Type, CellEditor> defaultCellEditors, Dictionary<string, FieldDescriptor> fields,
+                                                             bool autoCreateForeignKeyConfigurations )
     {
-      DataGridControl dataGridControl = columns.DataGridControl;
-
       using( columns.DeferColumnAdditionMessages() )
       {
         foreach( FieldDescriptor field in fields.Values )
@@ -510,13 +482,11 @@ namespace Xceed.Wpf.DataGrid
 
           if( column == null )
           {
-            dataColumn = ItemsSourceHelper.CreateColumnFromItemsSourceField(
-              dataGridControl, defaultCellEditors, field, autoCreateForeignKeyConfigurations );
+            dataColumn = ItemsSourceHelper.CreateColumnFromItemsSourceField( defaultCellEditors, field, autoCreateForeignKeyConfigurations );
 
             if( dataColumn != null )
             {
               columns.Add( dataColumn );
-              ItemsSourceHelper.ApplySettingsRepositoryToColumn( dataColumn );
             }
           }
           else if( dataColumn != null )
@@ -604,31 +574,20 @@ namespace Xceed.Wpf.DataGrid
                 autoCreateForeignKeyConfigurations );
             }
 
-            // Disable warning for DisplayMemberBinding when internaly used
-#pragma warning disable 618
-
-            if( dataColumn.DisplayMemberBinding == null )
+            if( dataColumn.GetDisplayMemberBinding() == null )
             {
-              dataColumn.DisplayMemberBinding = ItemsSourceHelper.CreateDefaultBinding(
-                false, field.Name, field,
-                false, ( dataColumn.ReadOnly && !dataColumn.OverrideReadOnlyForInsertion ), dataType );
-
-              //mark the Column's Binding as AutoCreated.
+              dataColumn.SetDisplayMemberBinding( ItemsSourceHelper.CreateDefaultBinding( false, field.Name, field, dataColumn, false, dataType ) );
               dataColumn.IsBindingAutoCreated = true;
               dataColumn.IsBoundToDataGridUnboundItemProperty = field.IsDataGridUnboundItemProperty;
             }
 
-#pragma warning restore 618
+            column.DefaultCellRecyclingGroupDataType = dataType;
           }
         }
       } //end using
     }
 
-    public static Column CreateColumnFromItemsSourceField(
-      DataGridControl dataGridControl,
-      IDictionary<Type, CellEditor> defaultCellEditors,
-      FieldDescriptor field,
-      bool autoCreateForeignKeyConfigurations )
+    public static Column CreateColumnFromItemsSourceField( IDictionary<Type, CellEditor> defaultCellEditors, FieldDescriptor field, bool autoCreateForeignKeyConfigurations )
     {
       if( ( field.IsASubRelationship ) || ( !field.Browsable ) )
         return null;
@@ -646,21 +605,14 @@ namespace Xceed.Wpf.DataGrid
       // We only set ReadOnly when the value is true in order for the inheritence chain to work.  
       // Otherwise, the column value is always used instead of the row or grid value.
       if( readOnly )
+      {
         dataColumn.ReadOnly = readOnly;
+      }
 
       dataColumn.OverrideReadOnlyForInsertion = overrideReadOnlyForInsertion;
       dataColumn.Title = field.DisplayName;
 
-      // Disable warning for DisplayMemberBinding when internaly used
-#pragma warning disable 618
-
-      dataColumn.DisplayMemberBinding = ItemsSourceHelper.CreateDefaultBinding(
-        false, field.Name, field,
-        false, ( readOnly && !overrideReadOnlyForInsertion ), dataType );
-
-#pragma warning restore 618
-
-      //mark the Column's Binding as AutoCreated.
+      dataColumn.SetDisplayMemberBinding( ItemsSourceHelper.CreateDefaultBinding( false, field.Name, field, dataColumn, false, dataType ) );
       dataColumn.IsBindingAutoCreated = true;
       dataColumn.IsBoundToDataGridUnboundItemProperty = field.IsDataGridUnboundItemProperty;
 
@@ -699,36 +651,64 @@ namespace Xceed.Wpf.DataGrid
       }
 
       dataColumn.CellEditor = cellEditor;
+      dataColumn.DefaultCellRecyclingGroupDataType = dataType;
+
       return dataColumn;
     }
 
-    private static void ApplySettingsRepositoryToColumn( ColumnBase column )
+    public static ICustomTypeDescriptor GetCustomTypeDescriptor( IEnumerable itemsSource, Type itemType )
     {
+      var firstItem = ItemsSourceHelper.GetFirstItemByEnumerable( itemsSource );
+
+      var descriptor = firstItem as ICustomTypeDescriptor;
+      if( descriptor != null )
+      {
+        if( !( descriptor is DataItemTypeDescriptor ) )
+        {
+          descriptor = DataItemTypeDescriptionProvider.GetTypeDescriptor( itemType, descriptor );
+        }
+      }
+      else
+      {
+        descriptor = ItemsSourceHelper.GetCustomTypeDescriptor( firstItem, itemType );
+      }
+
+      return descriptor;
     }
 
-    public static System.Windows.Data.Binding CreateDefaultBinding(
-      bool dataItemIsDataRow,
-      string fieldName,
-      FieldDescriptor sourceField,
-      bool supportDBNull,
-      bool readOnly,
-      Type dataType )
+    public static ICustomTypeDescriptor GetCustomTypeDescriptor( object firstItem, Type itemType )
     {
-      DataGridBindingInfo bindingInfo = new DataGridBindingInfo();
+      var descriptionProvider = TypeDescriptor.GetProvider( itemType );
+      if( !( descriptionProvider is DataItemTypeDescriptionProvider ) )
+      {
+        descriptionProvider = new DataItemTypeDescriptionProvider( descriptionProvider );
+      }
+
+      return descriptionProvider.GetTypeDescriptor( itemType, firstItem );
+    }
 
+    public static System.Windows.Data.Binding CreateDefaultBinding( bool dataItemIsDataRow, string fieldName, FieldDescriptor sourceField, ColumnBase column, bool supportDBNull,
+                                                                    Type dataType )
+    {
+      DataGridBindingInfo bindingInfo = new DataGridBindingInfo();
       PropertyDescriptor propertyDescriptor = null;
       string bindingPath = null;
       string bindingXPath = null;
+      bool readOnly;
 
       if( sourceField != null )
       {
         dataType = sourceField.DataType;
         supportDBNull = sourceField.SupportDBNull;
-        readOnly |= ( sourceField.ReadOnly && !sourceField.OverrideReadOnlyForInsertion );
+        readOnly = ( sourceField.ReadOnly && !sourceField.OverrideReadOnlyForInsertion );
         propertyDescriptor = sourceField.PropertyDescriptor;
         bindingXPath = sourceField.BindingXPath;
         bindingPath = sourceField.BindingPath;
       }
+      else
+      {
+        readOnly = ( column.ReadOnly && !column.OverrideReadOnlyForInsertion );
+      }
 
       if( dataItemIsDataRow )
       {
@@ -752,7 +732,7 @@ namespace Xceed.Wpf.DataGrid
       }
 
       bindingInfo.ReadOnly = readOnly;
-      bindingInfo.Converter = new SourceDataConverter( supportDBNull );
+      bindingInfo.Converter = new ReadOnlyConverter( column, supportDBNull );
 
       bindingInfo.ValidationRules.Add( new SourceDataConverterValidationRule( supportDBNull, dataType ) );
 
@@ -816,89 +796,114 @@ namespace Xceed.Wpf.DataGrid
       return ItemsSourceHelper.GetFieldsForItemType( itemsSource, itemType, supportsDBNull );
     }
 
-    private static Dictionary<string, FieldDescriptor> GetFieldsForItemType( IEnumerable itemsSource, Type itemType, bool supportsDBNull )
+    public static Dictionary<string, FieldDescriptor> GetFields( Dictionary<string, FieldDescriptor> masterFields, FieldNameMap fieldMap, IEnumerable itemsSource, Type itemType )
     {
-      if( itemType == null )
-        return new Dictionary<string, FieldDescriptor>();
-
-      if( typeof( XmlNode ).IsAssignableFrom( itemType ) )
-        return new Dictionary<string, FieldDescriptor>();
-
-      if( itemType.IsArray )
-        return ItemsSourceHelper.GetFieldsForJaggedArray( itemType, itemsSource );
+      Dictionary<string, FieldDescriptor> fieldDescriptors;
+      DataGridCollectionViewBase dataGridCollectionViewBase = itemsSource as DataGridCollectionViewBase;
 
-      if( itemType.IsInterface )
-        return ItemsSourceHelper.GetFieldsForInterface( itemType );
+      if( dataGridCollectionViewBase != null )
+      {
+        var itemProperties = dataGridCollectionViewBase.ItemProperties;
 
-      if( ItemsSourceHelper.IsEntityFramework( itemType ) )
-        return ItemsSourceHelper.GetFieldsForEntityFramework( itemType );
+        fieldDescriptors = new Dictionary<string, FieldDescriptor>( itemProperties.Count );
 
-      TypeDescriptionProvider typeDescriptionProvider = TypeDescriptor.GetProvider( itemType );
-      object firstItem = ItemsSourceHelper.GetFirstItemByEnumerable( itemsSource );
+        foreach( var itemProperty in itemProperties )
+        {
+          string detailFieldName = itemProperty.Name;
+          string masterFieldName;
 
-      ICustomTypeDescriptor customTypeDescriptor = firstItem as ICustomTypeDescriptor;
+          if( !fieldMap.TryGetColumnFieldName( detailFieldName, out masterFieldName ) )
+          {
+            Debug.WriteLine( string.Format( "No mapping was found for the item property." ) );
+            continue;
+          }
 
-      if( customTypeDescriptor == null )
-        customTypeDescriptor = typeDescriptionProvider.GetTypeDescriptor( itemType, firstItem );
+          FieldDescriptor masterField;
+          if( !masterFields.TryGetValue( masterFieldName, out masterField ) )
+          {
+            Debug.WriteLine( string.Format( "An item property is mapped to a non-existent master field." ) );
+            continue;
+          }
 
-      if( ItemsSourceHelper.IsValueType( itemType ) )
-      {
-        Dictionary<string, FieldDescriptor> fieldDescriptors = new Dictionary<string, FieldDescriptor>();
+          FieldDescriptor detailField = ItemsSourceHelper.CreateFieldFromDataGridItemProperty( itemProperty );
+          if( detailField.DataType != masterField.DataType )
+          {
+            Debug.WriteLine( string.Format( "The data type of an item property doesn't match the data type of its master field." ) );
+            continue;
+          }
 
-        fieldDescriptors.Add( ".", new FieldDescriptor( ".",
-                                                        string.Empty,
-                                                        itemType,
-                                                        null,
-                                                        null,
-                                                        ".",
-                                                        true,
-                                                        false,
-                                                        supportsDBNull,
-                                                        true,
-                                                        ItemsSourceHelper.IsASubRelationship( itemType ),
-                                                        false,
-                                                        null ) );
+          FieldDescriptor oldDetailField;
+          if( fieldDescriptors.TryGetValue( masterFieldName, out oldDetailField ) )
+          {
+            Debug.WriteLine( string.Format( "Another detail field is already linked to the master field." ) );
+            continue;
+          }
 
-        return fieldDescriptors;
+          fieldDescriptors.Add( masterFieldName, detailField );
+        }
       }
-      else if( customTypeDescriptor != null )
+      else
       {
-        string className = customTypeDescriptor.GetClassName();
-
-        Type customType = ( className == null ) ? null : Type.GetType( className );
+        fieldDescriptors = ItemsSourceHelper.GetFields( itemsSource, itemType );
+        var fieldNames = fieldDescriptors.Keys.ToArray();
 
-        if( ( customType != null ) && ( ItemsSourceHelper.IsValueType( customType ) ) )
+        foreach( var fieldName in fieldNames )
         {
-          Dictionary<string, FieldDescriptor> fieldDescriptors = new Dictionary<string, FieldDescriptor>();
+          string detailFieldName = fieldName;
+          string masterFieldName;
 
-          DataGridForeignKeyDescription foreignKeyDescription = null;
+          if( !fieldMap.TryGetColumnFieldName( detailFieldName, out masterFieldName ) )
+          {
+            fieldDescriptors.Remove( detailFieldName );
+            continue;
+          }
 
-          // Try to retreive the ForeignKeyDescription if the field is an Enum
-          if( ( itemType != null ) && ( itemType.IsEnum ) )
+          FieldDescriptor masterField;
+          if( !masterFields.TryGetValue( masterFieldName, out masterField ) )
           {
-            foreignKeyDescription = ItemsSourceHelper.GetDataGridForeignKeyDescriptionForEnum( itemType );
+            fieldDescriptors.Remove( masterFieldName );
+
+            Debug.WriteLine( string.Format( "An item property is mapped to a non-existent master field." ) );
+            continue;
           }
 
-          fieldDescriptors.Add( ".", new FieldDescriptor( ".",
-                                                          string.Empty,
-                                                          itemType,
-                                                          null,
-                                                          null,
-                                                          ".",
-                                                          true,
-                                                          false,
-                                                          supportsDBNull,
-                                                          true,
-                                                          ItemsSourceHelper.IsASubRelationship( itemType ),
-                                                          false,
-                                                          foreignKeyDescription ) );
-
-          return fieldDescriptors;
+          FieldDescriptor detailField = fieldDescriptors[ fieldName ];
+          if( detailField.DataType != masterField.DataType )
+          {
+            fieldDescriptors.Remove( fieldName );
+
+            Debug.WriteLine( string.Format( "The data type of an item property doesn't match the data type of its master field." ) );
+            continue;
+          }
         }
       }
 
+      return fieldDescriptors;
+    }
+
+    private static Dictionary<string, FieldDescriptor> GetFieldsForItemType( IEnumerable itemsSource, Type itemType, bool supportsDBNull )
+    {
+      if( itemType == null )
+        return new Dictionary<string, FieldDescriptor>();
+
+      if( typeof( XmlNode ).IsAssignableFrom( itemType ) )
+        return new Dictionary<string, FieldDescriptor>();
+
+      if( itemType.IsArray )
+        return ItemsSourceHelper.GetFieldsForJaggedArray( itemType, itemsSource );
+
+      if( itemType.IsInterface )
+        return ItemsSourceHelper.GetFieldsForInterface( itemType );
+
+      if( ItemsSourceHelper.IsEntityFramework( itemType ) )
+        return ItemsSourceHelper.GetFieldsForEntityFramework( itemType );
+
+      if( ItemsSourceHelper.IsValueType( itemType ) )
+        return ItemsSourceHelper.GetFieldsForValueType( itemType, supportsDBNull );
+
+      var customTypeDescriptor = ItemsSourceHelper.GetCustomTypeDescriptor( itemsSource, itemType );
       if( customTypeDescriptor != null )
-        return ItemsSourceHelper.GetFieldDescriptors( customTypeDescriptor.GetProperties(), supportsDBNull );
+        return ItemsSourceHelper.GetFieldsForCustomTypeDescriptor( customTypeDescriptor, itemType, supportsDBNull );
 
       return ItemsSourceHelper.GetFieldDescriptors( TypeDescriptor.GetProperties( itemType ), supportsDBNull );
     }
@@ -1058,24 +1063,16 @@ namespace Xceed.Wpf.DataGrid
         }
         else if( dataColumn.IsBindingAutoCreated )
         {
-          // Disable warning for DisplayMemberBinding when internaly used
-#pragma warning disable 618
-
-          //clear the display member binding.
-          dataColumn.DisplayMemberBinding = null;
-
-#pragma warning restore 618
-
           dataColumn.IsBindingAutoCreated = false;
           dataColumn.IsBoundToDataGridUnboundItemProperty = false;
+          dataColumn.SetDisplayMemberBinding( null );
         }
       }
     }
 
     public static FieldDescriptor CreateFieldFromDataGridItemProperty( DataGridItemPropertyBase itemProperty )
     {
-      DataGridItemPropertyBase.PropertyDescriptorFromItemPropertyBase propertyDescriptor =
-        itemProperty.GetPropertyDescriptorForBinding();
+      var propertyDescriptor = itemProperty.GetPropertyDescriptorForBinding();
 
       string name = propertyDescriptor.Name;
       Type type = propertyDescriptor.PropertyType;
@@ -1097,12 +1094,8 @@ namespace Xceed.Wpf.DataGrid
                                   itemProperty.ForeignKeyDescription );
     }
 
-    public static void UpdateColumnsOnItemsPropertiesChanged( 
-      DataGridControl dataGridControl, 
-      ColumnCollection columns,
-      bool autoCreateForeignKeyConfigurations,
-      NotifyCollectionChangedEventArgs e,
-      DataGridItemPropertyCollection itemProperties )
+    public static void UpdateColumnsOnItemsPropertiesChanged( DataGridControl dataGridControl, ColumnCollection columns, bool autoCreateForeignKeyConfigurations,
+                                                              NotifyCollectionChangedEventArgs e, DataGridItemPropertyCollection itemProperties )
     {
       if( dataGridControl == null )
         return;
@@ -1118,14 +1111,13 @@ namespace Xceed.Wpf.DataGrid
               if( columns[ name ] == null )
               {
                 Column column = ItemsSourceHelper.CreateColumnFromItemsSourceField(
-                  dataGridControl, dataGridControl.DefaultCellEditors,
+                  dataGridControl.DefaultCellEditors,
                   ItemsSourceHelper.CreateFieldFromDataGridItemProperty( itemProperty ),
                   autoCreateForeignKeyConfigurations );
 
                 if( column != null )
                 {
                   columns.Add( column );
-                  ItemsSourceHelper.ApplySettingsRepositoryToColumn( column );
                 }
               }
             }
@@ -1169,14 +1161,13 @@ namespace Xceed.Wpf.DataGrid
               if( columns[ name ] == null )
               {
                 Column column = ItemsSourceHelper.CreateColumnFromItemsSourceField(
-                  dataGridControl, dataGridControl.DefaultCellEditors,
+                  dataGridControl.DefaultCellEditors,
                   ItemsSourceHelper.CreateFieldFromDataGridItemProperty( itemProperty ),
                   autoCreateForeignKeyConfigurations );
 
                 if( column != null )
                 {
                   columns.Add( column );
-                  ItemsSourceHelper.ApplySettingsRepositoryToColumn( column );
                 }
               }
             }
@@ -1203,14 +1194,13 @@ namespace Xceed.Wpf.DataGrid
               if( columns[ name ] == null )
               {
                 Column column = ItemsSourceHelper.CreateColumnFromItemsSourceField(
-                  dataGridControl, dataGridControl.DefaultCellEditors,
+                  dataGridControl.DefaultCellEditors,
                   ItemsSourceHelper.CreateFieldFromDataGridItemProperty( itemProperty ),
                   autoCreateForeignKeyConfigurations );
 
                 if( column != null )
                 {
                   columns.Add( column );
-                  ItemsSourceHelper.ApplySettingsRepositoryToColumn( column );
                 }
               }
             }
@@ -1221,13 +1211,36 @@ namespace Xceed.Wpf.DataGrid
         //case NotifyCollectionChangedAction.Move:
         default:
           break;
-
       }
     }
 
-    #endregion PUBLIC STATIC METHODS
+    internal static System.Windows.Data.Binding AutoCreateDisplayMemberBinding( Column column, DataGridContext dataGridContext, object dataItem, out bool isDataGridUnboundItemProperty )
+    {
+      System.Windows.Data.Binding displayMemberBinding = null;
 
-    #region PRIVATE STATIC METHODS
+      if( column == null )
+        throw new ArgumentNullException( "column" );
+
+      string name = column.FieldName;
+
+      // Don't create the default binding if FieldName is null and we're in design-time.
+      if( !string.IsNullOrEmpty( name ) )
+      {
+        ItemsSourceHelper.FieldDescriptor fieldDescriptor;
+        dataGridContext.ItemsSourceFieldDescriptors.TryGetValue( name, out fieldDescriptor );
+
+        isDataGridUnboundItemProperty = ( fieldDescriptor == null ) ? false :
+          fieldDescriptor.IsDataGridUnboundItemProperty;
+
+        displayMemberBinding = ItemsSourceHelper.CreateDefaultBinding( dataItem is DataRow, name, fieldDescriptor, column, false, typeof( object ) );
+      }
+      else
+      {
+        isDataGridUnboundItemProperty = false;
+      }
+
+      return displayMemberBinding;
+    }
 
     private static Type GetTypedListIndexerType( Type listType )
     {
@@ -1357,9 +1370,8 @@ namespace Xceed.Wpf.DataGrid
       return fieldDescriptors;
     }
 
-    private static Dictionary<string, FieldDescriptor> GetFieldsForDataGridCollectionViewBase(
-      DataGridCollectionViewBase dataGridCollectionViewBase,
-      DataGridItemPropertyCollection itemProperties )
+    private static Dictionary<string, FieldDescriptor> GetFieldsForDataGridCollectionViewBase( DataGridCollectionViewBase dataGridCollectionViewBase,
+                                                                                               DataGridItemPropertyCollection itemProperties )
     {
       int fieldCount = itemProperties.Count;
 
@@ -1388,9 +1400,7 @@ namespace Xceed.Wpf.DataGrid
       return fieldDescriptors;
     }
 
-    private static Dictionary<string, FieldDescriptor> GetFieldsForJaggedArray(
-      Type itemType,
-      IEnumerable jaggedArray )
+    private static Dictionary<string, FieldDescriptor> GetFieldsForJaggedArray( Type itemType, IEnumerable jaggedArray )
     {
       int fieldCount = 0;
       IEnumerator enumerator = jaggedArray.GetEnumerator();
@@ -1479,8 +1489,55 @@ namespace Xceed.Wpf.DataGrid
       return fieldDescriptors;
     }
 
-    private static Dictionary<string, ForeignKeyConstraint> GetForeignKeyConstraints(
-      ConstraintCollection constraints )
+    private static Dictionary<string, FieldDescriptor> GetFieldsForValueType( Type itemType, bool supportsDBNull )
+    {
+      return ItemsSourceHelper.GetFieldsForValueType( itemType, supportsDBNull, null );
+    }
+
+    private static Dictionary<string, FieldDescriptor> GetFieldsForValueType( Type itemType, bool supportsDBNull, DataGridForeignKeyDescription foreignKeyDescription )
+    {
+      Dictionary<string, FieldDescriptor> fieldDescriptors = new Dictionary<string, FieldDescriptor>();
+      FieldDescriptor fieldDescriptor = new FieldDescriptor( ".",
+                                                             string.Empty,
+                                                             itemType,
+                                                             null,
+                                                             null,
+                                                             ".",
+                                                             true,
+                                                             false,
+                                                             supportsDBNull,
+                                                             true,
+                                                             ItemsSourceHelper.IsASubRelationship( itemType ),
+                                                             false,
+                                                             foreignKeyDescription );
+
+      fieldDescriptors.Add( ".", fieldDescriptor );
+
+      return fieldDescriptors;
+    }
+
+    private static Dictionary<string, FieldDescriptor> GetFieldsForCustomTypeDescriptor( ICustomTypeDescriptor customTypeDescriptor, Type itemType, bool supportsDBNull )
+    {
+      var className = customTypeDescriptor.GetClassName();
+      var customType = ( className == null ) ? null : Type.GetType( className );
+
+      if( ( customType != null ) && ( ItemsSourceHelper.IsValueType( customType ) ) )
+      {
+        DataGridForeignKeyDescription foreignKeyDescription = null;
+
+        // Try to retreive the ForeignKeyDescription if the field is an Enum
+        if( ( itemType != null ) && ( itemType.IsEnum ) )
+        {
+          foreignKeyDescription = ItemsSourceHelper.GetDataGridForeignKeyDescriptionForEnum( itemType );
+        }
+
+        return ItemsSourceHelper.GetFieldsForValueType( itemType, supportsDBNull, foreignKeyDescription );
+      }
+
+      return ItemsSourceHelper.GetFieldDescriptors( customTypeDescriptor.GetProperties(), supportsDBNull );
+    }
+
+    private static Dictionary<string, ForeignKeyConstraint> GetForeignKeyConstraints( ConstraintCollection constraints )
     {
       Dictionary<string, ForeignKeyConstraint> foreignKeyConstraints =
         new Dictionary<string, ForeignKeyConstraint>();
@@ -1525,8 +1582,7 @@ namespace Xceed.Wpf.DataGrid
       return foreignKeyDescription;
     }
 
-    private static DataTableForeignKeyDescription GetDataGridForeignKeyDescriptionForForeignKeyConstraint(
-      ForeignKeyConstraint foreignKeyConstraint )
+    private static DataTableForeignKeyDescription GetDataGridForeignKeyDescriptionForForeignKeyConstraint( ForeignKeyConstraint foreignKeyConstraint )
     {
       DataTableForeignKeyDescription foreignKeyDescription = null;
 
@@ -1544,9 +1600,7 @@ namespace Xceed.Wpf.DataGrid
       return foreignKeyDescription;
     }
 
-    #endregion PRIVATE STATIC METHODS
-
-    #region PRIVATE FIELDS
+    #region Static Fields
 
     private static readonly object[] EmptyObjectArray = new object[ 0 ];
 
@@ -1554,14 +1608,12 @@ namespace Xceed.Wpf.DataGrid
       "System.Data.Objects.DataClasses.EntityObject, System.Data.Entity, Version=" + _XceedVersionInfo.FrameworkVersion + ", Culture=neutral, PublicKeyToken=b77a5c561934e089",
       false, false );
 
-    #endregion PRIVATE FIELDS
+    #endregion
 
-    #region FieldDescriptor NESTED CLASSES
+    #region FieldDescriptor Nested Type
 
     internal class FieldDescriptor
     {
-      #region CONSTRUCTORS
-
       public FieldDescriptor(
         string name,
         string displayName,
@@ -1601,8 +1653,6 @@ namespace Xceed.Wpf.DataGrid
         this.ForeignKeyDescription = foreignKeyDescription;
       }
 
-      #endregion CONSTRUCTORS
-
       #region Name PROPERTY
 
       public string Name
@@ -1783,7 +1833,7 @@ namespace Xceed.Wpf.DataGrid
 
       #endregion IsDataGridUnboundItemProperty Property
 
-      #region ForeignKeyDescription
+      #region ForeignKeyDescription Property
 
       public DataGridForeignKeyDescription ForeignKeyDescription
       {
@@ -1793,14 +1843,8 @@ namespace Xceed.Wpf.DataGrid
 
       #endregion
 
-      #region Private Fields
-
       private BitVector32 m_flags = new BitVector32();
 
-      #endregion
-
-      #region FieldDescriptor Flags
-
       [Flags]
       private enum FieldDescriptorFlags
       {
@@ -1812,40 +1856,37 @@ namespace Xceed.Wpf.DataGrid
         OverrideReadOnlyForInsertion = 32,
         IsDataGridUnboundItemProperty = 64
       }
-
-      #endregion
     }
 
-    #endregion NESTED CLASSES
+    #endregion
 
-    internal static System.Windows.Data.Binding AutoCreateDisplayMemberBinding( Column column, DataGridContext dataGridContext, object dataItem, out bool isDataGridUnboundItemProperty )
-    {
-      System.Windows.Data.Binding displayMemberBinding = null;
-
-      if( column == null )
-        throw new ArgumentNullException( "column" );
+    #region ReadOnlyConverter Private Class
 
-      string name = column.FieldName;
-
-      // Don't create the default binding if FieldName is null and we're in design-time.
-      if( !string.IsNullOrEmpty( name ) )
+    private sealed class ReadOnlyConverter : IValueConverter
+    {
+      internal ReadOnlyConverter( ColumnBase column, bool supportDBNull )
       {
-        ItemsSourceHelper.FieldDescriptor fieldDescriptor;
-        dataGridContext.ItemsSourceFieldDescriptors.TryGetValue( name, out fieldDescriptor );
-
-        isDataGridUnboundItemProperty = ( fieldDescriptor == null ) ? false :
-          fieldDescriptor.IsDataGridUnboundItemProperty;
+        m_converter = new SourceDataConverter( supportDBNull );
+        m_column = column;
+      }
 
-        displayMemberBinding = ItemsSourceHelper.CreateDefaultBinding(
-          dataItem is DataRow, name, fieldDescriptor,
-          false, ( column.ReadOnly && !column.OverrideReadOnlyForInsertion ), typeof( object ) );
+      public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
+      {
+        return m_converter.Convert( value, targetType, parameter, culture );
       }
-      else
+
+      public object ConvertBack( object value, Type targetType, object parameter, CultureInfo culture )
       {
-        isDataGridUnboundItemProperty = false;
+        if( ( m_column != null ) && ( m_column.ReadOnly ) && ( !m_column.OverrideReadOnlyForInsertion ) )
+          return Binding.DoNothing;
+
+        return m_converter.ConvertBack( value, targetType, parameter, culture );
       }
 
-      return displayMemberBinding;
+      private readonly IValueConverter m_converter;
+      private readonly ColumnBase m_column;
     }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/LateGroupLevelDescription.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/LateGroupLevelDescription.cs
new file mode 100644
index 00000000..d2df5e8c
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/LateGroupLevelDescription.cs
@@ -0,0 +1,431 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class LateGroupLevelDescription : IGroupLevelDescription, INotifyPropertyChanged, IWeakEventListener
+  {
+    #region Constructor
+
+    internal LateGroupLevelDescription( GroupDescription groupDescription, IEnumerable<GroupLevelDescription> groupLevelDescriptions )
+    {
+      if( groupDescription == null )
+        throw new ArgumentNullException( "groupDescription" );
+
+      var finder = new GroupLevelDescriptionFinder( groupDescription, groupLevelDescriptions );
+
+      m_groupDescription = groupDescription;
+      m_groupLevelDescription = finder.GroupLevelDescription;
+
+      if( m_groupLevelDescription == null )
+      {
+        m_finder = finder;
+        m_finder.PropertyChanged += new PropertyChangedEventHandler( this.OnGroupLevelDescriptionFound );
+      }
+      else
+      {
+        finder.Dispose();
+
+        PropertyChangedEventManager.AddListener( m_groupLevelDescription, this, string.Empty );
+      }
+    }
+
+    #endregion
+
+    #region GroupDescription Property
+
+    public GroupDescription GroupDescription
+    {
+      get
+      {
+        return m_groupDescription;
+      }
+    }
+
+    private readonly GroupDescription m_groupDescription;
+
+    #endregion
+
+    #region FieldName Property
+
+    public string FieldName
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.FieldName;
+      }
+    }
+
+    #endregion
+
+    #region Title Property
+
+    public object Title
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.Title;
+      }
+    }
+
+    #endregion
+
+    #region TitleTemplate Property
+
+    public DataTemplate TitleTemplate
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.TitleTemplate;
+      }
+    }
+
+    #endregion
+
+    #region TitleTemplateSelector Property
+
+    public DataTemplateSelector TitleTemplateSelector
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.TitleTemplateSelector;
+      }
+    }
+
+    #endregion
+
+    #region ValueStringFormat Property
+
+    public string ValueStringFormat
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.ValueStringFormat;
+      }
+    }
+
+    #endregion
+
+    #region ValueStringFormatCulture Property
+
+    public CultureInfo ValueStringFormatCulture
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.ValueStringFormatCulture;
+      }
+    }
+
+    #endregion
+
+    #region ValueTemplate Property
+
+    public DataTemplate ValueTemplate
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.ValueTemplate;
+      }
+    }
+
+    #endregion
+
+    #region ValueTemplateSelector Property
+
+    public DataTemplateSelector ValueTemplateSelector
+    {
+      get
+      {
+        GroupLevelDescription description;
+        if( !this.TryGetGroupLevelDescription( out description ) )
+          return null;
+
+        return description.ValueTemplateSelector;
+      }
+    }
+
+    #endregion
+
+    internal void Clear()
+    {
+      this.ClearLateBinding();
+
+      this.PropertyChanged = null;
+    }
+
+    private void ClearLateBinding()
+    {
+      if( m_finder != null )
+      {
+        m_finder.PropertyChanged -= new PropertyChangedEventHandler( this.OnGroupLevelDescriptionFound );
+        m_finder.Dispose();
+        m_finder = null;
+      }
+
+      if( m_groupLevelDescription != null )
+      {
+        PropertyChangedEventManager.RemoveListener( m_groupLevelDescription, this, string.Empty );
+      }
+    }
+
+    private bool TryGetGroupLevelDescription( out GroupLevelDescription result )
+    {
+      result = m_groupLevelDescription;
+      if( result != null )
+        return true;
+
+      m_raiseEventOnGroupLevelDescriptionFound = true;
+
+      return false;
+    }
+
+    private void OnGroupLevelDescriptionFound( object sender, PropertyChangedEventArgs e )
+    {
+      var finder = ( GroupLevelDescriptionFinder )sender;
+      Debug.Assert( finder == m_finder );
+
+      var groupLevelDescription = finder.GroupLevelDescription;
+      Debug.Assert( groupLevelDescription != null );
+
+      this.ClearLateBinding();
+
+      m_groupLevelDescription = groupLevelDescription;
+      PropertyChangedEventManager.AddListener( m_groupLevelDescription, this, string.Empty );
+
+      if( m_raiseEventOnGroupLevelDescriptionFound )
+      {
+        this.RaisePropertyChanged();
+      }
+    }
+
+    private void OnGroupLevelDescriptionPropertyChanged( object sender, PropertyChangedEventArgs e )
+    {
+      Debug.Assert( sender == m_groupLevelDescription );
+
+      this.RaisePropertyChanged( e );
+    }
+
+    #region INotifyPropertyChanged Members
+
+    public event PropertyChangedEventHandler PropertyChanged;
+
+    private void RaisePropertyChanged()
+    {
+      var handler = this.PropertyChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, new PropertyChangedEventArgs( null ) );
+    }
+
+    private void RaisePropertyChanged( PropertyChangedEventArgs e )
+    {
+      var handler = this.PropertyChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, e );
+    }
+
+    #endregion
+
+    #region IWeakEventListener Members
+
+    bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      if( typeof( PropertyChangedEventManager ) == managerType )
+      {
+        this.OnGroupLevelDescriptionPropertyChanged( sender, ( PropertyChangedEventArgs )e );
+        return true;
+      }
+
+      return false;
+    }
+
+    #endregion
+
+    #region Private Fields
+
+    private GroupLevelDescription m_groupLevelDescription;
+    private GroupLevelDescriptionFinder m_finder;
+    private bool m_raiseEventOnGroupLevelDescriptionFound; //false
+
+    #endregion
+
+    #region GroupLevelDescriptionFinder Private Class
+
+    private sealed class GroupLevelDescriptionFinder : INotifyPropertyChanged, IWeakEventListener, IDisposable
+    {
+      internal GroupLevelDescriptionFinder( GroupDescription groupDescription, IEnumerable<GroupLevelDescription> groupLevelDescriptions )
+      {
+        if( groupDescription == null )
+          throw new ArgumentNullException( "groupDescription" );
+
+        if( groupLevelDescriptions == null )
+          throw new ArgumentNullException( "groupLevelDescriptions" );
+
+        if( !GroupLevelDescriptionFinder.TryFind( groupLevelDescriptions, groupDescription, out m_groupLevelDescription ) )
+        {
+          m_groupDescription = groupDescription;
+          m_groupLevelDescriptions = groupLevelDescriptions;
+
+          this.RegisterCollectionChanged( ( INotifyCollectionChanged )groupLevelDescriptions );
+        }
+      }
+
+      internal GroupLevelDescription GroupLevelDescription
+      {
+        get
+        {
+          return m_groupLevelDescription;
+        }
+      }
+
+      public event PropertyChangedEventHandler PropertyChanged;
+
+      private void RaisePropertyChanged( string propertyName )
+      {
+        var handler = this.PropertyChanged;
+        if( handler == null )
+          return;
+
+        handler.Invoke( this, new PropertyChangedEventArgs( propertyName ) );
+      }
+
+      private void RegisterCollectionChanged( INotifyCollectionChanged collection )
+      {
+        if( collection == null )
+          return;
+
+        CollectionChangedEventManager.AddListener( collection, this );
+      }
+
+      private void UnregisterCollectionChanged( INotifyCollectionChanged collection )
+      {
+        if( collection == null )
+          return;
+
+        CollectionChangedEventManager.RemoveListener( collection, this );
+      }
+
+      private static bool TryFind( IEnumerable<GroupLevelDescription> collection, GroupDescription description, out GroupLevelDescription result )
+      {
+        if( ( collection == null ) || ( description == null ) )
+        {
+          result = null;
+        }
+        else
+        {
+          result = collection.Where( item => ( item.GroupDescription == description ) ).FirstOrDefault();
+        }
+
+        return ( result != null );
+      }
+
+      bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+      {
+        if( typeof( CollectionChangedEventManager ) == managerType )
+        {
+          Debug.Assert( sender == m_groupLevelDescriptions );
+
+          switch( ( ( NotifyCollectionChangedEventArgs )e ).Action )
+          {
+            case NotifyCollectionChangedAction.Move:
+            case NotifyCollectionChangedAction.Remove:
+              break;
+
+            default:
+              if( GroupLevelDescriptionFinder.TryFind( m_groupLevelDescriptions, m_groupDescription, out m_groupLevelDescription ) )
+              {
+                this.RaisePropertyChanged( "GroupLevelDescription" );
+                this.Dispose();
+              }
+              break;
+          }
+
+          return true;
+        }
+
+        return false;
+      }
+
+      public void Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        this.PropertyChanged = null;
+
+        this.UnregisterCollectionChanged( ( INotifyCollectionChanged )m_groupLevelDescriptions );
+
+        m_groupLevelDescriptions = null;
+        m_groupDescription = null;
+      }
+
+      ~GroupLevelDescriptionFinder()
+      {
+        this.Dispose( false );
+      }
+
+      private GroupDescription m_groupDescription; //null
+      private GroupLevelDescription m_groupLevelDescription; //null
+      private IEnumerable<GroupLevelDescription> m_groupLevelDescriptions; //null
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Log.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Log.cs
index 64eb7526..26ec0d4f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Log.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Log.cs
@@ -16,154 +16,398 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.IO;
-using System.Threading;
+using System.ComponentModel;
 using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
 using System.Runtime.ExceptionServices;
+using System.Text;
+using System.Threading;
 
 namespace Xceed.Wpf.DataGrid
 {
-  static class Log
+  internal class Log
   {
-#if LOG
-    static Log()
+    internal Log()
+    {
+      this.CreateBackgroungWorker();
+    }
+
+    #region SyncRoot Private Property
+
+    private object SyncRoot
     {
-      m_path = Environment.GetEnvironmentVariable( "AstoriaLogs" );
+      get
+      {
+        if( m_syncRoot == null )
+        {
+          Interlocked.CompareExchange( ref m_syncRoot, new object(), null );
+        }
+
+        return m_syncRoot;
+      }
+    }
+
+    private object m_syncRoot;
+
+    #endregion
 
-      if( string.IsNullOrEmpty( m_path ) )
-        m_path = Path.Combine( Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData ), @"XceedLog" );
+    #region Indentation Methods
 
-      Directory.CreateDirectory( m_path );
-      Log.WriteLine( "" );
-      Log.WriteLine( null, "*** App starting - Version : " + typeof( Log ).Assembly.GetName().Version.ToString() + " - Start time : " + DateTime.Now.ToString( "yy-MM-dd HH:mm:ss" ) );
-      AppDomain.CurrentDomain.FirstChanceException += new EventHandler<FirstChanceExceptionEventArgs>( CurrentDomain_FirstChanceException );
+    private int GetIndentLevel()
+    {
+      return m_indentLevel;
     }
 
-    static void CurrentDomain_FirstChanceException( object sender, FirstChanceExceptionEventArgs e )
+    private void IncreaseIndentLevel()
     {
-      Exception exception = e.Exception;
+      Interlocked.Increment( ref m_indentLevel );
+    }
 
-      if( exception != null )
+    private void DecreaseIndentLevel()
+    {
+      Interlocked.Decrement( ref m_indentLevel );
+    }
+
+    private int m_indentLevel;
+
+    #endregion
+
+    [Conditional( "LOG" )]
+    private void CreateBackgroungWorker()
+    {
+      m_queueSyncRoot = new object();
+      m_messageQueue = new Queue<string>( 100 );
+      m_backgroundWorker = new BackgroundWorker();
+      m_backgroundWorker.DoWork += new DoWorkEventHandler( DoWriteLine );
+    }
+
+    internal void Fail( string message )
+    {
+      this.Fail( UnknownSource.Instance, message );
+    }
+
+    internal void Fail( object source, string message )
+    {
+      this.Assert( source, false, message );
+    }
+
+    internal void Assert( bool condition, string message )
+    {
+      this.Assert( UnknownSource.Instance, condition, message );
+    }
+
+    internal void Assert( object source, bool condition, string message )
+    {
+      Debug.Assert( condition, message );
+      this.AssertCore( source, condition, message );
+    }
+
+    [Conditional( "LOG" )]
+    internal void WriteLine( object source, string message )
+    {
+      var sb = new StringBuilder();
+
+      lock( this.SyncRoot )
       {
-        StackTrace stackTrace = new StackTrace( 1 );
-        string stackTraceString = stackTrace.ToString();
+        sb.Append( this.GetHeader( source ) );
+        sb.Append( this.GetMessage( string.Empty, message, string.Empty ) );
 
-        if( stackTraceString.IndexOf( "xceed", StringComparison.InvariantCultureIgnoreCase ) >= 0 )
-        {
-          lock( m_unknowSource )
-          {
-            Log.WriteLine( m_unknowSource, exception.ToString() );
-            Log.WriteLine( "--------------------" );
-            Log.WriteLine( stackTraceString );
-          }
-        }
+        this.QueueWriteLine( sb.ToString() );
+      }
+    }
+
+    [MethodImpl( MethodImplOptions.NoInlining )]
+    internal Block BeginBlock( object source, string message )
+    {
+      var location = new StackFrame( 1 ).GetMethod().Name;
+
+      return new Block( this, source, location, message );
+    }
+
+    [Conditional( "LOG" )]
+    private void Start( object source, string location, string message )
+    {
+      lock( this.SyncRoot )
+      {
+        var sb = new StringBuilder();
+        sb.Append( this.GetHeader( source ) );
+        sb.Append( this.GetMessage( location, "Start", message ) );
+
+        this.QueueWriteLine( sb.ToString() );
+        this.IncreaseIndentLevel();
+      }
+    }
+
+    [Conditional( "LOG" )]
+    private void End( object source, string location, string message )
+    {
+      lock( this.SyncRoot )
+      {
+        this.DecreaseIndentLevel();
+
+        var sb = new StringBuilder();
+        sb.Append( this.GetHeader( source ) );
+        sb.Append( this.GetMessage( location, "End", message ) );
+
+        this.QueueWriteLine( sb.ToString() );
+      }
+    }
+
+    private string GetHeader( object source )
+    {
+      var sb = new StringBuilder();
+      sb.AppendFormat( "{0} | {1}", DateTime.Now.ToString( "HHmmss" ), Thread.CurrentThread.GetHashCode() );
+
+      if( ( source == null ) || ( source == UnknownSource.Instance ) )
+      {
+        sb.AppendFormat( " : {0,10}", "Unknown" );
       }
       else
       {
-        Log.WriteLine( "FirstChanceException with a null/no exception." );
+        sb.AppendFormat( " : {0:0000000000}", source.GetHashCode() );
       }
+
+      sb.Append( " : " );
+
+      var indentLevel = this.GetIndentLevel();
+      if( indentLevel > 0 )
+      {
+        sb.Append( ' ', indentLevel * 2 );
+      }
+
+      return sb.ToString();
     }
 
-    private static string m_path;
-    private static string m_fileName = Environment.UserName + "-" + Environment.MachineName + "-" + DateTime.Now.ToString( "yyMMdd-HHmmss-" ) + Guid.NewGuid().ToString();
-    private static int m_indentation = 0;
-    private static UnknowSource m_unknowSource = new UnknowSource();
+    private string GetMessage( string prefix, string message, string suffix )
+    {
+      var sb = new StringBuilder();
 
-    public static void Assert( object source, bool condition, string message )
+      foreach( var part in new string[] { prefix, message, suffix } )
+      {
+        if( string.IsNullOrEmpty( part ) )
+          continue;
+
+        if( sb.Length > 0 )
+        {
+          sb.Append( " - " );
+        }
+
+        sb.Append( part );
+      }
+
+      return sb.ToString();
+    }
+
+    [Conditional( "LOG" )]
+    private void QueueWriteLine( string message )
     {
-      if( !condition )
+      lock( m_queueSyncRoot )
       {
-        Log.WriteLine( source, "# - " + message );
+        m_messageQueue.Enqueue( message );
+      }
+
+      if( !m_backgroundWorker.IsBusy )
+      {
+        m_backgroundWorker.RunWorkerAsync();
+      }
+    }
+
+    private void DoWriteLine( object sender, DoWorkEventArgs e )
+    {
+      string message;
+
+      while( m_messageQueue.Count > 0 )
+      {
+        lock( m_queueSyncRoot )
+        {
+          message = m_messageQueue.Dequeue();
+        }
 
-        StackTrace stackTrace = new StackTrace();
-        Log.WriteLine( stackTrace.ToString() );
+        lock( this.SyncRoot )
+        {
+          using( TextWriter tw = new StreamWriter( m_defaultPath + "\\" + m_defaultFileName, true ) )
+          {
+            tw.WriteLine( message );
+          }
+        }
       }
     }
 
-    public static void Start( object source, string message )
+    [Conditional( "LOG" )]
+    internal void AssertCore( object source, bool condition, string message )
     {
-      if( source == null )
-        source = m_unknowSource;
+      if( condition )
+        return;
 
-      message = DateTime.Now.ToString( "HHmmss" ) + " | " +
-        Thread.CurrentThread.GetHashCode().ToString() + " : " +
-        source.GetHashCode().ToString( "0000000000" ) + " : " +
-        new string( ' ', m_indentation * 2 ) +
-        message + " - Start";
+      var stackTrace = new StackTrace();
+      var sb = new StringBuilder();
 
-      Log.WriteLine( message );
-      m_indentation++;
+      lock( this.SyncRoot )
+      {
+        sb.Append( this.GetHeader( source ) );
+        sb.Append( this.GetMessage( "# - ", message, string.Empty ) );
+
+        this.QueueWriteLine( sb.ToString() );
+        this.QueueWriteLine( stackTrace.ToString() );
+      }
     }
 
-    public static void End( object source, string message )
+    [Conditional( "LOG" )]
+    internal void StartUp( string gridUniqueName = "" )
     {
-      if( source == null )
-        source = m_unknowSource;
+      m_defaultPath = Environment.GetEnvironmentVariable( "AstoriaLogs" );
+      if( string.IsNullOrEmpty( m_defaultPath ) )
+      {
+        m_defaultPath = Path.Combine( Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData ), @"XceedLog" );
+      }
 
-      m_indentation--;
+      var now = DateTime.Now;
+      m_defaultFileName = Environment.UserName + "-" + Environment.MachineName + "-" + now.ToString( "yyMMdd-HHmmss-" ) + Guid.NewGuid().ToString() + ".txt";
 
-      if( m_indentation < 0 )
-        m_indentation = 0;
+      this.OverridePaths( gridUniqueName );
 
-      message = DateTime.Now.ToString( "HHmmss" ) + " | " +
-        Thread.CurrentThread.GetHashCode().ToString() + " : " +
-        source.GetHashCode().ToString( "0000000000" ) + " : " +
-        new string( ' ', m_indentation * 2 ) +
-        message + " - End";
+      // Make sure the destination folder exists.
+      if( !Directory.Exists( m_defaultPath ) )
+      {
+        Directory.CreateDirectory( m_defaultPath );
+      }
+
+      this.QueueWriteLine( "*** App starting - Version : " + typeof( Log ).Assembly.GetName().Version.ToString() + " - Start time : " + now.ToString( "yy-MM-dd HH:mm:ss" ) );
 
-      Log.WriteLine( message );
+      AppDomain.CurrentDomain.FirstChanceException += new EventHandler<FirstChanceExceptionEventArgs>( this.OnFirstChanceException );
     }
 
-    public static void WriteLine( object source, string message )
+    [Conditional( "CUSTOMLOG" )]
+    private void OverridePaths( string gridUniqueName )
     {
-      if( source == null )
-        source = m_unknowSource;
+      m_defaultPath = Path.Combine( Environment.GetFolderPath( Environment.SpecialFolder.LocalApplicationData ), @"..\Local Settings\Application Data\WMC\Gtseq\Logs\" );
 
-      message = DateTime.Now.ToString( "HHmmss" ) + " | " +
-        Thread.CurrentThread.GetHashCode().ToString() + " : " +
-        source.GetHashCode().ToString( "0000000000" ) + " : " +
-        new string( ' ', m_indentation * 2 ) +
-        message;
+      var now = DateTime.Now;
+      m_defaultFileName = gridUniqueName + "-TID_" + Thread.CurrentThread.ManagedThreadId + "-" + now.ToString( "yyMMdd-HHmmss" ) + ".log";
+    }
 
-      Log.WriteLine( message );
+    [MethodImpl( MethodImplOptions.NoInlining )]
+    private void OnFirstChanceException( object sender, FirstChanceExceptionEventArgs e )
+    {
+      this.WriteException( e.Exception as Exception );
     }
 
-    private static void WriteLine( string message )
+    [Conditional( "LOG" )]
+    [MethodImpl( MethodImplOptions.NoInlining )]
+    private void WriteException( Exception e )
     {
-      lock( m_unknowSource )
+      if( e != null )
       {
-        using( TextWriter tw = new StreamWriter( m_path + "\\" + m_fileName + ".txt", true ) )
+        StackTrace stackTrace = new StackTrace( 2 );
+        string stackTraceString = stackTrace.ToString();
+
+        if( stackTraceString.IndexOf( "xceed", StringComparison.InvariantCultureIgnoreCase ) >= 0 )
         {
-          tw.WriteLine( message );
+          lock( this.SyncRoot )
+          {
+            this.WriteLine( UnknownSource.Instance, e.ToString() );
+            this.QueueWriteLine( "--------------------" );
+            this.QueueWriteLine( stackTraceString );
+          }
         }
       }
+      else
+      {
+        this.QueueWriteLine( "FirstChanceException with a null/no exception." );
+      }
     }
 
-    private class UnknowSource
+    private string m_defaultPath;
+    private string m_defaultFileName;
+    private object m_queueSyncRoot;
+    private Queue<string> m_messageQueue;
+    private BackgroundWorker m_backgroundWorker;
+
+    #region UnknownSource Private Class
+
+    private sealed class UnknownSource
     {
+      internal static readonly UnknownSource Instance = new UnknownSource();
+
+      private UnknownSource()
+      {
+      }
+
       public override int GetHashCode()
       {
-        return -1;
+        return 0;
       }
 
       public override bool Equals( object obj )
       {
         return base.Equals( obj );
       }
-    }
-#endif
 
-    public static void NotToolkit( string featureName )
-    {
-      Console.WriteLine( Log.NotToolkitStr( featureName ) );
+      public override string ToString()
+      {
+        return "Unknown source";
+      }
     }
 
-    public static string NotToolkitStr( string featureName )
+    #endregion
+
+    #region Block Private Class
+
+    internal sealed class Block : IDisposable
     {
-      return string.Format( "{0} feature not available in the toolkit version of the DataGrid", featureName );
+      internal Block( Log log, object source, string location, string message )
+      {
+        if( source == null )
+          throw new ArgumentNullException( "source" );
+
+        m_log = log;
+        m_source = source;
+        m_location = location;
+
+        m_log.Start( source, location, message );
+      }
+
+      internal void Break( string message )
+      {
+        if( Interlocked.CompareExchange( ref m_source, null, null ) == null )
+          return;
+
+        m_message = message;
+      }
+
+      void IDisposable.Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var source = m_source;
+        if( Interlocked.CompareExchange( ref m_source, null, source ) == null )
+          return;
+
+        if( disposing )
+        {
+          m_log.End( source, m_location, m_message );
+        }
+
+        m_location = null;
+        m_message = null;
+      }
+
+      ~Block()
+      {
+        this.Dispose( false );
+      }
+
+      private Log m_log;
+      private object m_source;
+      private string m_location;
+      private string m_message;
     }
 
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/DataGridThemeResourceDictionary.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/DataGridThemeResourceDictionary.cs
new file mode 100644
index 00000000..8afeb94e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/DataGridThemeResourceDictionary.cs
@@ -0,0 +1,45 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+using System.Threading;
+
+namespace Xceed.Wpf.DataGrid.Markup
+{
+  [Browsable( false )]
+  [EditorBrowsable( EditorBrowsableState.Never )]
+  public sealed class DataGridThemeResourceDictionary : SharedThemeResourceDictionary
+  {
+    #region Static Fields
+
+    private static Uri s_baseUri; //null
+
+    #endregion
+
+    protected override Uri GetBaseUri()
+    {
+      if( s_baseUri == null )
+      {
+        var baseUri = this.CreateBaseUri( this.GetType().Assembly );
+
+        Interlocked.CompareExchange<Uri>( ref s_baseUri, baseUri, null );
+      }
+
+      return s_baseUri;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/FrameworkThemeResourceDictionary.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/FrameworkThemeResourceDictionary.cs
new file mode 100644
index 00000000..d9654f82
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/FrameworkThemeResourceDictionary.cs
@@ -0,0 +1,31 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+
+namespace Xceed.Wpf.DataGrid.Markup
+{
+  [Browsable( false )]
+  [EditorBrowsable( EditorBrowsableState.Never )]
+  public sealed class FrameworkThemeResourceDictionary : SharedThemeResourceDictionary
+  {
+    protected override Uri GetBaseUri()
+    {
+      return null;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedResourceDictionary.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedResourceDictionary.cs
new file mode 100644
index 00000000..60f6fbc0
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedResourceDictionary.cs
@@ -0,0 +1,283 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Threading;
+using System.Windows;
+using System.Windows.Markup;
+
+namespace Xceed.Wpf.DataGrid.Markup
+{
+  [Browsable( false )]
+  [EditorBrowsable( EditorBrowsableState.Never )]
+  public abstract class SharedResourceDictionary : ResourceDictionary
+  {
+    #region SharedDictionaries Private Static Property
+
+    private static List<KeyValuePair<Uri, WeakResourceDictionary>> SharedDictionaries
+    {
+      get
+      {
+        if( s_sharedDictionaries == null )
+        {
+          Interlocked.CompareExchange<List<KeyValuePair<Uri, WeakResourceDictionary>>>( ref s_sharedDictionaries, new List<KeyValuePair<Uri, WeakResourceDictionary>>(), null );
+        }
+
+        return s_sharedDictionaries;
+      }
+    }
+
+    private static List<KeyValuePair<Uri, WeakResourceDictionary>> s_sharedDictionaries; //null
+
+    #endregion
+
+    #region Source Property
+
+    public new Uri Source
+    {
+      get
+      {
+        if( m_sourceUri != null )
+          return m_sourceUri;
+
+        return base.Source;
+      }
+      set
+      {
+        Uri sourceUri;
+        if( !this.TryCreateAbsoluteUri( ( ( IUriContext )this ).BaseUri, value, out sourceUri )
+          || ( sourceUri == null )
+          || ( !sourceUri.IsAbsoluteUri ) )
+        {
+          base.Source = value;
+        }
+        else
+        {
+          var dictionaries = SharedResourceDictionary.SharedDictionaries;
+          lock( ( ( ICollection )dictionaries ).SyncRoot )
+          {
+            bool cleanUp;
+            ResourceDictionary dictionary;
+
+            var index = SharedResourceDictionary.FindIndex( dictionaries, sourceUri, out cleanUp );
+            if( index >= 0 )
+            {
+              var container = dictionaries[ index ].Value;
+              if( container.Status == ResourceDictionaryStatus.NotSet )
+                throw new InvalidOperationException( "TODODOC: A circular reference has been detected in a ResourceDictionary." );
+
+              dictionary = container.Target;
+            }
+            else
+            {
+              dictionary = null;
+            }
+
+            m_sourceUri = value;
+
+            if( dictionary != null )
+            {
+              var mergedDictionaries = this.MergedDictionaries;
+              lock( ( ( ICollection )this ).SyncRoot )
+              {
+                lock( ( ( ICollection )mergedDictionaries ).SyncRoot )
+                {
+                  mergedDictionaries.Add( dictionary );
+                }
+              }
+            }
+            else
+            {
+              // We must add the entry in the collection before we actually load the ResourceDictionary because
+              // the ResourceDictionary may load other ResourceDictionary as well.  Our insertion index may no longer
+              // be valid after the ResourceDictionary is loaded.
+              var container = new WeakResourceDictionary();
+              var newEntry = new KeyValuePair<Uri, WeakResourceDictionary>( sourceUri, container );
+              if( index >= 0 )
+              {
+                dictionaries[ index ] = newEntry;
+              }
+              else
+              {
+                dictionaries.Insert( ~index, newEntry );
+              }
+
+              bool exceptionOccured = true;
+
+              try
+              {
+                base.Source = sourceUri;
+
+                exceptionOccured = false;
+              }
+              finally
+              {
+                if( exceptionOccured )
+                {
+                  dictionaries.Remove( newEntry );
+                }
+                else
+                {
+                  container.Target = this;
+                }
+              }
+            }
+
+            if( cleanUp )
+            {
+              for( int i = dictionaries.Count - 1; i >= 0; i-- )
+              {
+                if( dictionaries[ i ].Value.Status != ResourceDictionaryStatus.GarbageCollected )
+                  continue;
+
+                dictionaries.RemoveAt( i );
+              }
+            }
+          }
+        }
+      }
+    }
+
+    private Uri m_sourceUri; //null
+
+    #endregion
+
+    protected virtual bool TryCreateAbsoluteUri( Uri baseUri, Uri sourceUri, out Uri result )
+    {
+      result = null;
+
+      if( ( sourceUri == null ) || !sourceUri.IsAbsoluteUri )
+        return false;
+
+      if( string.Compare( sourceUri.Scheme, Uri.UriSchemeFile, StringComparison.OrdinalIgnoreCase ) != 0 )
+      {
+        result = sourceUri;
+      }
+      else if( string.Compare( sourceUri.OriginalString, 0, Uri.UriSchemeFile, 0, Uri.UriSchemeFile.Length, StringComparison.OrdinalIgnoreCase ) == 0 )
+      {
+        result = sourceUri;
+      }
+      else
+      {
+        result = new Uri( sourceUri.AbsoluteUri );
+      }
+
+      return true;
+    }
+
+    private static int FindIndex( IList<KeyValuePair<Uri, WeakResourceDictionary>> collection, Uri sourceUri, out bool cleanUp )
+    {
+      cleanUp = false;
+
+      Debug.Assert( collection != null );
+      Debug.Assert( sourceUri != null );
+
+      var lowerBound = 0;
+      var upperBound = collection.Count - 1;
+
+      while( lowerBound <= upperBound )
+      {
+        var middle = lowerBound + ( upperBound - lowerBound ) / 2;
+        var entry = collection[ middle ];
+        var compare = Uri.Compare( entry.Key, sourceUri, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.InvariantCultureIgnoreCase );
+
+        cleanUp = cleanUp || ( entry.Value.Status == ResourceDictionaryStatus.GarbageCollected );
+
+        if( compare < 0 )
+        {
+          if( middle == lowerBound )
+            return ~middle;
+
+          upperBound = middle - 1;
+        }
+        else if( compare > 0 )
+        {
+          if( middle == upperBound )
+            return ~( middle + 1 );
+
+          lowerBound = middle + 1;
+        }
+        else
+        {
+          return middle;
+        }
+      }
+
+      return ~0;
+    }
+
+    #region WeakResourceDictionary Private Class
+
+    private sealed class WeakResourceDictionary
+    {
+      internal ResourceDictionary Target
+      {
+        get
+        {
+          var resource = m_resource;
+          if( resource == null )
+            return null;
+
+          return ( ResourceDictionary )resource.Target;
+        }
+        set
+        {
+          if( value == null )
+            throw new ArgumentNullException( "value" );
+
+          if( m_resource != null )
+            throw new InvalidOperationException( "TODODOC: The property can only be set once." );
+
+          m_resource = new WeakReference( value );
+        }
+      }
+
+      internal ResourceDictionaryStatus Status
+      {
+        get
+        {
+          var resource = m_resource;
+          if( resource == null )
+            return ResourceDictionaryStatus.NotSet;
+
+          if( resource.IsAlive )
+            return ResourceDictionaryStatus.Alive;
+
+          return ResourceDictionaryStatus.GarbageCollected;
+        }
+      }
+
+      private WeakReference m_resource; //null
+    }
+
+    #endregion
+
+    #region ResourceDictionaryStatus Private Enum
+
+    private enum ResourceDictionaryStatus
+    {
+      NotSet = 0,
+      Alive,
+      GarbageCollected
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedThemeResourceDictionary.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedThemeResourceDictionary.cs
new file mode 100644
index 00000000..c6222734
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/SharedThemeResourceDictionary.cs
@@ -0,0 +1,414 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Reflection;
+using System.Security;
+using System.Text;
+
+namespace Xceed.Wpf.DataGrid.Markup
+{
+  [Browsable( false )]
+  [EditorBrowsable( EditorBrowsableState.Never )]
+  public abstract class SharedThemeResourceDictionary : SharedResourceDictionary
+  {
+    #region Static Fields
+
+    private const string UriSchemePack = "pack";
+    private const string UriComponent = ";component";
+    private const string UriAssemblyVersionSymbol = "V";
+    private const string UriAssemblyInfoSeparator = ";";
+    private const string UriPathSeparator = "/";
+
+    private const string AssemblyFullNameSeparator = ",";
+    private const string AssemblyFullNameVersionPrefix = "Version=";
+    private const string AssemblyFullNamePublicKeyTokenPrefix = "PublicKeyToken=";
+
+    private static readonly Uri SchemePackBaseUri = new Uri( "pack://application:,,,/", UriKind.Absolute );
+
+    #endregion
+
+    protected abstract Uri GetBaseUri();
+
+    protected sealed override bool TryCreateAbsoluteUri( Uri baseUri, Uri sourceUri, out Uri result )
+    {
+      Uri packUri;
+
+      if( sourceUri != null )
+      {
+        if( SharedThemeResourceDictionary.TryConvertToPackUri( sourceUri, out packUri ) )
+        {
+          sourceUri = packUri;
+        }
+
+        UriDescription sourceUriDescription;
+        if( SharedThemeResourceDictionary.TryGetUriDescription( sourceUri, out sourceUriDescription ) )
+        {
+          if( SharedThemeResourceDictionary.IsAssemblyInfoFilled( sourceUriDescription ) )
+          {
+            result = SharedThemeResourceDictionary.CreateUri( sourceUriDescription );
+            return true;
+          }
+        }
+      }
+
+      if( SharedThemeResourceDictionary.TryConvertToPackUri( baseUri, out packUri ) )
+      {
+        baseUri = packUri;
+      }
+
+      var newBaseUri = this.GetBaseUri();
+      if( newBaseUri != null )
+      {
+        if( SharedThemeResourceDictionary.TryConvertToPackUri( newBaseUri, out packUri ) )
+        {
+          newBaseUri = packUri;
+        }
+
+        if( baseUri != null )
+        {
+          Uri combinedUri;
+          if( SharedThemeResourceDictionary.TryCombineUri( newBaseUri, baseUri, out combinedUri ) )
+          {
+            newBaseUri = combinedUri;
+          }
+        }
+
+        if( sourceUri != null )
+          return SharedThemeResourceDictionary.TryCombineUri( newBaseUri, sourceUri, out result );
+      }
+      else
+      {
+        newBaseUri = baseUri;
+      }
+
+      return base.TryCreateAbsoluteUri( newBaseUri, sourceUri, out result );
+    }
+
+    protected Uri CreateBaseUri( Assembly assembly )
+    {
+      if( assembly == null )
+        return null;
+
+      try
+      {
+        return SharedThemeResourceDictionary.CreateBaseUriFromAssembly( assembly );
+      }
+      catch( SecurityException )
+      {
+        return SharedThemeResourceDictionary.CreateBaseUriFromAssemblyFullName( assembly );
+      }
+    }
+
+    private static Uri CreateBaseUriFromAssembly( Assembly assembly )
+    {
+      Debug.Assert( assembly != null );
+
+      var assemblyInfo = assembly.GetName();
+      var assemblyName = assemblyInfo.Name;
+      var assemblyVersion = SharedThemeResourceDictionary.GetAssemblyVersion( assemblyInfo.Version );
+      var assemblyPublicKeyToken = SharedThemeResourceDictionary.GetAssemblyPublicKeyToken( assemblyInfo.GetPublicKeyToken() );
+
+      return SharedThemeResourceDictionary.CreateUri( assemblyName, assemblyVersion, assemblyPublicKeyToken, string.Empty );
+    }
+
+    private static Uri CreateBaseUriFromAssemblyFullName( Assembly assembly )
+    {
+      Debug.Assert( assembly != null );
+
+      var fullName = assembly.FullName;
+      var assemblyName = SharedThemeResourceDictionary.GetAssemblyName( fullName );
+      var assemblyVersion = SharedThemeResourceDictionary.GetAssemblyVersion( fullName );
+      var assemblyPublicKeyToken = SharedThemeResourceDictionary.GetAssemblyPublicKeyToken( fullName );
+
+      return SharedThemeResourceDictionary.CreateUri( assemblyName, assemblyVersion, assemblyPublicKeyToken, string.Empty );
+    }
+
+    private static string GetAssemblyName( string fullName )
+    {
+      if( fullName == null )
+        return null;
+
+      var length = fullName.IndexOf( SharedThemeResourceDictionary.AssemblyFullNameSeparator, StringComparison.InvariantCultureIgnoreCase );
+      if( length <= 0 )
+        return null;
+
+      return fullName.Substring( 0, length );
+    }
+
+    private static string GetAssemblyVersion( Version version )
+    {
+      if( version == null )
+        return null;
+
+      return SharedThemeResourceDictionary.UriAssemblyVersionSymbol + version.ToString();
+    }
+
+    private static string GetAssemblyVersion( string fullName )
+    {
+      if( fullName == null )
+        return null;
+
+      var start = fullName.IndexOf( SharedThemeResourceDictionary.AssemblyFullNameVersionPrefix, StringComparison.InvariantCultureIgnoreCase );
+      if( start < 0 )
+        return null;
+
+      start += SharedThemeResourceDictionary.AssemblyFullNameVersionPrefix.Length;
+
+      var end = fullName.IndexOf( SharedThemeResourceDictionary.AssemblyFullNameSeparator, start, StringComparison.InvariantCultureIgnoreCase );
+      var value = ( end > 0 )
+                    ? fullName.Substring( start, end - start )
+                    : fullName.Substring( start );
+
+      if( string.IsNullOrEmpty( value ) )
+        return null;
+
+      return SharedThemeResourceDictionary.UriAssemblyVersionSymbol + value;
+    }
+
+    private static string GetAssemblyPublicKeyToken( byte[] publicKeyToken )
+    {
+      if( publicKeyToken == null )
+        return null;
+
+      var sb = new StringBuilder();
+      for( int i = 0; i < publicKeyToken.Length; i++ )
+      {
+        sb.AppendFormat( "{0:x2}", publicKeyToken[ i ] );
+      }
+
+      return sb.ToString();
+    }
+
+    private static string GetAssemblyPublicKeyToken( string fullName )
+    {
+      if( fullName == null )
+        return null;
+
+      var start = fullName.IndexOf( SharedThemeResourceDictionary.AssemblyFullNamePublicKeyTokenPrefix, StringComparison.InvariantCultureIgnoreCase );
+      if( start < 0 )
+        return null;
+
+      start += SharedThemeResourceDictionary.AssemblyFullNamePublicKeyTokenPrefix.Length;
+
+      var end = fullName.IndexOf( SharedThemeResourceDictionary.AssemblyFullNameSeparator, start, StringComparison.InvariantCultureIgnoreCase );
+      var value = ( end > 0 )
+                    ? fullName.Substring( start, end - start )
+                    : fullName.Substring( start );
+
+      return value;
+    }
+
+    private static string ParseAssemblyVersion( string version )
+    {
+      var symbol = SharedThemeResourceDictionary.UriAssemblyVersionSymbol;
+      if( string.IsNullOrEmpty( version ) || !version.StartsWith( symbol, StringComparison.InvariantCultureIgnoreCase ) )
+        return version;
+
+      Version ver;
+      if( !Version.TryParse( version.Substring( symbol.Length ), out ver ) )
+        return version;
+
+      return SharedThemeResourceDictionary.GetAssemblyVersion( ver );
+    }
+
+    private static Uri CreateUri( UriDescription description )
+    {
+      Debug.Assert( description != null );
+
+      return SharedThemeResourceDictionary.CreateUri(
+               description.AssemblyName,
+               description.AssemblyVersion,
+               description.AssemblyPublicKeyToken,
+               description.RelativePath );
+    }
+
+    private static Uri CreateUri( string assemblyName, string assemblyVersion, string assemblyPublicKeyToken, string relativePath )
+    {
+      var sb = new StringBuilder( SharedThemeResourceDictionary.UriPathSeparator );
+
+      sb.Append( assemblyName ?? string.Empty );
+
+      sb.Append( SharedThemeResourceDictionary.UriAssemblyInfoSeparator );
+      sb.Append( SharedThemeResourceDictionary.UriAssemblyInfoSeparator );
+
+      sb.Append( SharedThemeResourceDictionary.UriComponent );
+
+      if( string.IsNullOrEmpty( relativePath ) || !relativePath.StartsWith( SharedThemeResourceDictionary.UriPathSeparator, StringComparison.InvariantCultureIgnoreCase ) )
+      {
+        sb.Append( SharedThemeResourceDictionary.UriPathSeparator );
+      }
+
+      sb.Append( relativePath ?? string.Empty );
+
+      return new Uri( SharedThemeResourceDictionary.SchemePackBaseUri, sb.ToString() );
+    }
+
+    private static bool TryConvertToPackUri( Uri sourceUri, out Uri result )
+    {
+      if( SharedThemeResourceDictionary.IsPackUri( sourceUri ) )
+      {
+        result = new Uri( SharedThemeResourceDictionary.SchemePackBaseUri, sourceUri );
+      }
+      else
+      {
+        result = null;
+      }
+
+      return ( result != null );
+    }
+
+    private static bool IsPackUri( Uri sourceUri )
+    {
+      if( sourceUri == null )
+        return false;
+
+      var path = sourceUri.ToString();
+
+      return ( path.IndexOf( SharedThemeResourceDictionary.UriComponent, StringComparison.InvariantCultureIgnoreCase ) >= 0 );
+    }
+
+    private static bool IsAssemblyInfoFilled( UriDescription description )
+    {
+      if( string.IsNullOrEmpty( description.AssemblyName ) )
+        return false;
+
+      return !string.IsNullOrEmpty( description.AssemblyVersion )
+          || !string.IsNullOrEmpty( description.AssemblyPublicKeyToken );
+    }
+
+    private static bool TryGetUriDescription( Uri uri, out UriDescription description )
+    {
+      description = null;
+      if( ( uri == null ) || !uri.IsAbsoluteUri )
+        return false;
+
+      if( !string.Equals( uri.Scheme, SharedThemeResourceDictionary.UriSchemePack, StringComparison.InvariantCultureIgnoreCase ) )
+        return false;
+
+      var segments = uri.Segments;
+      if( ( segments == null ) || ( segments.Length < 2 ) )
+        return false;
+
+      var componentPart = segments[ 1 ];
+      var index = componentPart.IndexOf( SharedThemeResourceDictionary.UriComponent, StringComparison.InvariantCultureIgnoreCase );
+      if( index < 0 )
+        return false;
+
+      string assemblyName = null;
+      string assemblyVersion = null;
+      string assemblyPublicKeyToken = null;
+
+      var assemblyInfo = componentPart.Substring( 0, index );
+      if( assemblyInfo.Length > 0 )
+      {
+        var assemblyParts = assemblyInfo.Split( new string[] { SharedThemeResourceDictionary.UriAssemblyInfoSeparator }, StringSplitOptions.None );
+        Debug.Assert( assemblyParts.Length <= 3 );
+
+        assemblyName = ( assemblyParts.Length > 0 ) ? assemblyParts[ 0 ] : null;
+        assemblyVersion = ( assemblyParts.Length > 1 ) ? SharedThemeResourceDictionary.ParseAssemblyVersion( assemblyParts[ 1 ] ) : null;
+        assemblyPublicKeyToken = ( assemblyParts.Length > 2 ) ? assemblyParts[ 2 ] : null;
+      }
+
+      string relativePath = null;
+
+      if( segments.Length > 2 )
+      {
+        var sb = new StringBuilder();
+        for( int i = 2; i < segments.Length; i++ )
+        {
+          sb.Append( segments[ i ] );
+        }
+
+        relativePath = sb.ToString();
+      }
+
+      description = new UriDescription( assemblyName, assemblyVersion, assemblyPublicKeyToken, relativePath );
+
+      return true;
+    }
+
+    private static bool TryCombineUri( Uri baseUri, Uri relativeUri, out Uri result )
+    {
+      result = null;
+
+      Debug.Assert( ( baseUri != null ) && ( relativeUri != null ) );
+      Debug.Assert( baseUri.IsAbsoluteUri );
+
+      UriDescription baseUriDescription;
+      if( !SharedThemeResourceDictionary.TryGetUriDescription( baseUri, out baseUriDescription ) )
+        return false;
+
+      UriDescription relativeUriDescription;
+      if( SharedThemeResourceDictionary.TryGetUriDescription( relativeUri, out relativeUriDescription ) )
+      {
+        if( !string.IsNullOrEmpty( relativeUriDescription.AssemblyName ) && !string.Equals( relativeUriDescription.AssemblyName, baseUriDescription.AssemblyName, StringComparison.InvariantCultureIgnoreCase ) )
+          return false;
+      }
+      else if( relativeUri.IsAbsoluteUri )
+      {
+        return false;
+      }
+      else
+      {
+        relativeUriDescription = null;
+      }
+
+      var baseUriPath = baseUriDescription.RelativePath;
+      var relativeUriPath = ( relativeUriDescription != null ) ? relativeUriDescription.RelativePath : Uri.EscapeUriString( relativeUri.ToString() );
+
+      if( relativeUriPath.StartsWith( SharedThemeResourceDictionary.UriPathSeparator, StringComparison.InvariantCultureIgnoreCase ) )
+      {
+        baseUriPath = string.Empty;
+        relativeUriPath = relativeUriPath.Substring( SharedThemeResourceDictionary.UriPathSeparator.Length );
+      }
+
+      var assemblyDescription = ( ( relativeUriDescription != null ) && !SharedThemeResourceDictionary.IsAssemblyInfoFilled( baseUriDescription ) )
+                                  ? relativeUriDescription
+                                  : baseUriDescription;
+      var newBaseUri = SharedThemeResourceDictionary.CreateUri(
+                         assemblyDescription.AssemblyName,
+                         assemblyDescription.AssemblyVersion,
+                         assemblyDescription.AssemblyPublicKeyToken,
+                         baseUriPath );
+      var newRelativeUri = new Uri( relativeUriPath, UriKind.Relative );
+
+      return Uri.TryCreate( newBaseUri, newRelativeUri, out result );
+    }
+
+    #region UriDescription Private Class
+
+    private sealed class UriDescription
+    {
+      internal UriDescription( string assemblyName, string assemblyVersion, string assemblyPublicKeyToken, string relativePath )
+      {
+        this.AssemblyName = assemblyName ?? string.Empty;
+        this.AssemblyVersion = assemblyVersion ?? string.Empty;
+        this.AssemblyPublicKeyToken = assemblyPublicKeyToken ?? string.Empty;
+        this.RelativePath = relativePath ?? string.Empty;
+      }
+
+      internal readonly string AssemblyName;
+      internal readonly string AssemblyVersion;
+      internal readonly string AssemblyPublicKeyToken;
+      internal readonly string RelativePath;
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeConverter.cs
index da85da09..c6e80087 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeConverter.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeConverter.cs
@@ -15,9 +15,7 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel;
-using System.Text;
 using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid.Markup
@@ -75,10 +73,6 @@ namespace Xceed.Wpf.DataGrid.Markup
           case "aeronormalcolortheme":
             theme = s_aeroNormalColorTheme;
             break;
-          case "aero2.normalcolor":
-          case "aero2normalcolortheme":
-            theme = s_aero2NormalColorTheme;
-            break;
           case "royale.normalcolor":
           case "royalenormalcolortheme":
             theme = s_royaleNormalColorTheme;
@@ -91,6 +85,10 @@ namespace Xceed.Wpf.DataGrid.Markup
           case "windows7theme":
             theme = s_windows7Theme;
             break;
+          case "aero2.normalcolor":
+          case "aero2normalcolortheme":
+            theme = s_aero2NormalColorTheme;
+            break;
         }
 
         if( theme == null )
@@ -107,9 +105,9 @@ namespace Xceed.Wpf.DataGrid.Markup
     private static readonly Theme s_lunaHomesteadTheme = new LunaHomesteadTheme();
     private static readonly Theme s_lunaMetallicTheme = new LunaMetallicTheme();
     private static readonly Theme s_aeroNormalColorTheme = new AeroNormalColorTheme();
-    private static readonly Theme s_aero2NormalColorTheme = new Windows8Theme();
     private static readonly Theme s_royaleNormalColorTheme = new RoyaleNormalColorTheme();
     private static readonly Theme s_zuneNormalColorTheme = new ZuneNormalColorTheme();
     private static readonly Theme s_windows7Theme = new Windows7Theme();
+    private static readonly Theme s_aero2NormalColorTheme = new Windows8Theme();
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeKey.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeKey.cs
index dbf58a25..ef9cc2bb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeKey.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Markup/ThemeKey.cs
@@ -15,14 +15,12 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
+using System.ComponentModel;
 using System.Reflection;
-using System.Text;
 using System.Windows;
 using System.Windows.Markup;
-using Xceed.Wpf.DataGrid.Views;
 using System.Windows.Media;
-using System.ComponentModel;
+using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid.Markup
 {
@@ -34,7 +32,7 @@ namespace Xceed.Wpf.DataGrid.Markup
     {
     }
 
-    public ThemeKey( Type targetViewType, Type themeType, Type targetElementType, Brush targetAccentBrush )
+    public ThemeKey( Type targetViewType, Type themeType, Type targetElementType )
     {
       if( targetViewType == null )
         throw new ArgumentNullException( "targetViewType" );
@@ -48,43 +46,13 @@ namespace Xceed.Wpf.DataGrid.Markup
       m_themeTypeInitialized = true;
       m_targetElementType = targetElementType;
       m_targetElementTypeInitialized = true;
-      m_targetAccentBrush = targetAccentBrush;
-      m_targetAccentBrushInitialized = true;
     }
 
     public ThemeKey( Type targetViewType, Type targetElementType )
-      : this( targetViewType, null, targetElementType, null )
-    {
-    }
-
-    public ThemeKey( Type targetViewType, Type themeType, Type targetElementType )
-      : this( targetViewType, themeType, targetElementType, null )
+      : this( targetViewType, null, targetElementType )
     {
     }
 
-    #region TargetAccentBrush Property
-
-    public Brush TargetAccentBrush
-    {
-      get
-      {
-        return m_targetAccentBrush;
-      }
-      set
-      {
-        if( m_targetAccentBrushInitialized )
-          throw new InvalidOperationException( "An attempt was made to set the TargetAccentBrush property when it has already been initialized." );
-
-        m_targetAccentBrush = value;
-        m_targetAccentBrushInitialized = true;
-      }
-    }
-
-    private Brush m_targetAccentBrush; // = null;
-    private bool m_targetAccentBrushInitialized; // = false;
-
-    #endregion TargetAccentBrush Property
-
     #region TargetViewType Property
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly" )]
@@ -177,32 +145,33 @@ namespace Xceed.Wpf.DataGrid.Markup
 
     public override bool Equals( object obj )
     {
-      ThemeKey key = obj as ThemeKey;
-
-      if( key == null )
-        return false;
-
-      if( !( ( key.TargetViewType != null ) ? key.TargetViewType.Equals( this.TargetViewType ) : ( this.TargetViewType == null ) ) )
-        return false;
-
-      if( !( ( key.ThemeType != null ) ? key.ThemeType.Equals( this.ThemeType ) : ( this.ThemeType == null ) ) )
-        return false;
-
-      if( !( ( key.TargetElementType != null ) ? key.TargetElementType.Equals( this.TargetElementType ) : ( this.TargetElementType == null ) ) )
-        return false;
+      if( object.ReferenceEquals( obj, this ) )
+        return true;
 
-      if( !( ( key.TargetAccentBrush != null ) ? key.TargetAccentBrush.Equals( this.TargetAccentBrush ) : ( this.TargetAccentBrush == null ) ) )
+      var key = obj as ThemeKey;
+      if( object.ReferenceEquals( key, null ) )
         return false;
 
-      return true;
+      return ( object.Equals( key.TargetViewType, this.TargetViewType ) )
+          && ( object.Equals( key.ThemeType, this.ThemeType ) )
+          && ( object.Equals( key.TargetElementType, this.TargetElementType ) );
     }
 
     public override int GetHashCode()
     {
-      return ( ( ( this.TargetViewType != null ) ? this.TargetViewType.GetHashCode() : 0 )
-        ^ ( ( this.ThemeType != null ) ? this.ThemeType.GetHashCode() : 0 )
-        ^ ( ( this.TargetElementType != null ) ? this.TargetElementType.GetHashCode() : 0 ) 
-        ^ ( ( this.TargetAccentBrush != null ) ? this.TargetAccentBrush.GetHashCode() : 0 ) );
+      var elementType = this.TargetElementType;
+      if( elementType != null )
+        return elementType.GetHashCode();
+
+      var viewType = this.TargetViewType;
+      if( viewType != null )
+        return viewType.GetHashCode();
+
+      var themeType = this.ThemeType;
+      if( themeType != null )
+        return themeType.GetHashCode();
+
+      return 0;
     }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyCollectionChangedEventArgsExtensions.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyCollectionChangedEventArgsExtensions.cs
new file mode 100644
index 00000000..26ee117f
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyCollectionChangedEventArgsExtensions.cs
@@ -0,0 +1,36 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Specialized;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal static class NotifyCollectionChangedEventArgsExtensions
+  {
+    internal static NotifyCollectionChangedEventArgs GetRangeActionOrSelf( this NotifyCollectionChangedEventArgs source )
+    {
+      if( source == null )
+        throw new ArgumentNullException( "source" );
+
+      var rangeEventArgs = source as NotifyRangeCollectionChangedEventArgs;
+      if( rangeEventArgs != null )
+        return rangeEventArgs.OriginalEventArgs;
+
+      return source;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyRangeCollectionChangedEventArgs.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyRangeCollectionChangedEventArgs.cs
new file mode 100644
index 00000000..4292c81a
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/NotifyRangeCollectionChangedEventArgs.cs
@@ -0,0 +1,51 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Specialized;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class NotifyRangeCollectionChangedEventArgs : NotifyCollectionChangedEventArgs
+  {
+    #region Constructor
+
+    internal NotifyRangeCollectionChangedEventArgs( NotifyCollectionChangedEventArgs args )
+      : base( NotifyCollectionChangedAction.Reset )
+    {
+      if( args == null )
+        throw new ArgumentNullException( "args" );
+
+      m_originalEventArgs = args;
+    }
+
+    #endregion
+
+    #region OriginalEventArgs Property
+
+    internal NotifyCollectionChangedEventArgs OriginalEventArgs
+    {
+      get
+      {
+        return m_originalEventArgs;
+      }
+    }
+
+    private readonly NotifyCollectionChangedEventArgs m_originalEventArgs;
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ObservableColumnCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ObservableColumnCollection.cs
new file mode 100644
index 00000000..71cce324
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ObservableColumnCollection.cs
@@ -0,0 +1,220 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+
+namespace Xceed.Wpf.DataGrid
+{
+  public class ObservableColumnCollection : ObservableCollection<ColumnBase>
+  {
+    public ColumnBase this[ string fieldName ]
+    {
+      get
+      {
+        ColumnBase column = null;
+
+        m_fieldNameToColumns.TryGetValue( fieldName, out column );
+
+        return column;
+      }
+    }
+
+    #region ProcessingVisibleColumnsUpdate Property
+
+    internal AutoResetFlag ProcessingVisibleColumnsUpdate
+    {
+      get
+      {
+        return m_processingVisibleColumnsUpdate;
+      }
+    }
+
+    private readonly AutoResetFlag m_processingVisibleColumnsUpdate = AutoResetFlagFactory.Create();
+
+    #endregion
+
+    #region ProcessingCollectionChangedUpdate Property
+
+    internal bool ProcessingCollectionChangedUpdate
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    protected override void RemoveItem( int index )
+    {
+      ColumnBase column = this[ index ];
+
+      if( column != null )
+      {
+        this.UnregisterColumnChangedEvent( column );
+
+        m_fieldNameToColumns.Remove( column.FieldName );
+      }
+
+      base.RemoveItem( index );
+    }
+
+    protected override void InsertItem( int index, ColumnBase item )
+    {
+      if( item != null )
+      {
+        if( ( item != null ) && ( string.IsNullOrEmpty( item.FieldName ) == true ) )
+          throw new ArgumentException( "A column must have a fieldname.", "item" );
+
+        if( m_fieldNameToColumns.ContainsKey( item.FieldName ) )
+          throw new DataGridException( "A column with same field name already exists in collection." );
+
+        m_fieldNameToColumns.Add( item.FieldName, item );
+
+        this.RegisterColumnChangedEvent( item );
+      }
+
+      base.InsertItem( index, item );
+    }
+
+    protected override void ClearItems()
+    {
+      foreach( ColumnBase column in this )
+      {
+        this.UnregisterColumnChangedEvent( column );
+      }
+
+      m_fieldNameToColumns.Clear();
+
+      base.ClearItems();
+    }
+
+    protected override void SetItem( int index, ColumnBase item )
+    {
+      if( ( item != null ) && ( string.IsNullOrEmpty( item.FieldName ) == true ) )
+        throw new ArgumentException( "A column must have a fieldname.", "item" );
+
+      if( m_fieldNameToColumns.ContainsKey( item.FieldName ) )
+        throw new DataGridException( "A column with same field name already exists in collection." );
+
+      ColumnBase column = this[ index ];
+
+      if( ( column != null ) && ( column != item ) )
+      {
+        this.UnregisterColumnChangedEvent( column );
+
+        m_fieldNameToColumns.Remove( column.FieldName );
+      }
+
+      if( ( item != null ) && ( column != item ) )
+      {
+        m_fieldNameToColumns.Add( item.FieldName, item );
+
+        this.RegisterColumnChangedEvent( item );
+      }
+
+      base.SetItem( index, item );
+    }
+
+    protected override void OnCollectionChanged( NotifyCollectionChangedEventArgs e )
+    {
+      if( ( m_columnAdditionMessagesDeferedCount > 0 ) && ( e.Action == NotifyCollectionChangedAction.Add ) && ( e.NewStartingIndex == ( this.Count - e.NewItems.Count ) ) )
+      {
+        if( m_deferedColumnAdditionMessageStartIndex == -1 )
+        {
+          m_deferedColumnAdditionMessageStartIndex = e.NewStartingIndex;
+        }
+
+        foreach( object item in e.NewItems )
+        {
+          m_deferedColumns.Add( ( ColumnBase )item );
+        }
+      }
+      else
+      {
+        base.OnCollectionChanged( e );
+      }
+    }
+
+    internal IDisposable DeferColumnAdditionMessages()
+    {
+      return new DeferedColumnAdditionMessageDisposable( this );
+    }
+
+    internal event EventHandler ColumnVisibilityChanged;
+
+    private void RegisterColumnChangedEvent( ColumnBase column )
+    {
+      column.VisiblePositionChanged += new EventHandler( this.OnColumnVisibilityChanged );
+      column.VisibleChanged += new EventHandler( this.OnColumnVisibilityChanged );
+    }
+
+    private void UnregisterColumnChangedEvent( ColumnBase column )
+    {
+      column.VisiblePositionChanged -= new EventHandler( this.OnColumnVisibilityChanged );
+      column.VisibleChanged -= new EventHandler( this.OnColumnVisibilityChanged );
+    }
+
+    private void OnColumnVisibilityChanged( object sender, EventArgs e )
+    {
+      if( this.ColumnVisibilityChanged != null )
+      {
+        this.ColumnVisibilityChanged( this, new ColumnCollection.WrappedEventEventArgs( sender, e ) );
+      }
+    }
+
+    private int m_columnAdditionMessagesDeferedCount = 0;
+    private int m_deferedColumnAdditionMessageStartIndex = -1;
+    private List<ColumnBase> m_deferedColumns = new List<ColumnBase>();
+    private Dictionary<string, ColumnBase> m_fieldNameToColumns = new Dictionary<string, ColumnBase>(); // To optimize indexing speed for FieldName
+
+    private sealed class DeferedColumnAdditionMessageDisposable : IDisposable
+    {
+      internal DeferedColumnAdditionMessageDisposable( ObservableColumnCollection columns )
+      {
+        if( columns == null )
+          throw new ArgumentNullException( "columns" );
+
+        m_columns = columns;
+
+        m_columns.m_columnAdditionMessagesDeferedCount++;
+      }
+
+      #region IDisposable Members
+
+      public void Dispose()
+      {
+        m_columns.m_columnAdditionMessagesDeferedCount--;
+
+        if( m_columns.m_columnAdditionMessagesDeferedCount == 0 )
+        {
+          if( m_columns.m_deferedColumns.Count > 0 )
+          {
+            m_columns.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, m_columns.m_deferedColumns, m_columns.m_deferedColumnAdditionMessageStartIndex ) );
+          }
+
+          m_columns.m_deferedColumnAdditionMessageStartIndex = -1;
+          m_columns.m_deferedColumns.Clear();
+        }
+      }
+
+      #endregion
+
+      private ObservableColumnCollection m_columns; // = null
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RecyclingManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RecyclingManager.cs
index 19f99ad1..217e4e79 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RecyclingManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RecyclingManager.cs
@@ -14,24 +14,53 @@
 
   ***********************************************************************************/
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Diagnostics;
 using System.Windows;
 
 namespace Xceed.Wpf.DataGrid
 {
-  internal class RecyclingManager
+  internal sealed class RecyclingManager
   {
-    public void EnqueueItemContainer( DependencyObject container )
+    #region RefCount Property
+
+    public int RefCount
+    {
+      get
+      {
+        return m_generators.Count;
+      }
+    }
+
+    #endregion
+
+    public void EnqueueItemContainer( object item, DependencyObject container )
     {
-      m_itemRecyclingStack.Push( container );
+      Debug.Assert( container != null );
+
+      var entry = new ItemRecyclingPoolContainer( item, container );
+
+      m_itemRecyclingPool.Add( entry, entry );
     }
 
-    public DependencyObject DequeueItemContainer()
+    public DependencyObject DequeueItemContainer( object item )
     {
-      if( m_itemRecyclingStack.Count > 0 )
-        return m_itemRecyclingStack.Pop();
+      if( m_itemRecyclingPool.Count <= 0 )
+        return null;
 
-      return null;
+      var retriever = new ItemRecyclingPoolContainerRetriever( item );
+
+      ItemRecyclingPoolEntry value;
+      if( !m_itemRecyclingPool.TryGetValue( retriever, out value ) )
+      {
+        value = m_itemRecyclingPool.First().Value;
+      }
+
+      m_itemRecyclingPool.Remove( value );
+
+      return value.Container;
     }
 
     public void EnqueueHeaderFooterContainer( object key, DependencyObject container )
@@ -88,7 +117,6 @@ namespace Xceed.Wpf.DataGrid
 
     public DependencyObject DequeueGroupHeaderFooterContainer( object key, object item )
     {
-
       Dictionary<object, Stack<DependencyObject>> headerFooterRecyclingStacks;
 
       if( m_groupLevelRecyclingStacks.TryGetValue( key, out headerFooterRecyclingStacks ) )
@@ -112,14 +140,10 @@ namespace Xceed.Wpf.DataGrid
 
     public IList<DependencyObject> Clear()
     {
-      List<DependencyObject> removedContainers = new List<DependencyObject>();
+      var removedContainers = new List<DependencyObject>( ( from entry in m_itemRecyclingPool.Values
+                                                            select entry.Container ) );
 
-      foreach( DependencyObject container in m_itemRecyclingStack )
-      {
-        removedContainers.Add( container );
-      }
-
-      m_itemRecyclingStack.Clear();
+      m_itemRecyclingPool.Clear();
 
       foreach( Stack<DependencyObject> stack in m_headerRecyclingStacks.Values )
       {
@@ -155,32 +179,164 @@ namespace Xceed.Wpf.DataGrid
 
     public void AddRef( CustomItemContainerGenerator reference )
     {
-      if( m_refList.Contains( reference ) == false )
+      Debug.Assert( reference != null );
+
+      if( m_generators.Contains( reference ) )
+        return;
+
+      m_generators.Add( reference );
+    }
+
+    public void RemoveRef( CustomItemContainerGenerator reference )
+    {
+      Debug.Assert( reference != null );
+
+      m_generators.Remove( reference );
+    }
+
+    #region Private Fields
+
+    private readonly Dictionary<object, Dictionary<object, Stack<DependencyObject>>> m_groupLevelRecyclingStacks = new Dictionary<object, Dictionary<object, Stack<DependencyObject>>>();
+    private readonly Dictionary<object, Stack<DependencyObject>> m_headerRecyclingStacks = new Dictionary<object, Stack<DependencyObject>>();
+    private readonly Dictionary<ItemRecyclingPoolEntry, ItemRecyclingPoolEntry> m_itemRecyclingPool = new Dictionary<ItemRecyclingPoolEntry, ItemRecyclingPoolEntry>( new ItemRecyclingPoolEqualityComparer() );
+    private readonly HashSet<CustomItemContainerGenerator> m_generators = new HashSet<CustomItemContainerGenerator>();
+
+    #endregion
+
+    #region ItemRecyclingPoolEntry Private Class
+
+    private abstract class ItemRecyclingPoolEntry
+    {
+      internal ItemRecyclingPoolEntry( object dataItem )
+      {
+        m_key = ( dataItem != null ) ? dataItem.GetHashCode() : 0;
+      }
+
+      internal int Key
+      {
+        get
+        {
+          return m_key;
+        }
+      }
+
+      // This property has been set here to remove the casts every time we want to
+      // retrieve the container from an instance of ItemRecyclingPoolContainer.
+      internal abstract DependencyObject Container
+      {
+        get;
+      }
+
+      public override int GetHashCode()
       {
-        m_refList.Add( reference );
+        return m_key;
       }
+
+      public override bool Equals( object obj )
+      {
+        var item = obj as ItemRecyclingPoolEntry;
+        if( item == null )
+          return false;
+
+        return ( item.m_key == m_key );
+      }
+
+      private readonly int m_key;
     }
 
-    public void RemoveRef( CustomItemContainerGenerator reference )
+    #endregion
+
+    #region ItemRecyclingPoolContainer Private Class
+
+    private sealed class ItemRecyclingPoolContainer : ItemRecyclingPoolEntry
     {
-      if( m_refList.Contains( reference ) == true )
+      internal ItemRecyclingPoolContainer( object dataItem, DependencyObject container )
+        : base( dataItem )
+      {
+        Debug.Assert( container != null );
+
+        m_container = container;
+      }
+
+      internal override DependencyObject Container
       {
-        m_refList.Remove( reference );
+        get
+        {
+          return m_container;
+        }
+      }
+
+      public override int GetHashCode()
+      {
+        return base.GetHashCode();
+      }
+
+      public override bool Equals( object obj )
+      {
+        if( !base.Equals( obj ) )
+          return false;
+
+        if( obj == this )
+          return true;
+
+        var item = obj as ItemRecyclingPoolContainer;
+
+        return ( item != null )
+            && ( item.m_container == m_container );
       }
+
+      private readonly DependencyObject m_container;
     }
 
-    public int RefCount
+    #endregion
+
+    #region ItemRecyclingPoolContainerRetriever Private Class
+
+    private sealed class ItemRecyclingPoolContainerRetriever : ItemRecyclingPoolEntry
     {
-      get
+      internal ItemRecyclingPoolContainerRetriever( object dataItem )
+        : base( dataItem )
+      {
+      }
+
+      internal override DependencyObject Container
       {
-        return m_refList.Count;
+        get
+        {
+          throw new NotSupportedException( "A retriever has no container." );
+        }
       }
     }
 
-    private readonly Dictionary<object, Dictionary<object, Stack<DependencyObject>>> m_groupLevelRecyclingStacks = new Dictionary<object, Dictionary<object, Stack<DependencyObject>>>();
-    private readonly Dictionary<object, Stack<DependencyObject>> m_headerRecyclingStacks = new Dictionary<object, Stack<DependencyObject>>();
-    private readonly Stack<DependencyObject> m_itemRecyclingStack = new Stack<DependencyObject>();
-    private readonly List<CustomItemContainerGenerator> m_refList = new List<CustomItemContainerGenerator>();
+    #endregion
+
+    #region ItemRecyclingPoolEqualityComparer Private Class
+
+    private sealed class ItemRecyclingPoolEqualityComparer : IEqualityComparer<ItemRecyclingPoolEntry>
+    {
+      public int GetHashCode( ItemRecyclingPoolEntry obj )
+      {
+        Debug.Assert( obj != null );
+
+        return obj.GetHashCode();
+      }
+
+      public bool Equals( ItemRecyclingPoolEntry x, ItemRecyclingPoolEntry y )
+      {
+        if( object.ReferenceEquals( x, y ) )
+          return true;
+
+        if( object.ReferenceEquals( x, null ) || object.ReferenceEquals( y, null ) )
+          return false;
+
+        // If one of the entry is a retriever, invoke its Equals method so the retriever may do its job.
+        if( x is ItemRecyclingPoolContainerRetriever )
+          return x.Equals( y );
+
+        return y.Equals( x );
+      }
+    }
 
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RequestBringIntoViewWeakEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RequestBringIntoViewWeakEventManager.cs
new file mode 100644
index 00000000..5b689afe
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RequestBringIntoViewWeakEventManager.cs
@@ -0,0 +1,81 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class RequestBringIntoViewWeakEventManager : WeakEventManager
+  {
+    #region Constructor
+
+    private RequestBringIntoViewWeakEventManager()
+    {
+    }
+
+    #endregion
+
+    #region CurrentManager Static Property
+
+    private static RequestBringIntoViewWeakEventManager CurrentManager
+    {
+      get
+      {
+        var managerType = typeof( RequestBringIntoViewWeakEventManager );
+        var currentManager = ( RequestBringIntoViewWeakEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new RequestBringIntoViewWeakEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    #endregion
+
+    public static void AddListener( FrameworkElement source, IWeakEventListener listener )
+    {
+      RequestBringIntoViewWeakEventManager.CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( FrameworkElement source, IWeakEventListener listener )
+    {
+      RequestBringIntoViewWeakEventManager.CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var fe = ( FrameworkElement )source;
+
+      fe.RequestBringIntoView += new RequestBringIntoViewEventHandler( this.OnEventRaised );
+    }
+
+    protected override void StopListening( object source )
+    {
+      var fe = ( FrameworkElement )source;
+
+      fe.RequestBringIntoView -= new RequestBringIntoViewEventHandler( this.OnEventRaised );
+    }
+
+    private void OnEventRaised( object sender, RequestBringIntoViewEventArgs e )
+    {
+      this.DeliverEvent( sender, e );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/InvalidValueException.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RequestingDelayBringIntoViewAndFocusCurrentEventArgs.cs
similarity index 53%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/InvalidValueException.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RequestingDelayBringIntoViewAndFocusCurrentEventArgs.cs
index 1d895e72..0134c4e6 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/InvalidValueException.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RequestingDelayBringIntoViewAndFocusCurrentEventArgs.cs
@@ -15,31 +15,28 @@
   ***********************************************************************************/
 
 using System;
-using System.Runtime.Serialization;
 
-namespace Xceed.Wpf.DataGrid.Stats
+namespace Xceed.Wpf.DataGrid
 {
-  [Serializable]
-  internal class InvalidValueException : DataGridException
+  internal class RequestingDelayBringIntoViewAndFocusCurrentEventArgs : EventArgs
   {
-    public InvalidValueException()
-      : base()
+    internal RequestingDelayBringIntoViewAndFocusCurrentEventArgs( AutoScrollCurrentItemSourceTriggers trigger )
     {
+      m_trigger = trigger;
     }
 
-    public InvalidValueException( string message )
-      : base( message )
-    {
-    }
+    #region Trigger Property
 
-    public InvalidValueException( string message, Exception innerException )
-      : base( message, innerException )
+    internal AutoScrollCurrentItemSourceTriggers Trigger
     {
+      get
+      {
+        return m_trigger;
+      }
     }
 
-    protected InvalidValueException( SerializationInfo info, StreamingContext context )
-      : base( info, context )
-    {
-    }
+    private readonly AutoScrollCurrentItemSourceTriggers m_trigger;
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Row.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Row.cs
index 54d48f11..ac48d4b6 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Row.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Row.cs
@@ -17,29 +17,23 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Linq;
 using System.Reflection;
 using System.Windows;
+using System.Windows.Automation.Peers;
 using System.Windows.Controls;
 using System.Windows.Data;
+using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Markup;
 using System.Windows.Media;
-using System.Security;
-using System.Security.Permissions;
-using System.Windows.Automation.Peers;
-
-using Xceed.Wpf.DataGrid.Print;
-using Xceed.Wpf.DataGrid.ValidationRules;
-using Xceed.Wpf.DataGrid.Views;
 using Xceed.Utils.Wpf;
-using Xceed.Wpf.DataGrid.Export;
 using Xceed.Wpf.DataGrid.Automation;
-using System.Windows.Threading;
-using System.Windows.Media.Animation;
+using Xceed.Wpf.DataGrid.ValidationRules;
+using Xceed.Wpf.DataGrid.Views;
 using Xceed.Wpf.Toolkit.Core;
 
 namespace Xceed.Wpf.DataGrid
@@ -47,7 +41,7 @@ namespace Xceed.Wpf.DataGrid
   [TemplatePart( Name = "PART_CellsHost", Type = typeof( Panel ) )]
   [TemplatePart( Name = "PART_RowFocusRoot", Type = typeof( FrameworkElement ) )]
   [ContentProperty( "Cells" )]
-  public abstract class Row : Control, IPrintInfo, IDataGridItemContainer
+  public abstract class Row : Control, IDataGridItemContainer
   {
     // This validation rule is meant to be used as the rule in error set in a Row's ValidationError when
     // we want to flag a validation error even though no binding's ValidationRules or CellValidationRules are invalid.
@@ -76,6 +70,12 @@ namespace Xceed.Wpf.DataGrid
 
       // We do this last to ensure all the Static content of the row is done before using 
       // any static readonly field of the cell.
+      Row.SelectionBackgroundProperty = Cell.SelectionBackgroundProperty.AddOwner( typeof( Row ) );
+      Row.SelectionForegroundProperty = Cell.SelectionForegroundProperty.AddOwner( typeof( Row ) );
+      Row.InactiveSelectionBackgroundProperty = Cell.InactiveSelectionBackgroundProperty.AddOwner( typeof( Row ) );
+      Row.InactiveSelectionForegroundProperty = Cell.InactiveSelectionForegroundProperty.AddOwner( typeof( Row ) );
+      Row.ParentForegroundProperty = Cell.ParentForegroundProperty.AddOwner( typeof( Row ) );
+
       EventManager.RegisterClassHandler( typeof( Row ), Cell.IsDirtyEvent, new RoutedEventHandler( OnCellIsDirty_ClassHandler ) );
       Row.IsDirtyEvent = Cell.IsDirtyEvent.AddOwner( typeof( Row ) );
     }
@@ -125,11 +125,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region Cells Read-Only Property
 
-    private static readonly DependencyPropertyKey CellsPropertyKey =
-        DependencyProperty.RegisterReadOnly( "Cells",
-        typeof( CellCollection ),
-        typeof( Row ),
-        new PropertyMetadata( null ) );
+    private static readonly DependencyPropertyKey CellsPropertyKey = DependencyProperty.RegisterReadOnly(
+      "Cells",
+      typeof( CellCollection ),
+      typeof( Row ),
+      new PropertyMetadata( null ) );
 
     public static readonly DependencyProperty CellsProperty;
 
@@ -287,8 +287,11 @@ namespace Xceed.Wpf.DataGrid
 
     #region IsBeingEdited Read-Only Property
 
-    internal static readonly DependencyPropertyKey IsBeingEditedPropertyKey =
-        DependencyProperty.RegisterReadOnly( "IsBeingEdited", typeof( bool ), typeof( Row ), new PropertyMetadata( false, new PropertyChangedCallback( OnIsBeingEditedChanged ) ) );
+    internal static readonly DependencyPropertyKey IsBeingEditedPropertyKey = DependencyProperty.RegisterReadOnly(
+      "IsBeingEdited",
+      typeof( bool ),
+      typeof( Row ),
+      new PropertyMetadata( false, new PropertyChangedCallback( OnIsBeingEditedChanged ) ) );
 
     public static readonly DependencyProperty IsBeingEditedProperty;
 
@@ -498,11 +501,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region SelectionBackground Property
 
-    public static readonly DependencyProperty SelectionBackgroundProperty =
-      DependencyProperty.Register( "SelectionBackground",
-      typeof( Brush ),
-      typeof( Row ),
-      new FrameworkPropertyMetadata( null ) );
+    public static readonly DependencyProperty SelectionBackgroundProperty;
 
     public Brush SelectionBackground
     {
@@ -520,11 +519,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region SelectionForeground Property
 
-    public static readonly DependencyProperty SelectionForegroundProperty =
-      DependencyProperty.Register( "SelectionForeground",
-      typeof( Brush ),
-      typeof( Row ),
-      new FrameworkPropertyMetadata( null ) );
+    public static readonly DependencyProperty SelectionForegroundProperty;
 
     public Brush SelectionForeground
     {
@@ -542,11 +537,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region InactiveSelectionBackground Property
 
-    public static readonly DependencyProperty InactiveSelectionBackgroundProperty =
-      DependencyProperty.Register( "InactiveSelectionBackground",
-      typeof( Brush ),
-      typeof( Row ),
-      new FrameworkPropertyMetadata( null ) );
+    public static readonly DependencyProperty InactiveSelectionBackgroundProperty;
 
     public Brush InactiveSelectionBackground
     {
@@ -564,11 +555,7 @@ namespace Xceed.Wpf.DataGrid
 
     #region InactiveSelectionForeground Property
 
-    public static readonly DependencyProperty InactiveSelectionForegroundProperty =
-      DependencyProperty.Register( "InactiveSelectionForeground",
-      typeof( Brush ),
-      typeof( Row ),
-      new FrameworkPropertyMetadata( null ) );
+    public static readonly DependencyProperty InactiveSelectionForegroundProperty;
 
     public Brush InactiveSelectionForeground
     {
@@ -584,6 +571,47 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion InactiveSelectionForeground Property
 
+    #region ParentForeground Property
+
+    [Browsable( false )]
+    [EditorBrowsable( EditorBrowsableState.Never )]
+    public static readonly DependencyProperty ParentForegroundProperty;
+
+    [Browsable( false )]
+    [EditorBrowsable( EditorBrowsableState.Never )]
+    public Brush ParentForeground
+    {
+      get
+      {
+        return ( Brush )this.GetValue( Row.ParentForegroundProperty );
+      }
+      set
+      {
+        this.SetValue( Row.ParentForegroundProperty, value );
+      }
+    }
+
+    private void UpdateParentForeground()
+    {
+      // Use the visual parent when there is no logical parent.
+      var parent = LogicalTreeHelper.GetParent( this ) ?? VisualTreeHelper.GetParent( this );
+
+      if( parent != null )
+      {
+        var binding = new Binding();
+        binding.Path = new PropertyPath( TextElement.ForegroundProperty );
+        binding.Source = parent;
+
+        this.SetBinding( Row.ParentForegroundProperty, binding );
+      }
+      else
+      {
+        this.ClearValue( Row.ParentForegroundProperty );
+      }
+    }
+
+    #endregion ParentForeground Property
+
     #region RowFocusRoot Property
 
     private FrameworkElement m_rowFocusRoot;
@@ -867,6 +895,28 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region LevelCache Property
+
+    internal static readonly DependencyProperty LevelCacheProperty = DependencyProperty.Register(
+      "LevelCache",
+      typeof( int ),
+      typeof( Row ),
+      new FrameworkPropertyMetadata( -1 ) );
+
+    internal int LevelCache
+    {
+      get
+      {
+        return ( int )this.GetValue( Row.LevelCacheProperty );
+      }
+      set
+      {
+        this.SetValue( Row.LevelCacheProperty, value );
+      }
+    }
+
+    #endregion
+
     public static Row FindFromChild( DependencyObject child )
     {
       return Row.FindFromChild( ( DataGridContext )null, child );
@@ -891,7 +941,9 @@ namespace Xceed.Wpf.DataGrid
           RowSelector rowSelector = child as RowSelector;
 
           if( rowSelector != null )
+          {
             row = rowSelector.DataContext as Row;
+          }
         }
 
         if( ( row != null )
@@ -939,60 +991,61 @@ namespace Xceed.Wpf.DataGrid
 
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
       if( dataGridContext == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "DataGridContext is null for Row." );
 
       DataGridControl gridControl = dataGridContext.DataGridControl;
       if( gridControl == null )
-        throw new DataGridInternalException();
+        throw new DataGridInternalException( "DataGridControl is null for Row." );
 
       m_rowFocusRoot = this.GetTemplateChild( "PART_RowFocusRoot" ) as FrameworkElement;
 
-      {
-        m_oldCellsHostPanel = m_cellsHostPanel;
-
-        IVirtualizingCellsHost oldVirtualizingCellsHost = m_oldCellsHostPanel as IVirtualizingCellsHost;
+      var oldCellsHostPanel = m_cellsHostPanel;
+      var oldVirtualizingCellsHost = oldCellsHostPanel as IVirtualizingCellsHost;
 
-        if( oldVirtualizingCellsHost != null )
-          oldVirtualizingCellsHost.ClearCellsHost();
-
-        m_cellsHostPanel = this.GetTemplateChild( "PART_CellsHost" ) as Panel;
+      if( oldVirtualizingCellsHost != null )
+      {
+        oldVirtualizingCellsHost.ClearCellsHost();
+      }
 
-        if( m_rowFocusRoot == null )
-          m_rowFocusRoot = m_cellsHostPanel;
+      m_cellsHostPanel = this.GetTemplateChild( "PART_CellsHost" ) as Panel;
 
-        m_templateCells.Clear();
+      if( m_rowFocusRoot == null )
+      {
+        m_rowFocusRoot = m_cellsHostPanel;
+      }
 
-        this.GetTemplateCells( this, m_templateCells );
+      m_templateCells.Clear();
 
-        this.PreparePreviousTemplateCells();
+      this.GetTemplateCells( this, m_templateCells );
 
-        this.SynchronizeCellsWithColumns( gridControl, m_templateCells, false );
+      this.PreparePreviousTemplateCells();
 
-        if( m_oldCellsHostPanel != null )
-          m_oldCellsHostPanel.Children.Clear();
+      this.SynchronizeCellsWithColumns( gridControl, m_templateCells, false );
 
-        IVirtualizingCellsHost virtualizingCellsHost = m_cellsHostPanel as IVirtualizingCellsHost;
+      if( oldCellsHostPanel != null )
+      {
+        oldCellsHostPanel.Children.Clear();
+      }
 
-        if( virtualizingCellsHost != null )
+      var virtualizingCellsHost = m_cellsHostPanel as IVirtualizingCellsHost;
+      if( virtualizingCellsHost != null )
+      {
+        this.PrepareCellsHost( dataGridContext );
+      }
+      else
+      {
+        // Reset the flag
+        if( gridControl.ForceGeneratorReset == false )
         {
-          // Ensure to register to the TableViewColumnVirtualizationManager
-          virtualizingCellsHost.PrepareCellsHost( dataGridContext );
-
-          // We force an InvalidateMeasure on the CellsHost to be sure
-          // the visible Cells are the good ones
-          virtualizingCellsHost.InvalidateCellsHostMeasure();
+          gridControl.ForceGeneratorReset = true;
         }
-        else
-        {
-          // Reset the flag
-          if( gridControl.ForceGeneratorReset == false )
-            gridControl.ForceGeneratorReset = true;
 
-          this.PutCellsInVisualTree( m_templateCells );
+        if( ( m_cellsHostPanel != null ) && ( m_cellsHostPanel != oldCellsHostPanel ) )
+        {
+          m_cellsHostPanel.Children.Clear();
         }
 
-
-        m_oldCellsHostPanel = null;
+        this.PutCellsInVisualTree( m_templateCells );
       }
 
       this.UpdateNavigationBehavior();
@@ -1062,36 +1115,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    protected override void OnMouseEnter( MouseEventArgs e )
-    {
-      base.OnMouseEnter( e );
-
-      //If the current CellEditorDisplayConditions requires display when mouse is over the Row 
-      if( Row.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverRow ) )
-      {
-        //Display the editors for the Row
-        this.SetDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverRow );
-      }
-
-      // In case a value was explicitly specified on the Cell's ParentColumn
-      this.RefreshCellsDisplayedTemplate();
-    }
-
-    protected override void OnMouseLeave( MouseEventArgs e )
-    {
-      base.OnMouseLeave( e );
-
-      //If the current CellEditorDisplayConditions requires display when mouse is over the Row 
-      if( Row.IsCellEditorDisplayConditionsSet( this, CellEditorDisplayConditions.MouseOverRow ) )
-      {
-        //Display the editors for the Row
-        this.RemoveDisplayEditorMatchingCondition( CellEditorDisplayConditions.MouseOverRow );
-      }
-
-      // In case a value was explicitly specified on the Cell's ParentColumn
-      this.RefreshCellsDisplayedTemplate();
-    }
-
     protected override void OnIsKeyboardFocusWithinChanged( DependencyPropertyChangedEventArgs e )
     {
       base.OnIsKeyboardFocusWithinChanged( e );
@@ -1126,6 +1149,13 @@ namespace Xceed.Wpf.DataGrid
       return new RowAutomationPeer( this );
     }
 
+    protected override void OnVisualParentChanged( DependencyObject oldParent )
+    {
+      base.OnVisualParentChanged( oldParent );
+
+      this.UpdateParentForeground();
+    }
+
     protected virtual void SetDataContext( object item )
     {
       this.DataContext = item;
@@ -1136,11 +1166,8 @@ namespace Xceed.Wpf.DataGrid
       this.DataContext = null;
     }
 
-    protected internal virtual void PrepareContainer( DataGridContext dataGridContext, object item )
+    protected virtual void PrepareContainer( DataGridContext dataGridContext, object item )
     {
-      if( this.IsContainerPrepared )
-        Debug.Fail( "A Row can't be prepared twice, it must be cleaned before PrepareContainer is called again" );
-
       if( dataGridContext == null )
         throw new ArgumentNullException( "dataGridContext" );
 
@@ -1174,18 +1201,14 @@ namespace Xceed.Wpf.DataGrid
 
       if( virtualizingCellsHost != null )
       {
-        virtualizingCellsHost.PrepareCellsHost( dataGridContext );
-
-        // We force an InvalidateMeasure on the CellsHost to be sure
-        // the visible Cells are the good ones
-        virtualizingCellsHost.InvalidateCellsHostMeasure();
+        this.PrepareCellsHost( dataGridContext );
       }
       else
       {
         //re-Initialize all created cells for the new "assignation"
         foreach( Cell cell in this.CreatedCells )
         {
-          // Call Cell.PrepareContainer for cells already created
+          // Call Cell.PrepareContainer for cells already created          
           cell.PrepareContainer( dataGridContext, item );
         }
       }
@@ -1224,24 +1247,19 @@ namespace Xceed.Wpf.DataGrid
 
     protected abstract bool IsValidCellType( Cell cell );
 
-    protected internal virtual void ClearContainer()
+    protected virtual void ClearContainer()
     {
       this.IsClearingContainer = true;
 
       try
       {
-        // Clear every Cells before clearing the Row's values to allow the Cell
-        // to check some properties on there parent row when processing a Cell.ClearContainer
-        IVirtualizingCellsHost virtualizingCellsHost = this.CellsHostPanel as IVirtualizingCellsHost;
-
         // If there were some validation errors, we want to clear every Cells to be sure 
         // they will never reflect the error state on another data item if they are not 
         // explicitly prepared
-        if( virtualizingCellsHost != null )
-        {
-          virtualizingCellsHost.ClearCellsHost();
-        }
+        this.ClearCellsHost();
 
+        // Clear every Cells before clearing the Row's values to allow the Cell
+        // to check some properties on there parent row when processing a Cell.ClearContainer
         // Ensure every prepared Cells are cleared correctly
         foreach( Cell cell in m_cellsCache.Cells )
         {
@@ -1283,28 +1301,20 @@ namespace Xceed.Wpf.DataGrid
       if( container == null )
         return null;
 
-      Row row = container as Row;
-
+      var row = container as Row;
       if( row != null )
         return row;
 
-      HeaderFooterItem headerFooterItem = container as HeaderFooterItem;
-
-      if( headerFooterItem != null )
-      {
-        row = HeaderFooterItem.FindIDataGridItemContainerInChildren(
-          headerFooterItem, headerFooterItem.AsVisual() ) as Row;
-
-        if( row != null )
-          return row;
-      }
+      var itemContainer = container as IDataGridItemContainer;
+      if( itemContainer != null )
+        return ( Row )itemContainer.GetTemplatedDescendantDataGridItemContainers().FirstOrDefault( item => item is Row );
 
       return null;
     }
 
     internal static void SetRowValidationErrorOnException( Row row, Exception exception )
     {
-      System.Diagnostics.Debug.Assert( ( row != null ) && ( exception != null ) );
+      Debug.Assert( ( row != null ) && ( exception != null ) );
 
       // This method will set a validation error on the row and throw back a DataGridValidationException so that 
       // the row stays in edition.
@@ -1327,6 +1337,20 @@ namespace Xceed.Wpf.DataGrid
       return ( ( row.CellEditorDisplayConditions & condition ) == condition );
     }
 
+    internal void PrepareCellsHost()
+    {
+      this.PrepareCellsHost( DataGridControl.GetDataGridContext( this ) );
+    }
+
+    internal void ClearCellsHost()
+    {
+      var cellsHost = m_cellsHostPanel as IVirtualizingCellsHost;
+      if( cellsHost == null )
+        return;
+
+      cellsHost.ClearCellsHost();
+    }
+
     internal void UpdateCellsContentBindingTarget()
     {
       // We need to refresh the Cell.Content target binding in case the dataObject value was coerced to something else.
@@ -1336,13 +1360,9 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    internal void SynchronizeCellsWithColumns(
-      DataGridControl parentGrid,
-      Dictionary<string, Cell> templateCells,
-      bool onlyIfParentGridHasChanged )
+    internal void SynchronizeCellsWithColumns( DataGridControl parentGrid, Dictionary<string, Cell> templateCells, bool onlyIfParentGridHasChanged )
     {
-      if( ( !onlyIfParentGridHasChanged ) ||
-        ( parentGrid != m_parentGridUsedForCellsGeneration ) )
+      if( ( !onlyIfParentGridHasChanged ) || ( parentGrid != m_parentGridUsedForCellsGeneration ) )
       {
         if( templateCells == null )
         {
@@ -1351,7 +1371,12 @@ namespace Xceed.Wpf.DataGrid
           templateCells = m_templateCells;
         }
 
-        this.GenerateMissingAndRemoveUnusedCells( templateCells );
+        DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
+
+        if( dataGridContext == null )
+          return;
+
+        this.GenerateMissingAndRemoveUnusedCells( dataGridContext, dataGridContext.Columns, templateCells );
         m_parentGridUsedForCellsGeneration = parentGrid;
       }
     }
@@ -1472,13 +1497,17 @@ namespace Xceed.Wpf.DataGrid
         cell.PrepareDefaultStyleKey( view );
 
         if( ( virtualizingCellsHost != null ) && ( virtualizingCellsHost.CanModifyLogicalParent ) )
+        {
           virtualizingCellsHost.SetLogicalParent( cell );
+        }
 
         //optimization so that lookup speed will be increased for the Cells
         cell.SetValue( DataGridControl.DataGridContextPropertyKey, dataGridContext );
 
         if( ( rowIsCurrent ) && ( isCurrentColumn ) )
+        {
           cell.SetIsCurrent( true );
+        }
 
         // We must update the Focusable status for the newly created cell since
         // UpdateCellsFocusableStatus is only called in Row.OnApplyTemplate
@@ -1520,6 +1549,11 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    internal virtual HashedLinkedList<ColumnBase> GetColumnsByVisiblePosition( DataGridContext dataGridContext )
+    {
+      return dataGridContext.ColumnsByVisiblePosition;
+    }
+
     private static bool GetIsValidationErrorRestrictive( RowValidationError validationError )
     {
       if( validationError == null )
@@ -1575,6 +1609,19 @@ namespace Xceed.Wpf.DataGrid
       return retval;
     }
 
+    private void PrepareCellsHost( DataGridContext dataGridContext )
+    {
+      var cellsHost = m_cellsHostPanel as IVirtualizingCellsHost;
+      if( ( cellsHost == null ) || ( dataGridContext == null ) )
+        return;
+
+      // Ensure to register to the TableViewColumnVirtualizationManager
+      cellsHost.PrepareCellsHost( dataGridContext );
+
+      // We force an InvalidateMeasure on the CellsHost to be sure the visible Cells are the good ones
+      cellsHost.InvalidateCellsHostMeasure();
+    }
+
     private void UpdateMatchingDisplayConditions()
     {
       CellEditorDisplayConditions newEffectiveValue = CellEditorDisplayConditions.None;
@@ -1804,6 +1851,10 @@ namespace Xceed.Wpf.DataGrid
         foreach( Cell cell in this.CreatedCells )
         {
           ColumnBase parentColumn = cell.ParentColumn;
+
+          if( parentColumn == null )
+            continue;
+
           CellState cachedCellState;
 
           if( cachedCellStates.TryGetValue( parentColumn, out cachedCellState ) )
@@ -1828,33 +1879,28 @@ namespace Xceed.Wpf.DataGrid
         return;
       }
 
-      if( m_cellsHostPanel != m_oldCellsHostPanel )
-        m_cellsHostPanel.Children.Clear();
-
-      m_oldCellsHostPanel = null;
-
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
       if( dataGridContext == null )
         return;
 
       object dataItem = this.DataContext;
 
       // fill the cellsHostPanel in visible order.
-      foreach( ColumnBase column in dataGridContext.ColumnsByVisiblePosition )
+      foreach( ColumnBase column in this.GetColumnsByVisiblePosition( dataGridContext ) )
       {
         Cell cell = m_cellsCache[ column ];
 
         if( cell == null )
         {
-          //This situation is now a proof that something is awfully wrong since
-          //the VirtualizingCellCollection will create a cell if none is present.
-          throw new DataGridInternalException();
+          //This situation is now a proof that something is awfully wrong since the VirtualizingCellCollection will create a cell if none is present.
+          throw new DataGridInternalException( "No cell found or created for " + column.FieldName + " column.", dataGridContext.DataGridControl );
         }
 
         // We don't add a cell specifically (manually) positioned in the row template.
         if( cell.FieldName == null || !templateCells.ContainsKey( cell.FieldName ) )
+        {
           m_cellsHostPanel.Children.Add( cell );
+        }
 
         // When explicitly put in the PART_CellsHost, we must call Cell.PrepareContainer
         cell.PrepareContainer( dataGridContext, dataItem );
@@ -1937,21 +1983,12 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void GenerateMissingAndRemoveUnusedCells( Dictionary<string, Cell> templateCells )
+    protected virtual void GenerateMissingAndRemoveUnusedCells( DataGridContext dataGridContext, ColumnCollection columns, Dictionary<string, Cell> templateCells )
     {
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
-      Debug.Assert( ( dataGridContext != null ) || ( DesignerProperties.GetIsInDesignMode( this ) ) );
-
-      if( dataGridContext == null )
-        return;
-
-      ColumnCollection columns = dataGridContext.Columns;
       Hashtable cellsDictionary = new Hashtable();
 
-      //Take each and every cells already created and place them in a dictionary
-      //This dictionary is gonna be used to manage cells that need to be removed at the
-      //end of the method's body.
+      //Take each and every cells already created and place them in a dictionary.
+      //This dictionary is gonna be used to manage cells that need to be removed at the end of the method's body.
       foreach( Cell cell in this.CreatedCells )
       {
         cellsDictionary.Add( cell.FieldName, cell );
@@ -1975,7 +2012,7 @@ namespace Xceed.Wpf.DataGrid
         {
           //A cell for this Column has been found in the Template cells, get rid of the corresponding Cell in the Cells collection (if any)
           Cell oldCell;
-          if( m_cellsCache.TryGetCell( column, out oldCell ) )
+          if( m_cellsCache.TryGetCell( column, false, out oldCell ) )
           {
             //If an oldCell was present, clear it and remove it from the Cells collection
             oldCell.ClearContainer();
@@ -2015,8 +2052,7 @@ namespace Xceed.Wpf.DataGrid
           cell.PrepareDefaultStyleKey( view );
         }
 
-        //remove the Column's FieldName from the dictionary of Cells to remove
-        //This is to prevent the removal of the cell in the cleanup code below.
+        //Remove the Column's FieldName from the dictionary of Cells to remove.  This is to prevent the removal of the cell in the cleanup code below.
         cellsDictionary.Remove( fieldName );
       }
 
@@ -2175,8 +2211,7 @@ namespace Xceed.Wpf.DataGrid
       if( this.IsBeingEdited )
         return;
 
-      // If there is no dataItem mapped to this container, we don't want to
-      // enter in edition
+      // If there is no dataItem mapped to this container, we don't want to enter in edition
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
 
       if( dataGridContext != null )
@@ -2193,7 +2228,8 @@ namespace Xceed.Wpf.DataGrid
 
       Debug.Assert( this.IsContainerPrepared, "Can't edit a container that has not been prepared." );
 
-      if( this.ReadOnly )
+      //A cell can be editable will the row of the grid is not.
+      if( this.ReadOnly && !this.IsBeginningEditFromCell )
         throw new DataGridException( "An attempt was made to edit a read-only row." );
 
       if( this.IsBeginningEdition )
@@ -2212,16 +2248,14 @@ namespace Xceed.Wpf.DataGrid
             throw new DataGridException( "BeginEdit was canceled." );
         }
 
-        // We must update the CellStates before calling BeginEditCore to ensure we have the
-        // values that are currently present in the Cells before entering in edition.
-        DataGridControl gridControl = ( dataGridContext != null )
-          ? dataGridContext.DataGridControl
-          : null;
+        // We must update the CellStates before calling BeginEditCore to ensure we have the values that are currently present in the Cells before entering in edition.
+        DataGridControl gridControl = ( dataGridContext != null ) ? dataGridContext.DataGridControl : null;
 
-        // This call will also validate that we're not starting a second row edition.
-        // It will also save the row state and update the columns' CurrentRowInEditionCellState.
+        // This call will also validate that we're not starting a second row edition. It will also save the row state and update the columns' CurrentRowInEditionCellState.
         if( gridControl != null )
+        {
           gridControl.UpdateCurrentRowInEditionCellStates( this, this.DataContext );
+        }
 
         this.SetIsBeingEdited( true );
 
@@ -2235,7 +2269,9 @@ namespace Xceed.Wpf.DataGrid
 
           // Ensure to clear the CellStates
           if( gridControl != null )
+          {
             gridControl.UpdateCurrentRowInEditionCellStates( null, null );
+          }
 
           throw;
         }
@@ -2246,7 +2282,9 @@ namespace Xceed.Wpf.DataGrid
       }
 
       if( !this.IsBeginningEditFromCell )
+      {
         this.OnEditBegun();
+      }
     }
 
     protected virtual void BeginEditCore()
@@ -2271,7 +2309,7 @@ namespace Xceed.Wpf.DataGrid
 
           if( dataGridContext != null )
           {
-            int firstEditableColumn = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( dataGridContext );
+            int firstEditableColumn = NavigationHelper.GetFirstVisibleFocusableColumnIndex( dataGridContext );
             if( firstEditableColumn < 0 )
               throw new DataGridException( "Trying to edit while no cell is focusable. " );
 
@@ -2366,7 +2404,8 @@ namespace Xceed.Wpf.DataGrid
           return;
         }
 
-        IDisposable deferRefresh = ( this is DataRow )
+        IDisposable deferRefresh = ( ( this is DataRow )
+          && ( dataGridContext.ItemsSourceCollection is DataGridCollectionViewBase ) )
           ? DataRow.DeferCollectionViewRefresh( dataGridContext ) : null;
 
         try
@@ -2378,7 +2417,23 @@ namespace Xceed.Wpf.DataGrid
         {
           if( deferRefresh != null )
           {
+            // If there is a validation error, The Dispose of the deferRefresh
+            // may clear (local value) the current error. Be sure to keep it in order
+            // to restore it if needed.
+            object hasValidationError = this.ReadLocalValue( Row.HasValidationErrorProperty );
+            object validationError = this.ReadLocalValue( Row.ValidationErrorProperty );
+
             deferRefresh.Dispose();
+
+            if( hasValidationError != DependencyProperty.UnsetValue )
+            {
+              // This will use the PropertyKey.
+              this.SetHasValidationError( ( bool )hasValidationError );
+            }
+            if( validationError != DependencyProperty.UnsetValue )
+            {
+              this.SetValidationError( ( RowValidationError )validationError );
+            }
           }
         }
 
@@ -2417,7 +2472,9 @@ namespace Xceed.Wpf.DataGrid
 
       // Reset current row in edition.
       if( gridControl != null )
+      {
         gridControl.UpdateCurrentRowInEditionCellStates( null, null );
+      }
 
       this.SetIsBeingEdited( false );
 
@@ -2426,7 +2483,9 @@ namespace Xceed.Wpf.DataGrid
       if( ( this.NavigationBehavior == NavigationBehavior.RowOnly ) && ( this.IsCurrent ) )
       {
         if( gridControl != null )
+        {
           gridControl.QueueClearCurrentColumn( gridControl.CurrentItem );
+        }
       }
     }
 
@@ -2457,7 +2516,7 @@ namespace Xceed.Wpf.DataGrid
         try
         {
           editCell.EndEdit( true, true, true );
-          hasRestrictiveError |= Cell.GetIsValidationErrorRestrictive( editCell.ValidationError );
+          hasRestrictiveError = hasRestrictiveError || Cell.GetIsValidationErrorRestrictive( editCell.ValidationError );
         }
         catch( DataGridValidationException )
         {
@@ -2556,7 +2615,8 @@ namespace Xceed.Wpf.DataGrid
 
         if( dataGridContext != null )
         {
-          deferRefresh = ( this is DataRow )
+          deferRefresh = ( ( this is DataRow )
+            && ( dataGridContext.ItemsSourceCollection is DataGridCollectionViewBase ) )
             ? DataRow.DeferCollectionViewRefresh( dataGridContext ) : null;
         }
 
@@ -2600,7 +2660,9 @@ namespace Xceed.Wpf.DataGrid
         : null;
 
       if( gridControl != null )
+      {
         gridControl.UpdateCurrentRowInEditionCellStates( null, null );
+      }
 
       this.SetIsBeingEdited( false );
 
@@ -2608,7 +2670,9 @@ namespace Xceed.Wpf.DataGrid
          && ( this.IsCurrent ) )
       {
         if( gridControl != null )
+        {
           gridControl.QueueClearCurrentColumn( gridControl.CurrentItem );
+        }
       }
     }
 
@@ -2788,41 +2852,13 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion COMMANDS
 
-    #region IPrintInfo Members
-
-    double IPrintInfo.GetPageRightOffset( double horizontalOffset, double viewportWidth )
-    {
-      IPrintInfo subPrintInfo = this.CellsHostPanel as IPrintInfo;
-
-      if( subPrintInfo != null )
-        return subPrintInfo.GetPageRightOffset( horizontalOffset, viewportWidth );
-
-      return horizontalOffset + viewportWidth;
-    }
-
-    void IPrintInfo.UpdateElementVisibility( double horizontalOffset, double viewportWidth, object state )
-    {
-      IPrintInfo subPrintInfo = this.CellsHostPanel as IPrintInfo;
-
-      if( subPrintInfo != null )
-        subPrintInfo.UpdateElementVisibility( horizontalOffset, viewportWidth, state );
-    }
-
-    object IPrintInfo.CreateElementVisibilityState()
-    {
-      IPrintInfo subPrintInfo = this.CellsHostPanel as IPrintInfo;
-      if( subPrintInfo == null )
-        return null;
-
-      return subPrintInfo.CreateElementVisibilityState();
-    }
-
-    #endregion
-
     #region IDataGridItemContainer Members
 
     void IDataGridItemContainer.PrepareContainer( DataGridContext dataGridContext, object item )
     {
+      if( this.IsContainerPrepared )
+        Debug.Fail( "A Row can't be prepared twice, it must be cleaned before PrepareContainer is called again" );
+
       this.PrepareContainer( dataGridContext, item );
     }
 
@@ -2833,12 +2869,17 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
+    #region Private Fields
+
     private DataGridControl m_parentGridUsedForCellsGeneration; // = null
-    private Panel m_oldCellsHostPanel; // = null
     private Panel m_cellsHostPanel; // = null
     private Dictionary<string, Cell> m_templateCells = new Dictionary<string, Cell>();
     private BitVector32 m_flags = new BitVector32();
 
+    #endregion
+
+    #region RowFlags Nested Type
+
     [Flags]
     private enum RowFlags
     {
@@ -2849,7 +2890,9 @@ namespace Xceed.Wpf.DataGrid
       IsBeingEditedCache = 16,
       IsClearingContainer = 32,
       IsContainerPrepared = 64,
-      IsInitializingInsertionRow = 128
+      IsInitializingInsertionRow = 128,
     }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelector.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelector.cs
index dbed446f..774ceee3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelector.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelector.cs
@@ -14,14 +14,13 @@
 
   ***********************************************************************************/
 
-using System.Windows.Controls;
-using System.Windows;
-using System.Windows.Input;
-using System.Windows.Controls.Primitives;
 using System;
 using System.ComponentModel;
-using System.Collections.ObjectModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
 using System.Windows.Data;
+using System.Windows.Input;
 using Xceed.Wpf.DataGrid.Views;
 
 namespace Xceed.Wpf.DataGrid
@@ -40,6 +39,11 @@ namespace Xceed.Wpf.DataGrid
       DataGridControl.ParentDataGridControlPropertyKey.OverrideMetadata( typeof( RowSelector ),
         new FrameworkPropertyMetadata( new PropertyChangedCallback( RowSelector.OnParentGridControlChanged ) ) );
 
+      m_sDataContextBinding = new Binding();
+      m_sDataContextBinding.RelativeSource = new RelativeSource( RelativeSourceMode.Self );
+      m_sDataContextBinding.Path = new PropertyPath( DataGridControl.ContainerProperty );
+      m_sDataContextBinding.Mode = BindingMode.OneWay;
+
       m_sItemIndexBinding = new Binding();
       m_sItemIndexBinding.Path = new PropertyPath( DataGridVirtualizingPanel.ItemIndexProperty );
       m_sItemIndexBinding.Mode = BindingMode.OneWay;
@@ -77,8 +81,7 @@ namespace Xceed.Wpf.DataGrid
 
     internal RowSelector()
     {
-      this.DataContext = null;
-
+      BindingOperations.SetBinding( this, RowSelector.DataContextProperty, m_sDataContextBinding );
       BindingOperations.SetBinding( this, RowSelector.IsCurrentProperty, m_sIsCurrentBinding );
       BindingOperations.SetBinding( this, RowSelector.IsBeingEditedProperty, m_sIsBeingEditedBinding );
       BindingOperations.SetBinding( this, RowSelector.ItemIndexProperty, m_sItemIndexBinding );
@@ -647,7 +650,7 @@ namespace Xceed.Wpf.DataGrid
               {
                 try
                 {
-                  dataGridContext.SetCurrentColumnCore( null, false, false );
+                  dataGridContext.SetCurrentColumnCore( null, false, false, AutoScrollCurrentItemSourceTriggers.Navigation );
                 }
                 catch( DataGridException )
                 {
@@ -728,6 +731,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion Button Behavior Code
 
+    private static readonly Binding m_sDataContextBinding;
     private static readonly Binding m_sItemIndexBinding;
     private static readonly Binding m_sIsCurrentBinding;
     private static readonly Binding m_sIsBeingEditedBinding;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelectorPane.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelectorPane.cs
index 0954ec0a..2274ea15 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelectorPane.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/RowSelectorPane.cs
@@ -15,225 +15,195 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections;
-using System.Collections.Specialized;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Controls.Primitives;
-using System.Windows.Data;
+using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Threading;
-using Xceed.Wpf.DataGrid.Views;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.ComponentModel;
-using System.Windows.Input;
 
 namespace Xceed.Wpf.DataGrid
 {
   public class RowSelectorPane : Panel
   {
-    private const double SafeOffScreenCoordinate = -1000000.0d;
-
-    private static readonly Rect RecycleReadyRect = new Rect( RowSelectorPane.SafeOffScreenCoordinate, RowSelectorPane.SafeOffScreenCoordinate, 0, 0 );
-    private static readonly Point OriginPoint = new Point( 0, 0 );
-
     static RowSelectorPane()
     {
       ClipToBoundsProperty.OverrideMetadata( typeof( RowSelectorPane ), new FrameworkPropertyMetadata( true ) );
-
       FocusableProperty.OverrideMetadata( typeof( RowSelectorPane ), new FrameworkPropertyMetadata( false ) );
 
       DataGridControl.ParentDataGridControlPropertyKey.OverrideMetadata( typeof( RowSelectorPane ), new FrameworkPropertyMetadata( new PropertyChangedCallback( RowSelectorPane.OnParentGridControlChanged ) ) );
     }
 
-    //------------------------------
-    // PROPERTIES
-    //------------------------------
+    #region Orientation Dependency Property
 
-    #region Orientation Property
+    // Using a DependencyProperty as the backing store for Orientation.  This enables animation, styling, binding, etc...
+    public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(
+      "Orientation",
+      typeof( Orientation ),
+      typeof( RowSelectorPane ),
+      new UIPropertyMetadata( Orientation.Vertical ) );
 
     public Orientation Orientation
     {
       get
       {
-        return ( Orientation )GetValue( OrientationProperty );
+        return ( Orientation )this.GetValue( RowSelectorPane.OrientationProperty );
       }
       set
       {
-        SetValue( OrientationProperty, value );
+        this.SetValue( RowSelectorPane.OrientationProperty, value );
       }
     }
 
-    // Using a DependencyProperty as the backing store for Orientation.  This enables animation, styling, binding, etc...
-    public static readonly DependencyProperty OrientationProperty =
-        DependencyProperty.Register( "Orientation", typeof( Orientation ), typeof( RowSelectorPane ), new UIPropertyMetadata( Orientation.Vertical, new PropertyChangedCallback( OnOrientationChanged ) ) );
-
+    #endregion
 
-    private static void OnOrientationChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-
-    }
-
-    #endregion Orientation Property
-
-    internal void SetRowSelectorPosition( DependencyObject container, Rect containerRect, FrameworkElement referenceElement )
+    protected override Size MeasureOverride( Size availableSize )
     {
-      Debug.Assert( ( Visibility )this.GetValue( RowSelectorPane.VisibilityProperty ) == Visibility.Visible, "We should not be creating RowSelectors if we are not Visible." );
-
-      RowSelector rowSelector = null;
-
-      //Check if a RowSelector is already assigned to the container passed.
-      if( m_visibleSelectors.TryGetValue( container, out rowSelector ) == false )
+      foreach( UIElement child in this.InternalChildren )
       {
-        //If no RowSelector exists for this container, try to recycle one.
-        if( m_recycleQueue.Count > 0 )
+        var decorator = child as RowSelectorDecorator;
+        if( decorator != null )
         {
-          //get next recyclable RowSelector.
-          rowSelector = m_recycleQueue.Dequeue();
+          if( this.IsRowSelectorVisible( decorator ) )
+          {
+            decorator.Visibility = Visibility.Visible;
+            decorator.Measure( this.GetAvailableSize( decorator, availableSize ) );
+          }
+          else
+          {
+            decorator.Visibility = Visibility.Collapsed;
+
+            if( !decorator.IsMeasureValid )
+            {
+              decorator.Measure( RowSelectorPane.EmptySize );
+            }
+          }
         }
         else
         {
-          //Recycling pool empty, create a new RowSelector and place it in the visual tree right away.
-          rowSelector = new RowSelector();
-          this.InternalChildren.Add( rowSelector );
+          child.Measure( RowSelectorPane.EmptySize );
         }
-
-        //Since there was no RowSelector for the container, map the container to this RowSelector
-        rowSelector.DataContext = container;
-        DataGridControl.SetContainer( rowSelector, container );
-        rowSelector.ReferenceElement = referenceElement;
-        m_visibleSelectors.Add( container, rowSelector );
       }
 
-      //At this stage, it is not normal that no RowSelector instance is available.
-      Debug.Assert( rowSelector != null );
-
-      if( rowSelector == null )
-        throw new InvalidOperationException( "An attempt was made to set the position of a row selector that does not exist." );
-
-      rowSelector.ContainerRect = containerRect;
-
-      this.InvalidateMeasure();
+      return RowSelectorPane.EmptySize;
     }
 
-    internal void FreeRowSelector( DependencyObject container )
+    protected override Size ArrangeOverride( Size finalSize )
     {
-      RowSelector rowSelector = null;
-
-      //Check if a RowSelector is already assigned to the container passed.
-      if( m_visibleSelectors.TryGetValue( container, out rowSelector ) == true )
+      foreach( UIElement child in this.InternalChildren )
       {
-        //Remove from Visible list, add to pending cleanup list
-        m_visibleSelectors.Remove( container );
-        m_pendingCleanup.Add( rowSelector );
-
-        //clear data context (container) from the RowSelector.
-        rowSelector.DataContext = null;
-        DataGridControl.ClearContainer( rowSelector );
-
-        //Invalidate Measure since the list of VisibleSelector + PendingCleanup changed
-        this.InvalidateMeasure();
+        var decorator = child as RowSelectorDecorator;
+        if( decorator != null )
+        {
+          if( this.IsRowSelectorVisible( decorator ) )
+          {
+            var arrangeRect = this.GetArrangeRect( decorator, finalSize );
+            var rowSelector = decorator.RowSelector;
+            var referenceElement = ( rowSelector != null ) ? rowSelector.ReferenceElement : null;
+
+            decorator.Clip = this.GetClipRegion( decorator, arrangeRect, referenceElement );
+            decorator.Arrange( arrangeRect );
+          }
+          else if( !decorator.IsArrangeValid )
+          {
+            decorator.Arrange( RowSelectorPane.OutOfViewRect );
+          }
+        }
+        else
+        {
+          child.Arrange( RowSelectorPane.OutOfViewRect );
+        }
       }
-      //If there are no RowSelector for container, then do nothing.
-    }
 
-    protected override Size MeasureOverride( Size availableSize )
-    {
-      Size desiredSize = new Size( 0, 0 );
-
-      foreach( RowSelector rowSelector in m_visibleSelectors.Values )
+      if( this.IsMouseOver )
       {
-        Size rowSelectorAvaillableSize = this.PrepareAvailableSizeForRowSelector( rowSelector, availableSize );
-
-        rowSelector.Measure( rowSelectorAvaillableSize );
+        Mouse.Synchronize();
       }
 
-      return desiredSize;
+      return finalSize;
     }
 
-    protected override Size ArrangeOverride( Size finalSize )
+    internal virtual void PrepareDefaultStyleKey( Xceed.Wpf.DataGrid.Views.ViewBase view )
     {
-      foreach( RowSelector toClean in m_pendingCleanup )
-      {
-        toClean.Arrange( RecycleReadyRect );
-        m_recycleQueue.Enqueue( toClean );
-      }
+      this.DefaultStyleKey = view.GetDefaultStyleKey( typeof( RowSelectorPane ) );
+    }
 
-      m_pendingCleanup.Clear();
+    internal void SetRowSelectorPosition( DependencyObject container, Rect containerRect, FrameworkElement referenceElement )
+    {
+      Debug.Assert( ( Visibility )this.GetValue( RowSelectorPane.VisibilityProperty ) == Visibility.Visible, "We should not be creating RowSelectors if we are not Visible." );
 
-      foreach( RowSelector visibleRowSelector in m_visibleSelectors.Values )
-      {
-        Rect rowSelectorArrangeRect = this.PrepareArrangeRectForRowSelector( finalSize, visibleRowSelector );
+      // Try to re-use the RowSelector already assigned to the container.
+      if( this.TryReUseVisibleRowSelector( container, containerRect ) )
+        return;
 
-        visibleRowSelector.Clip = this.PrepareClipForRowSelector( visibleRowSelector, rowSelectorArrangeRect, visibleRowSelector.ReferenceElement );
+      var decorator = this.RecycleOrCreateRowSelector( container );
+      Debug.Assert( decorator != null, "An attempt was made to set the position of a row selector that does not exist." );
 
-        visibleRowSelector.Arrange( rowSelectorArrangeRect );
-      }
+      RowSelectorPane.PrepareRowSelector( decorator, container, containerRect, referenceElement );
 
-      //Case 117296: update the mouse status to make sure no container has invalid mouse over status. Only do this when the mouse is over the panel, to 
-      //prevent unescessary update when scrolling with thumb
-      if( this.IsMouseOver == true )
-      {
-        Mouse.Synchronize();
-      }
+      m_visibleSelectors.Add( container, decorator );
 
-      return finalSize;
+      this.InvalidateMeasure();
     }
 
-    internal virtual void PrepareDefaultStyleKey( Xceed.Wpf.DataGrid.Views.ViewBase view )
+    internal void FreeRowSelector( DependencyObject container )
     {
-      this.DefaultStyleKey = view.GetDefaultStyleKey( typeof( RowSelectorPane ) );
+      RowSelectorDecorator decorator;
+      if( !m_visibleSelectors.TryGetValue( container, out decorator ) )
+        return;
+
+      m_visibleSelectors.Remove( container );
+      m_pendingCleanup.Add( decorator );
+
+      this.ScheduleUnusedRowSelectorsCleanUp();
+      this.InvalidateMeasure();
     }
 
-    private Rect PrepareArrangeRectForRowSelector( Size finalSize, RowSelector visibleRowSelector )
+    private Rect GetArrangeRect( RowSelectorDecorator decorator, Size finalSize )
     {
-      Rect returnRect;
+      var rowSelector = decorator.RowSelector;
+      if( rowSelector == null )
+        return RowSelectorPane.EmptyRect;
 
-      FrameworkElement container = visibleRowSelector.DataContext as FrameworkElement;
+      var container = rowSelector.DataContext as FrameworkElement;
       Debug.Assert( container != null );
 
-      GeneralTransform coordinatesTransform = container.TransformToVisual( this );
-      Point origin = coordinatesTransform.Transform( OriginPoint );
+      var coordinatesTransform = container.TransformToVisual( this );
+      var origin = coordinatesTransform.Transform( RowSelectorPane.OriginPoint );
 
       if( this.Orientation == Orientation.Vertical )
-      {
-        returnRect = new Rect( 0, origin.Y, finalSize.Width, container.ActualHeight );
-      }
-      else
-      {
-        returnRect = new Rect( origin.X, 0, container.ActualWidth, finalSize.Height );
-      }
+        return new Rect( 0, origin.Y, finalSize.Width, container.ActualHeight );
 
-      return returnRect;
+      return new Rect( origin.X, 0, container.ActualWidth, finalSize.Height );
     }
 
-    private Size PrepareAvailableSizeForRowSelector( RowSelector rowSelector, Size availableSize )
+    private Size GetAvailableSize( RowSelectorDecorator decorator, Size availableSize )
     {
-      Rect containerRect = rowSelector.ContainerRect;
-      Size returnSize;
+      var rowSelector = decorator.RowSelector;
+      if( rowSelector == null )
+        return RowSelectorPane.EmptySize;
+
+      var containerRect = rowSelector.ContainerRect;
 
       if( this.Orientation == Orientation.Vertical )
-      {
-        returnSize = new Size( availableSize.Width, containerRect.Height );
-      }
-      else
-      {
-        returnSize = new Size( containerRect.Width, availableSize.Height );
-      }
+        return new Size( availableSize.Width, containerRect.Height );
 
-      return returnSize;
+      return new Size( containerRect.Width, availableSize.Height );
     }
 
-    private Geometry PrepareClipForRowSelector( RowSelector rowSelector, Rect arrangeRect, FrameworkElement referenceElement )
+    private Geometry GetClipRegion( RowSelectorDecorator decorator, Rect arrangeRect, FrameworkElement referenceElement )
     {
       if( referenceElement == null )
         return null;
 
-      GeneralTransform referenceElementToRowSelectorPaneTransform = referenceElement.TransformToVisual( this );
+      var rowSelector = decorator.RowSelector;
+      if( rowSelector == null )
+        return null;
 
+      GeneralTransform referenceElementToRowSelectorPaneTransform = referenceElement.TransformToVisual( this );
       Rect referenceElementRegion = referenceElementToRowSelectorPaneTransform.TransformBounds( new Rect( 0, 0, referenceElement.ActualWidth, referenceElement.ActualHeight ) );
-
       RectangleGeometry clipRegion = null;
 
       if( this.Orientation == Orientation.Vertical )
@@ -255,7 +225,6 @@ namespace Xceed.Wpf.DataGrid
           double width = arrangeRect.Width;
           double height = Math.Max( 0, arrangeRect.Height - y - Math.Max( 0, arrangeRect.Bottom - referenceElementRegion.Bottom ) );
 
-
           clipRegion = new RectangleGeometry( new Rect( x, y, width, height ) );
         }
       }
@@ -285,9 +254,139 @@ namespace Xceed.Wpf.DataGrid
       return clipRegion;
     }
 
-    //------------------------------
-    // DP CHANGED HANDLERS
-    //------------------------------
+    private bool IsRowSelectorVisible( RowSelectorDecorator decorator )
+    {
+      Debug.Assert( decorator != null );
+      if( decorator.RowSelector == null )
+        return false;
+
+      var container = DataGridControl.GetContainer( decorator );
+      if( container == null )
+        return false;
+
+      return m_visibleSelectors.ContainsKey( container );
+    }
+
+    private bool TryReUseVisibleRowSelector( DependencyObject container, Rect containerRect )
+    {
+      RowSelectorDecorator decorator;
+      if( !m_visibleSelectors.TryGetValue( container, out decorator ) )
+        return false;
+
+      var rowSelector = decorator.RowSelector;
+      if( rowSelector == null )
+      {
+        this.FreeRowSelector( container );
+        return false;
+      }
+
+      // Check if the cached position and size of the target container is up to date.
+      if( !Rect.Equals( rowSelector.ContainerRect, containerRect ) )
+      {
+        rowSelector.ContainerRect = containerRect;
+
+        this.InvalidateMeasure();
+      }
+
+      return true;
+    }
+
+    private RowSelectorDecorator RecycleOrCreateRowSelector( DependencyObject container )
+    {
+      RowSelectorDecorator decorator;
+
+      // Try to re-use a RowSelector that is schedule to be clean up.
+      if( m_pendingCleanup.Count > 0 )
+      {
+        int index = m_pendingCleanup.Count - 1;
+
+        for( int i = index; i >= 0; i-- )
+        {
+          decorator = m_pendingCleanup[ i ];
+          if( DataGridControl.GetContainer( decorator ) == container )
+          {
+            index = i;
+            break;
+          }
+        }
+
+        decorator = m_pendingCleanup[ index ];
+        m_pendingCleanup.RemoveAt( index );
+      }
+      // Try to recycle a RowSelector from the recycling pool.
+      else if( m_recyclingQueue.Count > 0 )
+      {
+        decorator = m_recyclingQueue.Dequeue();
+      }
+      else
+      {
+        decorator = new RowSelectorDecorator();
+
+        this.InternalChildren.Add( decorator );
+      }
+
+      return decorator;
+    }
+
+    private void ScheduleUnusedRowSelectorsCleanUp()
+    {
+      if( m_pendingCleanupOperation != null )
+        return;
+
+      m_pendingCleanupOperation = this.Dispatcher.BeginInvoke( DispatcherPriority.ApplicationIdle, new Action( this.CleanUpUnusedRowSelectors ) );
+    }
+
+    private void CleanUpUnusedRowSelectors()
+    {
+      m_pendingCleanupOperation = null;
+
+      for( int i = m_pendingCleanup.Count - 1; i >= 0; i-- )
+      {
+        var decorator = m_pendingCleanup[ i ];
+
+        RowSelectorPane.ClearRowSelector( decorator );
+
+        if( decorator.RowSelector != null )
+        {
+          m_recyclingQueue.Enqueue( decorator );
+        }
+        else
+        {
+          // The RowSelector has become useless, so we destroy it.
+          this.InternalChildren.Remove( decorator );
+        }
+      }
+
+      m_pendingCleanup.Clear();
+    }
+
+    private static void PrepareRowSelector( RowSelectorDecorator decorator, DependencyObject container, Rect containerRect, FrameworkElement referenceElement )
+    {
+      Debug.Assert( decorator != null );
+
+      DataGridControl.SetContainer( decorator, container );
+
+      var rowSelector = decorator.RowSelector;
+      if( rowSelector != null )
+      {
+        rowSelector.ReferenceElement = referenceElement;
+        rowSelector.ContainerRect = containerRect;
+      }
+    }
+
+    private static void ClearRowSelector( RowSelectorDecorator decorator )
+    {
+      Debug.Assert( decorator != null );
+
+      DataGridControl.ClearContainer( decorator );
+
+      var rowSelector = decorator.RowSelector;
+      if( rowSelector != null )
+      {
+        rowSelector.ReferenceElement = null;
+        rowSelector.ContainerRect = RowSelectorPane.EmptyRect;
+      }
+    }
 
     private static void OnParentGridControlChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
@@ -299,7 +398,7 @@ namespace Xceed.Wpf.DataGrid
       {
         // The RowSelectorPane must clear its internal state when the ParentGridControl changes
         rowSelectorPane.m_pendingCleanup.Clear();
-        rowSelectorPane.m_recycleQueue.Clear();
+        rowSelectorPane.m_recyclingQueue.Clear();
         rowSelectorPane.m_visibleSelectors.Clear();
         rowSelectorPane.InternalChildren.Clear();
       }
@@ -368,10 +467,44 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion Obsolete Members
 
+    #region CONSTANTS
+
+    private static readonly Point OriginPoint = new Point( 0d, 0d );
+    private static readonly Size EmptySize = new Size( 0d, 0d );
+    private static readonly Rect EmptyRect = new Rect( RowSelectorPane.OriginPoint, RowSelectorPane.EmptySize );
+    private static readonly Rect OutOfViewRect = new Rect( new Point( -999999d, -999999d ), RowSelectorPane.EmptySize );
+
+    #endregion
+
+    #region PRIVATE FIELDS
+
+    private readonly Queue<RowSelectorDecorator> m_recyclingQueue = new Queue<RowSelectorDecorator>();
+    private readonly List<RowSelectorDecorator> m_pendingCleanup = new List<RowSelectorDecorator>();
+    private readonly Dictionary<DependencyObject, RowSelectorDecorator> m_visibleSelectors = new Dictionary<DependencyObject, RowSelectorDecorator>();
+    private DispatcherOperation m_pendingCleanupOperation; //null
+
+    #endregion
 
-    private Queue<RowSelector> m_recycleQueue = new Queue<RowSelector>();
-    private List<RowSelector> m_pendingCleanup = new List<RowSelector>();
-    Dictionary<DependencyObject, RowSelector> m_visibleSelectors = new Dictionary<DependencyObject, RowSelector>();
+    #region RowSelectorDecorator Private Class
+
+    private sealed class RowSelectorDecorator : Decorator
+    {
+      internal RowSelectorDecorator()
+      {
+        this.Focusable = false;
+        this.OverridesDefaultStyle = true;
+        this.Child = new RowSelector();
+      }
+
+      internal RowSelector RowSelector
+      {
+        get
+        {
+          return this.Child as RowSelector;
+        }
+      }
+    }
 
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ScrollTip.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ScrollTip.cs
index 63ab2e71..60f021b3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ScrollTip.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ScrollTip.cs
@@ -311,10 +311,6 @@ namespace Xceed.Wpf.DataGrid
           }
 
           scrollTip.m_mainColumn = null;
-          scrollTip.m_horizontalScrollBar = null;
-          scrollTip.m_horizontalScrollThumb = null;
-          scrollTip.m_verticalScrollBar = null;
-          scrollTip.m_verticalScrollThumb = null;
 
           scrollTip.UnregisterListeners( oldParentGridControl );
         }
@@ -341,64 +337,25 @@ namespace Xceed.Wpf.DataGrid
     private void RegisterListeners( DataGridControl parentGridControl )
     {
       if( parentGridControl.ScrollViewer != null )
-        parentGridControl.ScrollViewer.ScrollChanged += new ScrollChangedEventHandler( this.OnScrollViewerScrollChanged );
-
-      m_verticalScrollBar = parentGridControl.ScrollViewer.Template.FindName( "PART_VerticalScrollBar", parentGridControl.ScrollViewer ) as ScrollBar;
-      m_horizontalScrollBar = parentGridControl.ScrollViewer.Template.FindName( "PART_HorizontalScrollBar", parentGridControl.ScrollViewer ) as ScrollBar;
-
-      if( m_verticalScrollBar != null )
       {
-        if( parentGridControl.ScrollViewer != null )
-        {
-          // Assert the Template as been applied on the ScrollBar to get access to the ScrollThumb
-          if( m_verticalScrollBar.Track == null )
-            m_verticalScrollBar.ApplyTemplate();
-
-          Debug.Assert( m_verticalScrollBar.Track != null );
-
-          if( m_verticalScrollBar.Track != null )
-            m_verticalScrollThumb = m_verticalScrollBar.Track.Thumb;
-
-          if( m_verticalScrollThumb != null )
-          {
-            // Register to IsMouseCaptureChanged to know when this ScrollThumb is clicked to display the ScrollTip if required
-            m_verticalScrollThumb.IsMouseCapturedChanged += new DependencyPropertyChangedEventHandler( this.ScrollThumb_IsMouseCapturedChanged );
-          }
-        }
-      }
-
-      if( m_horizontalScrollBar != null )
-      {
-        if( parentGridControl.ScrollViewer != null )
-        {
-          // Assert the Template as been applied on the ScrollBar to get access to the ScrollThumb
-          if( m_horizontalScrollBar.Track == null )
-            m_horizontalScrollBar.ApplyTemplate();
-
-          Debug.Assert( m_horizontalScrollBar.Track != null );
-
-          if( m_horizontalScrollBar.Track != null )
-            m_horizontalScrollThumb = m_horizontalScrollBar.Track.Thumb;
-
-          if( m_horizontalScrollThumb != null )
-          {
-            // Register to IsMouseCaptureChanged to know when this ScrollThumb is clicked to display the ScrollTip if required
-            m_horizontalScrollThumb.IsMouseCapturedChanged += new DependencyPropertyChangedEventHandler( this.ScrollThumb_IsMouseCapturedChanged );
-          }
-        }
+        parentGridControl.ScrollViewer.ScrollChanged += new ScrollChangedEventHandler( this.OnScrollViewerScrollChanged );
+        m_scrollViewerTemplateHelper = new ScrollViewerTemplateHelper( parentGridControl.ScrollViewer, this.DragScrollBegin, this.DragScrollEnd );
+        m_scrollViewerTemplateHelper.RefreshTemplate();
       }
     }
 
     private void UnregisterListeners( DataGridControl parentGridControl )
     {
-      if( ( parentGridControl != null ) && ( parentGridControl.ScrollViewer != null ) )
+      if( parentGridControl.ScrollViewer != null )
+      {
         parentGridControl.ScrollViewer.ScrollChanged -= new ScrollChangedEventHandler( this.OnScrollViewerScrollChanged );
+      }
 
-      if( m_verticalScrollThumb != null )
-        m_verticalScrollThumb.IsMouseCapturedChanged -= new DependencyPropertyChangedEventHandler( this.ScrollThumb_IsMouseCapturedChanged );
-
-      if( m_horizontalScrollThumb != null )
-        m_horizontalScrollThumb.IsMouseCapturedChanged -= new DependencyPropertyChangedEventHandler( this.ScrollThumb_IsMouseCapturedChanged );
+      if( m_scrollViewerTemplateHelper != null )
+      {
+        m_scrollViewerTemplateHelper.Dispose();
+        m_scrollViewerTemplateHelper = null;
+      }
     }
 
     private void RefreshDefaultScrollTipContentTemplate()
@@ -492,39 +449,11 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void ScrollThumb_IsMouseCapturedChanged( object sender, DependencyPropertyChangedEventArgs e )
+    private void DragScrollBegin( Orientation orientation )
     {
-      Thumb scrollThumb = sender as Thumb;
-
-      if( scrollThumb == null )
-        return;
-
-      if( !scrollThumb.IsMouseCaptured )
-        return;
-
       if( !this.ShouldDisplayScrollTip )
         return;
 
-      ScrollBar scrollBar = scrollThumb.TemplatedParent as ScrollBar;
-
-      if( scrollBar == null )
-        return;
-
-      // Register to LostMouseCapture to be sure to hide the ScrollTip when the ScrollThumb lost the focus
-      if( scrollThumb == m_horizontalScrollThumb )
-      {
-        m_horizontalScrollThumb.LostMouseCapture += new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
-      }
-      else if( scrollThumb == m_verticalScrollThumb )
-      {
-        m_verticalScrollThumb.LostMouseCapture += new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
-      }
-      else
-      {
-        Debug.Fail( "Unknown thumb used for scrolling." );
-        return;
-      }
-
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
 
       if( dataGridContext == null )
@@ -536,34 +465,19 @@ namespace Xceed.Wpf.DataGrid
       // Update items scrolling orientation and pixel scrolling
       m_itemsScrollingOrientation = ScrollViewerHelper.GetItemScrollingOrientation( dataGridContext.DataGridControl );
 
-      if( m_itemsScrollingOrientation == Orientation.Vertical )
-      {
-        if( scrollBar != m_verticalScrollBar )
-          return;
-      }
-      else
-      {
-        if( scrollBar != m_horizontalScrollBar )
-          return;
-      }
+      if( m_itemsScrollingOrientation != orientation )
+        return;
 
       this.Visibility = Visibility.Visible;
 
       this.IsPixelScrolling = ScrollViewerHelper.IsPixelScrolling( dataGridContext.DataGridControl, dataGridContext.DataGridControl.ItemsHost, dataGridContext.DataGridControl.ScrollViewer );
 
-      this.RefreshScrollTipContent( scrollBar );
+      this.RefreshScrollTipContent( m_scrollViewerTemplateHelper.GetScrollBar( orientation ) );
     }
 
-    private void ScrollThumb_LostMouseCapture( object sender, MouseEventArgs e )
+    private void DragScrollEnd( Orientation orientation )
     {
       this.Visibility = Visibility.Collapsed;
-
-      Thumb scrollBarThumb = sender as Thumb;
-
-      Debug.Assert( scrollBarThumb != null );
-
-      if( scrollBarThumb != null )
-        scrollBarThumb.LostMouseCapture -= new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
     }
 
     private void OnScrollViewerScrollChanged( object sender, ScrollChangedEventArgs e )
@@ -579,11 +493,11 @@ namespace Xceed.Wpf.DataGrid
 
       if( e.VerticalChange == 0 )
       {
-        scrollBar = m_horizontalScrollBar;
+        scrollBar = m_scrollViewerTemplateHelper.HorizontalScrollBar;
       }
       else
       {
-        scrollBar = m_verticalScrollBar;
+        scrollBar = m_scrollViewerTemplateHelper.VerticalScrollBar;
       }
 
       if( scrollBar == null )
@@ -775,10 +689,7 @@ namespace Xceed.Wpf.DataGrid
 
     private ColumnBase m_mainColumn; // = null;
     private Orientation m_itemsScrollingOrientation = Orientation.Vertical;
-    private ScrollBar m_horizontalScrollBar; // = null;
-    private Thumb m_horizontalScrollThumb; // = null;
-    private ScrollBar m_verticalScrollBar; // = null;
-    private Thumb m_verticalScrollThumb; // = null;
+    private ScrollViewerTemplateHelper m_scrollViewerTemplateHelper;
 
     private BitVector32 m_flags = new BitVector32();
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedCellsStorage.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedCellsStorage.cs
index 0b1edd46..be8fd9de 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedCellsStorage.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedCellsStorage.cs
@@ -15,52 +15,38 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Collections;
+using System.Collections.Generic;
 using System.Diagnostics;
-using System.Windows.Data;
+using System.Linq;
 
 namespace Xceed.Wpf.DataGrid
 {
-  internal class SelectedCellsStorage : IEnumerable
+  internal class SelectedCellsStorage : ICloneable, IEnumerable<SelectionCellRangeWithItems>, IEnumerable
   {
-    #region CONSTRUCTORS
+    #region Constructors
 
-    internal SelectedCellsStorage( DataGridContext dataGridContext, int capacity )
+    internal SelectedCellsStorage( DataGridContext dataGridContext )
     {
       // dataGridContext can be null for store that we don't want to auto-get Items from index
       m_dataGridContext = dataGridContext;
-      m_list = new List<SelectionCellRangeWithItems>( capacity );
     }
 
-    internal SelectedCellsStorage( SelectedCellsStorage collection )
-    {
-      m_dataGridContext = collection.m_dataGridContext;
-      m_list = new List<SelectionCellRangeWithItems>( collection.m_list );
-      m_cellsCount = collection.m_cellsCount;
-    }
-
-    #endregion CONSTRUCTORS
+    #endregion
 
-    #region PUBLIC PROPERTIES
+    #region Count Property
 
     public int Count
     {
       get
       {
-        return m_list.Count;
+        return m_unsortedRanges.Count;
       }
     }
 
-    public int CellsCount
-    {
-      get
-      {
-        return m_cellsCount;
-      }
-    }
+    #endregion
+
+    #region DataGridContext Property
 
     public DataGridContext DataGridContext
     {
@@ -70,339 +56,238 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private readonly DataGridContext m_dataGridContext;
+
+    #endregion
+
+    #region [] Property
+
     public SelectionCellRangeWithItems this[ int index ]
     {
       get
       {
-        return m_list[ index ];
+        return m_unsortedRanges[ index ].Value;
       }
-      set
+      private set
       {
-        SelectionCellRangeWithItems oldRange = m_list[ index ];
-        m_list[ index ] = value;
-        m_cellsCount += value.Length - oldRange.Length;
+        this.RemoveAt( index, false );
+        this.Insert( index, value, false );
       }
     }
 
-    #endregion PUBLIC PROPERTIES
+    #endregion
 
-    #region IEnumerable
-
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-      return m_list.GetEnumerator();
-    }
-
-    #endregion IEnumerable
-
-    #region PUBLIC METHODS
-
-    public int Add( SelectionCellRangeWithItems cellRangeWithItems )
+    public void Add( SelectionCellRangeWithItems rangeWithItems )
     {
+      Debug.Assert( m_unsortedRanges.All( r => r.Value.CellRange.Intersect( rangeWithItems.CellRange ).IsEmpty ), "Part of this range is already selected" );
 
+      var itemRangeWithItems = rangeWithItems.ItemRangeWithItems;
 
-      m_cellsCount += cellRangeWithItems.Length;
-      SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems;
+      SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd( m_dataGridContext, itemRangeWithItems, ref itemRangeWithItems );
 
-      SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
-        m_dataGridContext, itemRangeWithItems, ref itemRangeWithItems );
+      var newRangeWithItems = new SelectionCellRangeWithItems( itemRangeWithItems.Range, itemRangeWithItems.Items, rangeWithItems.ColumnRange );
 
-      m_list.Add( new SelectionCellRangeWithItems(
-        itemRangeWithItems.Range, itemRangeWithItems.Items, cellRangeWithItems.ColumnRange ) );
-
-      return m_list.Count - 1;
+      this.Insert( this.Count, newRangeWithItems, true );
     }
 
-    public void Insert( int index, SelectionCellRangeWithItems cellRangeWithItems )
+    public void Clear()
     {
-      Debug.Assert( !this.Contains( cellRangeWithItems.CellRange ) );
-      m_cellsCount += cellRangeWithItems.Length;
-
-      SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems;
-
-      SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
-        m_dataGridContext, itemRangeWithItems, ref itemRangeWithItems );
-
-      m_list.Insert(
-        index, new SelectionCellRangeWithItems(
-          itemRangeWithItems.Range, itemRangeWithItems.Items, cellRangeWithItems.ColumnRange ) );
+      m_unsortedRanges.Clear();
+      m_sortedRanges.Clear();
     }
 
-    public void RemoveAt( int index )
+    public bool Contains( int itemIndex, int columnIndex )
     {
-      m_cellsCount -= m_list[ index ].Length;
-      m_list.RemoveAt( index );
-    }
+      if( ( itemIndex < 0 ) || ( columnIndex < 0 ) )
+        return false;
 
-    public void Clear()
-    {
-      m_cellsCount = 0;
-      m_list.Clear();
+      return this.Contains( new SelectionCellRange( itemIndex, columnIndex ) );
     }
 
-    public SelectionCellRangeWithItems[] ToArray()
+    public bool Contains( SelectionCellRange range )
     {
-      return m_list.ToArray();
+      if( ( m_unsortedRanges.Count <= 0 ) || ( SelectedCellsStorage.IsEmpty( range ) ) )
+        return false;
+
+      return this.Contains( new SelectionCellRangeWithItems( range.ItemRange, null, range.ColumnRange ) );
     }
 
-    public bool Contains( int itemIndex, int columnIndex )
+    public bool Contains( SelectionCellRangeWithItems rangeWithItems )
     {
-      if( ( itemIndex < 0 ) || ( columnIndex < 0 ) )
+      if( ( m_unsortedRanges.Count <= 0 ) || ( SelectedCellsStorage.IsEmpty( rangeWithItems ) ) )
         return false;
 
-      SelectionCellRange cellRange = new SelectionCellRange( itemIndex, columnIndex );
-      int count = m_list.Count;
+      if( rangeWithItems.Length == 1 )
+        return this.IndexOfOverlap( rangeWithItems ).Any();
 
-      for( int i = 0; i < count; i++ )
+      var store = new SelectedCellsStorage( null );
+      store.Add( rangeWithItems );
+
+      foreach( var match in this.IndexOfOverlap( rangeWithItems ) )
       {
-        if( !m_list[ i ].CellRange.Intersect( cellRange ).IsEmpty )
+        store.Remove( m_unsortedRanges[ match ].Value );
+
+        if( store.Count == 0 )
           return true;
       }
 
       return false;
     }
 
-    public bool Contains( SelectionCellRange cellRange )
+    public bool Remove( SelectionCellRangeWithItems rangeWithItems )
     {
-      int count = m_list.Count;
-
-      int cellRangeLength = cellRange.Length;
+      if( rangeWithItems.CellRange.IsEmpty )
+        return true;
 
-      // Ensure every Cells are present in the SelectedCellsStorage
-      if( cellRangeLength > 1 )
-      {
-        SelectedCellsStorage cellStorage = new SelectedCellsStorage( null, cellRangeLength );
-        cellStorage.Add( new SelectionCellRangeWithItems( cellRange.ItemRange,
-          null,
-          cellRange.ColumnRange ) );
+      // The SelectionCellRange.IsEmpty should be mapped to the item range's SelectionRange.IsEmpty property.
+      Debug.Assert( !rangeWithItems.ItemRange.IsEmpty );
 
-        for( int i = 0; i < count; i++ )
-        {
-          cellStorage.Remove( m_list[ i ] );
+      var matches = this.IndexOfOverlap( rangeWithItems ).OrderBy( index => index ).ToList();
+      var rangeToRemove = rangeWithItems.CellRange;
 
-          if( cellStorage.Count == 0 )
-            return true;
-        }
-      }
-      else
+      for( int i = matches.Count - 1; i >= 0; i-- )
       {
-        for( int i = 0; i < count; i++ )
-        {
-          if( !m_list[ i ].CellRange.Intersect( cellRange ).IsEmpty )
-            return true;
-        }
-      }
+        var index = matches[ i ];
+        var currentRangeWithItems = m_unsortedRanges[ index ].Value;
+        var currentRange = currentRangeWithItems.CellRange;
+        var overlap = rangeToRemove.Intersect( currentRange );
 
-      return false;
-    }
+        Debug.Assert( !overlap.IsEmpty );
 
-    public bool Contains( SelectionCellRangeWithItems cellRangeWithItemsToCompare )
-    {
-      int count = m_list.Count;
-      SelectionCellRange cellRangeToCompare = cellRangeWithItemsToCompare.CellRange;
+        var newRanges = currentRange.Exclude( overlap );
 
-      int cellRangeLength = cellRangeToCompare.Length;
-      // If there is more than one Cell in the range, ensure 
-      // the range is completely contained within this SelectedCellsStorage
-      if( cellRangeLength > 1 )
-      {
-        SelectedCellsStorage cellStorage = new SelectedCellsStorage( null, cellRangeLength );
-        cellStorage.Add( cellRangeWithItemsToCompare );
-
-        // The range is completely contained when the store 
-        // is empty after removing all ranges contained within
-        // this SelectedCellsStorage
-        for( int i = 0; i < count; i++ )
+        if( newRanges.Length == 0 )
         {
-          SelectionCellRangeWithItems cellRangeWithItems = m_list[ i ];
-
-          cellStorage.Remove( cellRangeWithItems );
-
-          if( cellStorage.Count == 0 )
-            return true;
+          this.RemoveAt( index, true );
         }
-      }
-      else
-      {
-        for( int i = 0; i < count; i++ )
+        else
         {
-          SelectionCellRangeWithItems rangeWithItem = m_list[ i ];
-          SelectionCellRange rangeIntersection = rangeWithItem.CellRange.Intersect( cellRangeToCompare );
+          var currentRangeItems = currentRangeWithItems.ItemRangeWithItems;
+
+          this[ index ] = new SelectionCellRangeWithItems( newRanges[ 0 ].ItemRange, currentRangeItems.GetItems( newRanges[ 0 ].ItemRange ), newRanges[ 0 ].ColumnRange );
 
-          if( !rangeIntersection.IsEmpty )
+          if( newRanges.Length > 1 )
           {
-            if( cellRangeWithItemsToCompare.ItemRangeWithItems.IsItemsEqual(
-              rangeIntersection.ItemRange, rangeWithItem.ItemRangeWithItems ) )
+            for( int j = 1; j < newRanges.Length; j++ )
             {
-              return true;
+              this.Insert( index + j, new SelectionCellRangeWithItems( newRanges[ j ].ItemRange, currentRangeItems.GetItems( newRanges[ j ].ItemRange ), newRanges[ j ].ColumnRange ), false );
             }
+
+            this.RepairIndex( index + 1 );
           }
         }
       }
 
-      return false;
+      return ( matches.Count > 0 );
     }
 
-    public bool Remove( SelectionCellRangeWithItems cellRangeWithItemsToRemove )
+    public void OffsetIndex( int startIndex, int offset )
     {
-      if( cellRangeWithItemsToRemove.CellRange.IsEmpty )
-        return true;
+      if( m_sortedRanges.Count == 0 )
+        return;
 
-      bool removed = false;
-      SelectionCellRange cellRangeToRemove = cellRangeWithItemsToRemove.CellRange;
-      object[] itemsToRemove = cellRangeWithItemsToRemove.ItemRangeWithItems.Items;
-      int itemsToRemoveCount = ( itemsToRemove == null ) ? 0 : itemsToRemove.Length;
-      int itemOffsetToRemove = 0;
-      bool itemRangeToRemoveIsEmpty = cellRangeToRemove.ItemRange.IsEmpty;
+      // Used to offset index after an add or remove from the data source of the grid.
+      var offsetRange = new SelectionRange( startIndex, startIndex + Math.Abs( offset ) - 1 );
+      var comparer = new ItemRangeComparer( offsetRange );
 
-      do
+      // Find the first range that is greater or that overlaps the target range.
+      var index = this.FindIndex( comparer );
+      if( index < 0 )
       {
-        for( int i = m_list.Count - 1; i >= 0; i-- )
+        index = ~index;
+      }
+      else
+      {
+        while( index > 0 )
         {
-          SelectionCellRangeWithItems cellRangeWithItems = m_list[ i ];
-          SelectionRange itemRange = cellRangeWithItems.ItemRange;
-          SelectionCellRange cellRange = cellRangeWithItems.CellRange;
-          SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems;
-          SelectionCellRange cellRangeIntersection;
-          object[] oldRangeItems = itemRangeWithItems.Items;
-
-          if( itemRangeToRemoveIsEmpty )
-          {
-            int itemOffset = Array.IndexOf( oldRangeItems, itemsToRemove[ itemOffsetToRemove ] );
+          if( comparer.Compare( m_sortedRanges[ index - 1 ] ) != 0 )
+            break;
 
-            if( itemOffset == -1 )
-              continue;
-
-            int itemIndex = itemRange.GetIndexFromItemOffset( itemOffset );
-
-            cellRangeIntersection = new SelectionCellRange(
-              new SelectionRange( itemIndex, itemIndex ),
-              cellRangeWithItems.ColumnRange.Intersect( cellRangeToRemove.ColumnRange ) );
-          }
-          else
-          {
-            cellRangeIntersection = cellRange.Intersect( cellRangeToRemove );
-
-            if( cellRangeIntersection.IsEmpty )
-              continue;
-
-            if( !itemRangeWithItems.IsItemsEqual(
-              cellRangeIntersection.ItemRange, cellRangeWithItemsToRemove.ItemRangeWithItems ) )
-            {
-              continue;
-            }
-          }
-
-          removed = true;
-          m_cellsCount -= cellRangeIntersection.Length;
-          SelectionCellRange[] newCellRanges = cellRange.Exclude( cellRangeIntersection );
-
-          if( newCellRanges.Length == 0 )
-          {
-            m_list.RemoveAt( i );
-          }
-          else
-          {
-            SelectionCellRange newCellRange = newCellRanges[ 0 ];
-
-            m_list[ i ] = new SelectionCellRangeWithItems(
-              newCellRange.ItemRange, itemRangeWithItems.GetItems( newCellRange.ItemRange ), newCellRange.ColumnRange );
-
-            for( int j = 1; j < newCellRanges.Length; j++ )
-            {
-              newCellRange = newCellRanges[ j ];
-
-              m_list.Insert( i + j, new SelectionCellRangeWithItems(
-                newCellRange.ItemRange, itemRangeWithItems.GetItems( newCellRange.ItemRange ), newCellRange.ColumnRange ) );
-            }
-          }
+          index--;
         }
+      }
 
-        itemOffsetToRemove++;
-      } while( ( itemRangeToRemoveIsEmpty ) && ( itemOffsetToRemove < itemsToRemoveCount ) );
-
-      return removed;
-    }
-
-    public void OffsetIndex( int itemStartIndex, int offset )
-    {
-      // Used to offset index after an add or remove from the data source of the grid.
-
-      SelectionRange offsetRange = new SelectionRange(
-        itemStartIndex, itemStartIndex + Math.Abs( offset ) - 1 );
+      var matches = m_sortedRanges.Skip( index ).OrderByDescending( item => item.Index ).ToList();
 
-      for( int i = this.Count - 1; i >= 0; i-- )
+      // Adjust the range of all ranges greater or that overlaps the target range.
+      foreach( var currentRangeWithItemsWrapper in matches )
       {
-        SelectionCellRangeWithItems cellRangeWithItems = m_list[ i ];
-        SelectionRange itemRange = cellRangeWithItems.ItemRange;
-        SelectionRange columnRange = cellRangeWithItems.ColumnRange;
+        Debug.Assert( comparer.Compare( currentRangeWithItemsWrapper ) <= 0 );
 
-        if( offsetRange > itemRange )
-          continue;
+        var currentRangeIndex = currentRangeWithItemsWrapper.Index;
+        var currentRangeWithItems = currentRangeWithItemsWrapper.Value;
+        var currentRange = currentRangeWithItems.ItemRange;
+        var currentRangeItems = currentRangeWithItems.ItemRangeWithItems.Items;
 
-        SelectionRange itemRangeIntersection = itemRange.Intersect( offsetRange );
-        object[] originalItems = cellRangeWithItems.ItemRangeWithItems.Items;
+        Debug.Assert( !( offsetRange > currentRange ) );
 
-        if( !itemRangeIntersection.IsEmpty )
+        var currentRangeIntersection = currentRange.Intersect( offsetRange );
+
+        // The range overlaps.
+        if( !currentRangeIntersection.IsEmpty )
         {
           // Should only happen when adding since when we remove data from the source, we remove the
           // the range from the list.
           Debug.Assert( offset > 0 );
 
-          // Offset the index higher than the start index of the new added item
           SelectionRange topRange;
           SelectionRange bottomRange;
 
-          if( itemRange.StartIndex > itemRange.EndIndex )
+          if( currentRange.StartIndex > currentRange.EndIndex )
           {
-            if( itemRangeIntersection.EndIndex == itemRange.EndIndex )
+            if( currentRangeIntersection.EndIndex == currentRange.EndIndex )
             {
-              SelectionRange newItemRange = new SelectionRange( itemRange.StartIndex + offset, itemRange.EndIndex + offset );
-              m_list[ i ] = new SelectionCellRangeWithItems( newItemRange, originalItems, columnRange );
+              this[ currentRangeIndex ] = new SelectionCellRangeWithItems(
+                                            new SelectionRange( currentRange.StartIndex + offset, currentRange.EndIndex + offset ),
+                                            currentRangeItems,
+                                            currentRangeWithItems.ColumnRange );
               continue;
             }
             else
             {
-              int bottomRangeEndIndex = itemStartIndex + offset;
-              bottomRange = new SelectionRange( itemStartIndex - 1, itemRange.EndIndex );
-              topRange = new SelectionRange( itemRange.Length - bottomRange.Length - 1 + bottomRangeEndIndex, bottomRangeEndIndex );
+              topRange = new SelectionRange( currentRange.StartIndex + offset, startIndex + offset );
+              bottomRange = new SelectionRange( startIndex - 1, currentRange.EndIndex );
             }
           }
           else
           {
-            if( itemRangeIntersection.StartIndex == itemRange.StartIndex )
+            if( currentRangeIntersection.StartIndex == currentRange.StartIndex )
             {
-              SelectionRange newItemRange = new SelectionRange( itemRange.StartIndex + offset, itemRange.EndIndex + offset );
-              m_list[ i ] = new SelectionCellRangeWithItems( newItemRange, originalItems, columnRange );
+              this[ currentRangeIndex ] = new SelectionCellRangeWithItems(
+                                            new SelectionRange( currentRange.StartIndex + offset, currentRange.EndIndex + offset ),
+                                            currentRangeItems,
+                                            currentRangeWithItems.ColumnRange );
               continue;
             }
             else
             {
-              int bottomRangeStartIndex = itemStartIndex + offset;
-              topRange = new SelectionRange( itemRange.StartIndex, itemStartIndex - 1 );
-              bottomRange = new SelectionRange( bottomRangeStartIndex, itemRange.Length - topRange.Length - 1 + bottomRangeStartIndex );
+              topRange = new SelectionRange( currentRange.StartIndex, startIndex - 1 );
+              bottomRange = new SelectionRange( startIndex + offset, currentRange.EndIndex + offset );
             }
           }
 
           object[] topItems = null;
           object[] bottomItems = null;
 
-          if( originalItems != null )
+          if( currentRangeItems != null )
           {
             topItems = new object[ topRange.Length ];
-            Array.Copy( originalItems, 0, topItems, 0, topItems.Length );
+            Array.Copy( currentRangeItems, 0, topItems, 0, topItems.Length );
+
             bottomItems = new object[ bottomRange.Length ];
-            Array.Copy( originalItems, topItems.Length, bottomItems, 0, bottomItems.Length );
+            Array.Copy( currentRangeItems, topItems.Length, bottomItems, 0, bottomItems.Length );
           }
 
-          m_list[ i ] = new SelectionCellRangeWithItems( topRange, topItems, columnRange );
-          m_list.Insert( i + 1, new SelectionCellRangeWithItems( bottomRange, bottomItems, columnRange ) );
+          this[ currentRangeIndex ] = new SelectionCellRangeWithItems( topRange, topItems, currentRangeWithItems.ColumnRange );
+          this.Insert( currentRangeIndex + 1, new SelectionCellRangeWithItems( bottomRange, bottomItems, currentRangeWithItems.ColumnRange ), true );
         }
+        // The range is greater.
         else
         {
-          // Offset the index by the count added
-          SelectionRange newItemRange = new SelectionRange( itemRange.StartIndex + offset, itemRange.EndIndex + offset );
-          m_list[ i ] = new SelectionCellRangeWithItems( newItemRange, originalItems, columnRange );
+          this[ currentRangeIndex ] = new SelectionCellRangeWithItems(
+                                        new SelectionRange( currentRange.StartIndex + offset, currentRange.EndIndex + offset ),
+                                        currentRangeItems,
+                                        currentRangeWithItems.ColumnRange );
         }
       }
     }
@@ -412,20 +297,22 @@ namespace Xceed.Wpf.DataGrid
       if( m_dataGridContext == null )
         throw new InvalidOperationException( "We must have a DataGridContext to find the new index." );
 
-      CollectionView sourceItems = m_dataGridContext.Items;
+      if( maxOffset == 0 )
+        return;
+
+      var sourceItems = m_dataGridContext.Items;
 
       for( int i = this.Count - 1; i >= 0; i-- )
       {
-        SelectionCellRangeWithItems cellRangeWithItems = m_list[ i ];
-        SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems;
-        object[] items = itemRangeWithItems.Items;
+        var rangeWithItems = this[ i ];
+        var rangeItems = rangeWithItems.ItemRangeWithItems.Items;
 
-        if( items == null )
+        if( rangeItems == null )
           throw new InvalidOperationException( "We should have items to find the new index." );
 
-        object item = items[ 0 ];
-        SelectionRange itemRange = itemRangeWithItems.Range;
-        int startIndex = Math.Min( itemRange.StartIndex, itemRange.EndIndex );
+        var item = rangeItems[ 0 ];
+        var range = rangeWithItems.ItemRange;
+        var startIndex = range.StartIndex;
 
         if( maxOffset < 0 )
         {
@@ -435,8 +322,7 @@ namespace Xceed.Wpf.DataGrid
             {
               if( j != 0 )
               {
-                SelectionRange newItemRange = new SelectionRange( itemRange.StartIndex + j, itemRange.EndIndex + j );
-                m_list[ i ] = new SelectionCellRangeWithItems( newItemRange, items, cellRangeWithItems.ColumnRange );
+                this[ i ] = new SelectionCellRangeWithItems( new SelectionRange( range.StartIndex + j, range.EndIndex + j ), rangeItems, rangeWithItems.ColumnRange );
               }
 
               break;
@@ -450,7 +336,7 @@ namespace Xceed.Wpf.DataGrid
         }
         else
         {
-          int sourceItemCount = sourceItems.Count;
+          var sourceItemCount = sourceItems.Count;
 
           for( int j = 0; j <= maxOffset; j++ )
           {
@@ -458,8 +344,7 @@ namespace Xceed.Wpf.DataGrid
             {
               if( j != 0 )
               {
-                SelectionRange newItemRange = new SelectionRange( itemRange.StartIndex + j, itemRange.EndIndex + j );
-                m_list[ i ] = new SelectionCellRangeWithItems( newItemRange, items, cellRangeWithItems.ColumnRange );
+                this[ i ] = new SelectionCellRangeWithItems( new SelectionRange( range.StartIndex + j, range.EndIndex + j ), rangeItems, rangeWithItems.ColumnRange );
               }
 
               break;
@@ -474,52 +359,391 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    public List<SelectionRange> GetIntersectedColumnRanges( SelectionCellRange cellRange )
+    public IEnumerable<SelectionRange> GetIntersectedColumnRanges( SelectionCellRange range )
+    {
+      return ( from match in this.IndexOfOverlap( range )
+               let current = m_unsortedRanges[ match ].Value
+               let intersection = current.CellRange.Intersect( range )
+               select intersection.ColumnRange ).ToList();
+    }
+
+    public IEnumerable<SelectionCellRangeWithItems> GetIntersectedCellRangesWithItems( SelectionCellRange range )
+    {
+      return ( from match in this.IndexOfOverlap( range )
+               let current = m_unsortedRanges[ match ].Value
+               let intersection = current.CellRange.Intersect( range )
+               select new SelectionCellRangeWithItems(
+                 intersection.ItemRange,
+                 current.ItemRangeWithItems.GetItems( intersection.ItemRange ),
+                 intersection.ColumnRange ) ).ToList();
+    }
+
+    private void Insert( int index, SelectionCellRangeWithItems item, bool repairIndex )
+    {
+      var wrapper = new SelectionCellRangeWithItemsWrapper( item, index );
+
+      m_unsortedRanges.Insert( index, wrapper );
+
+      if( repairIndex )
+      {
+        this.RepairIndex( index + 1 );
+      }
+
+      if( !SelectedCellsStorage.IsEmpty( item ) )
+      {
+        var insertionIndex = ~this.FindIndex( new ItemComparer( wrapper ) );
+        Debug.Assert( insertionIndex >= 0 );
+
+        m_sortedRanges.Insert( insertionIndex, wrapper );
+      }
+    }
+
+    private void RemoveAt( int index, bool repairIndex )
     {
-      List<SelectionRange> intersectionRanges = new List<SelectionRange>();
-      int count = m_list.Count;
+      var wrapper = m_unsortedRanges[ index ];
+      Debug.Assert( wrapper.Index == index );
 
-      for( int i = 0; i < count; i++ )
+      if( !SelectedCellsStorage.IsEmpty( wrapper.Value ) )
       {
-        SelectionCellRangeWithItems range = m_list[ i ];
-        SelectionCellRange cellRangeIntersection = range.CellRange.Intersect( cellRange );
+        var removalIndex = this.FindIndex( new ItemComparer( wrapper ) );
+        Debug.Assert( removalIndex >= 0 );
+
+        m_sortedRanges.RemoveAt( removalIndex );
+      }
+
+      m_unsortedRanges.RemoveAt( index );
+
+      if( repairIndex )
+      {
+        this.RepairIndex( index );
+      }
+    }
+
+    private void RepairIndex( int index )
+    {
+      Debug.Assert( index >= 0 );
+
+      for( int i = index; i < m_unsortedRanges.Count; i++ )
+      {
+        m_unsortedRanges[ i ].Index = i;
+      }
+    }
+
+    private IEnumerable<int> IndexOfOverlap( SelectionCellRange target )
+    {
+      if( ( m_sortedRanges.Count <= 0 ) || SelectedCellsStorage.IsEmpty( target ) )
+        yield break;
+
+      var comparer = new ItemRangeComparer( target.ItemRange );
 
-        if( !cellRangeIntersection.IsEmpty )
+      var index = this.FindIndex( comparer );
+      if( index < 0 )
+        yield break;
+
+      while( index > 0 )
+      {
+        if( comparer.Compare( m_sortedRanges[ index - 1 ] ) != 0 )
+          break;
+
+        index--;
+      }
+
+      for( int i = index; i < m_sortedRanges.Count; i++ )
+      {
+        var wrapper = m_sortedRanges[ i ];
+        if( comparer.Compare( wrapper ) != 0 )
+          break;
+
+        var currentRangeWithItems = wrapper.Value;
+        var overlap = target.Intersect( currentRangeWithItems.CellRange );
+
+        if( !SelectedCellsStorage.IsEmpty( overlap ) )
+          yield return wrapper.Index;
+      }
+    }
+
+    private IEnumerable<int> IndexOfOverlap( SelectionCellRangeWithItems target )
+    {
+      var targetRange = target.CellRange;
+      var targetRangeWithItems = target.ItemRangeWithItems;
+      var targetItemRange = targetRange.ItemRange;
+
+      foreach( var match in this.IndexOfOverlap( targetRange ) )
+      {
+        var currentRangeWithItems = m_unsortedRanges[ match ].Value;
+        var overlap = targetItemRange.Intersect( currentRangeWithItems.ItemRange );
+
+        Debug.Assert( !overlap.IsEmpty );
+
+        if( targetRangeWithItems.IsItemsEqual( overlap, currentRangeWithItems.ItemRangeWithItems ) )
+          yield return match;
+      }
+    }
+
+    private int FindIndex( ISelectionRangeComparer comparer )
+    {
+      Debug.Assert( comparer != null );
+
+      var lowerBound = 0;
+      var upperBound = m_sortedRanges.Count - 1;
+
+      while( lowerBound <= upperBound )
+      {
+        var middle = lowerBound + ( upperBound - lowerBound ) / 2;
+        var compare = comparer.Compare( m_sortedRanges[ middle ] );
+
+        if( compare < 0 )
+        {
+          if( middle == lowerBound )
+            return ~middle;
+
+          upperBound = middle - 1;
+        }
+        else if( compare > 0 )
+        {
+          if( middle == upperBound )
+            return ~( middle + 1 );
+
+          lowerBound = middle + 1;
+        }
+        else
+        {
+          return middle;
+        }
+      }
+
+      return ~0;
+    }
+
+    private static bool IsEmpty( SelectionCellRange range )
+    {
+      return ( range.ItemRange.IsEmpty )
+          || ( range.ColumnRange.IsEmpty );
+    }
+
+    private static bool IsEmpty( SelectionCellRangeWithItems rangeWithItems )
+    {
+      return ( rangeWithItems.ItemRange.IsEmpty )
+          || ( rangeWithItems.ColumnRange.IsEmpty );
+    }
+
+    #region ICloneable Members
+
+    public object Clone()
+    {
+      var copy = new SelectedCellsStorage( m_dataGridContext );
+
+      for( int i = 0; i < m_unsortedRanges.Count; i++ )
+      {
+        copy.Insert( i, m_unsortedRanges[ i ].Value, false );
+      }
+
+      return copy;
+    }
+
+    #endregion
+
+    #region IEnumerable<SelectionCellRangeWithItems> Members
+
+    public IEnumerator<SelectionCellRangeWithItems> GetEnumerator()
+    {
+      return m_unsortedRanges.Select( item => item.Value ).GetEnumerator();
+    }
+
+    #endregion
+
+    #region IEnumerable Members
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+      return this.GetEnumerator();
+    }
+
+    #endregion
+
+    #region Private Fields
+
+    private readonly List<SelectionCellRangeWithItemsWrapper> m_unsortedRanges = new List<SelectionCellRangeWithItemsWrapper>();
+    private readonly List<SelectionCellRangeWithItemsWrapper> m_sortedRanges = new List<SelectionCellRangeWithItemsWrapper>();
+
+    #endregion
+
+    #region SelectionCellRangeWithItemsWrapper Private Class
+
+    // We are wrapping the SelectionCellRangeWithItems structure inside a class so our collections
+    // may target the same object.
+    private sealed class SelectionCellRangeWithItemsWrapper
+    {
+      internal SelectionCellRangeWithItemsWrapper( SelectionCellRangeWithItems value, int index )
+      {
+        m_value = value;
+        m_index = index;
+      }
+
+      internal SelectionCellRangeWithItems Value
+      {
+        get
+        {
+          return m_value;
+        }
+      }
+
+      internal int Index
+      {
+        get
+        {
+          return m_index;
+        }
+        set
         {
-          intersectionRanges.Add( cellRangeIntersection.ColumnRange );
+          m_index = value;
         }
       }
 
-      return intersectionRanges;
+      private readonly SelectionCellRangeWithItems m_value;
+      private int m_index;
     }
 
-    public List<SelectionCellRangeWithItems> GetIntersectedCellRangesWithItems( SelectionCellRange cellRange )
+    #endregion
+
+    #region ISelectionRangeComparer Private Interface
+
+    private interface ISelectionRangeComparer
     {
-      List<SelectionCellRangeWithItems> intersectionCellRanges = new List<SelectionCellRangeWithItems>();
-      int count = m_list.Count;
+      int Compare( SelectionCellRangeWithItemsWrapper item );
+    }
+
+    #endregion
 
-      for( int i = 0; i < count; i++ )
+    #region ItemComparer Private Class
+
+    private sealed class ItemComparer : ISelectionRangeComparer
+    {
+      internal ItemComparer( SelectionCellRangeWithItemsWrapper target )
       {
-        SelectionCellRangeWithItems range = m_list[ i ];
-        SelectionCellRange cellRangeIntersection = range.CellRange.Intersect( cellRange );
+        if( target == null )
+          throw new ArgumentNullException( "target" );
 
-        if( !cellRangeIntersection.IsEmpty )
+        if( SelectedCellsStorage.IsEmpty( target.Value ) )
+          throw new ArgumentException( "The selection range must not be empty.", "target" );
+
+        m_target = target;
+      }
+
+      public int Compare( SelectionCellRangeWithItemsWrapper item )
+      {
+        if( m_target == item )
+          return 0;
+
+        var xri = m_target.Value;
+        var yri = item.Value;
+
+        int compare;
+
+        compare = ItemComparer.Compare( xri.ItemRange, yri.ItemRange );
+        if( compare != 0 )
         {
-          intersectionCellRanges.Add(
-            new SelectionCellRangeWithItems(
-              cellRangeIntersection.ItemRange,
-              range.ItemRangeWithItems.GetItems( cellRangeIntersection.ItemRange ),
-              cellRangeIntersection.ColumnRange ) );
+          Debug.Assert( ( ( compare < 0 ) && ItemRangeComparer.Compare( xri.ItemRange, item ) <= 0 )
+                     || ( ( compare > 0 ) && ItemRangeComparer.Compare( xri.ItemRange, item ) >= 0 ) );
+
+          return compare;
         }
+
+        Debug.Assert( ItemRangeComparer.Compare( xri.ItemRange, item ) == 0 );
+
+        compare = ItemComparer.Compare( xri.CellRange.ColumnRange, yri.CellRange.ColumnRange );
+        if( compare != 0 )
+          return compare;
+
+        Debug.Assert( xri.CellRange == yri.CellRange );
+
+        return ( m_target.Index - item.Index );
       }
 
-      return intersectionCellRanges;
+      private static int Compare( SelectionRange xr, SelectionRange yr )
+      {
+        int xs, xe, ys, ye;
+        ItemComparer.GetBounds( xr, out xs, out xe );
+        ItemComparer.GetBounds( yr, out ys, out ye );
+
+        if( xs < ys )
+        {
+          return -1;
+        }
+        else if( xs > ys )
+        {
+          return 1;
+        }
+
+        Debug.Assert( !xr.Intersect( yr ).IsEmpty );
+
+        if( xe < ye )
+        {
+          return -1;
+        }
+        else if( xe > ye )
+        {
+          return 1;
+        }
+
+        Debug.Assert( xr == yr );
+        return 0;
+      }
+
+      private static void GetBounds( SelectionRange range, out int startIndex, out int endIndex )
+      {
+        if( range.StartIndex <= range.EndIndex )
+        {
+          startIndex = range.StartIndex;
+          endIndex = range.EndIndex;
+        }
+        else
+        {
+          endIndex = range.StartIndex;
+          startIndex = range.EndIndex;
+        }
+      }
+
+      private readonly SelectionCellRangeWithItemsWrapper m_target;
     }
 
-    #endregion PUBLIC METHODS
+    #endregion
+
+    #region ItemRangeComparer Private Class
+
+    private sealed class ItemRangeComparer : ISelectionRangeComparer
+    {
+      internal ItemRangeComparer( SelectionRange target )
+      {
+        if( target.IsEmpty )
+          throw new ArgumentException( "The selection range must not be empty.", "target" );
+
+        m_target = target;
+      }
+
+      public int Compare( SelectionCellRangeWithItemsWrapper item )
+      {
+        return ItemRangeComparer.Compare( m_target, item );
+      }
+
+      internal static int Compare( SelectionRange range, SelectionCellRangeWithItemsWrapper wrapper )
+      {
+        var itemRange = wrapper.Value.ItemRange;
+
+        if( range < itemRange )
+          return -1;
+
+        if( range > itemRange )
+          return 1;
+
+        Debug.Assert( !range.Intersect( itemRange ).IsEmpty );
+
+        return 0;
+      }
+
+      private readonly SelectionRange m_target;
+    }
 
-    private List<SelectionCellRangeWithItems> m_list;
-    private DataGridContext m_dataGridContext;
-    private int m_cellsCount;
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedItemsStorage.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedItemsStorage.cs
index 339aa685..eae732ef 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedItemsStorage.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectedItemsStorage.cs
@@ -15,45 +15,39 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Collections;
+using System.Collections.Generic;
 using System.Diagnostics;
-using System.Windows.Data;
+using System.Linq;
 
 namespace Xceed.Wpf.DataGrid
 {
-  internal class SelectedItemsStorage : IEnumerable
+  internal class SelectedItemsStorage : ICloneable, IEnumerable<SelectionRangeWithItems>, IEnumerable
   {
-    #region CONSTRUCTORS
+    #region Constructors
 
-    internal SelectedItemsStorage( DataGridContext dataGridContext, int capacity )
+    internal SelectedItemsStorage( DataGridContext dataGridContext )
     {
       // dataGridContext can be null for store that we don't want to auto-get Items from index
       m_dataGridContext = dataGridContext;
-      m_list = new List<SelectionRangeWithItems>( capacity );
     }
 
-    internal SelectedItemsStorage( SelectedItemsStorage collection )
-    {
-      m_dataGridContext = collection.m_dataGridContext;
-      m_list = new List<SelectionRangeWithItems>( collection.m_list );
-      m_itemsCount = collection.m_itemsCount;
-    }
+    #endregion
 
-    #endregion CONSTRUCTORS
-
-    #region PUBLIC PROPERTIES
+    #region Count Property
 
     public int Count
     {
       get
       {
-        return m_list.Count;
+        return m_unsortedRanges.Count;
       }
     }
 
+    #endregion
+
+    #region ItemsCount Property
+
     public int ItemsCount
     {
       get
@@ -62,6 +56,12 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private int m_itemsCount;
+
+    #endregion
+
+    #region DataGridContext Property
+
     public DataGridContext DataGridContext
     {
       get
@@ -70,32 +70,26 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    private readonly DataGridContext m_dataGridContext;
+
+    #endregion
+
+    #region [] Property
+
     public SelectionRangeWithItems this[ int index ]
     {
       get
       {
-        return m_list[ index ];
+        return m_unsortedRanges[ index ].Value;
       }
-      set
+      private set
       {
-        SelectionRangeWithItems oldRangeWithItems = m_list[ index ];
-        m_list[ index ] = value;
-        m_itemsCount += value.Length - oldRangeWithItems.Length;
+        this.RemoveAt( index, false );
+        this.Insert( index, value, false );
       }
     }
 
-    #endregion PUBLIC PROPERTIES
-
-    #region IEnumerable
-
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-      return m_list.GetEnumerator();
-    }
-
-    #endregion IEnumerable
-
-    #region PUBLIC METHODS
+    #endregion
 
     public static void UpdateSelectionRangeWithItemsFromAdd(
       DataGridContext dataGridContext,
@@ -106,350 +100,252 @@ namespace Xceed.Wpf.DataGrid
 
       object[] newRangeItems = newRangeWithItems.Items;
 
-      if( ( ( dataGridContext == null )
+      if( ( dataGridContext == null )
         || ( ( dataGridContext.ItemsSourceCollection == null ) && ( newRangeItems == null ) )
-        || ( dataGridContext.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase ) ) )
+        || ( dataGridContext.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase ) )
       {
-        lastRangeWithItems = new SelectionRangeWithItems(
-          new SelectionRange( lastRangeWithItems.Range.StartIndex, newRangeWithItems.Range.EndIndex ),
-          null );
-
+        lastRangeWithItems = new SelectionRangeWithItems( new SelectionRange( lastRangeWithItems.Range.StartIndex, newRangeWithItems.Range.EndIndex ), null );
         return;
       }
 
-      object[] rangeToUpdateItems = lastRangeWithItems.Items;
-      object[] newItems;
-      int newItemsStartPosition;
+      SharedList newItemsList;
 
       if( newRangeWithItems == lastRangeWithItems )
       {
         if( newRangeItems != null )
           return;
 
-        newItemsStartPosition = 0;
-        newItems = new object[ lastRangeWithItems.Length ];
+        newItemsList = new SharedList( lastRangeWithItems.Length );
       }
       else
       {
-        newItemsStartPosition = lastRangeWithItems.Length;
-        newItems = new object[ lastRangeWithItems.Length + newRangeWithItems.Length ];
-        Array.Copy( rangeToUpdateItems, newItems, newItemsStartPosition );
+        int minNewCapacity = lastRangeWithItems.Length + newRangeWithItems.Length;
+
+        // Optimization, re-use the ItemsList if available.
+        if( lastRangeWithItems.SharedList != null )
+        {
+          newItemsList = lastRangeWithItems.SharedList.Value;
+          newItemsList.EnsureCapacity( minNewCapacity );
+        }
+        else
+        {
+          newItemsList = new SharedList( minNewCapacity );
+          newItemsList.AddRange( lastRangeWithItems.Items );
+        }
       }
 
-      CollectionView items = ( dataGridContext == null ) ? null : dataGridContext.Items;
-      int rangeToUpdateStartIndex = lastRangeWithItems.Range.StartIndex;
-      int rangeToUpdateEndIndex = lastRangeWithItems.Range.EndIndex;
-      int newRangeStartIndex = newRangeWithItems.Range.StartIndex;
-      int newRangeEndIndex = newRangeWithItems.Range.EndIndex;
+      var rangeToUpdateStartIndex = lastRangeWithItems.Range.StartIndex;
+      var newRangeEndIndex = newRangeWithItems.Range.EndIndex;
 
       // If new range have no items set, found the items and set it.
       if( newRangeItems == null )
       {
+        var items = dataGridContext.Items;
+        var newRangeStartIndex = newRangeWithItems.Range.StartIndex;
+
         if( newRangeEndIndex > newRangeStartIndex )
         {
           for( int i = newRangeStartIndex; i <= newRangeEndIndex; i++ )
           {
-            newItems[ newItemsStartPosition ] = items.GetItemAt( i );
-            newItemsStartPosition++;
+            newItemsList.Add( items.GetItemAt( i ) );
           }
         }
         else
         {
           for( int i = newRangeStartIndex; i >= newRangeEndIndex; i-- )
           {
-            newItems[ newItemsStartPosition ] = items.GetItemAt( i );
-            newItemsStartPosition++;
+            newItemsList.Add( items.GetItemAt( i ) );
           }
         }
       }
       else
       {
-        for( int i = 0; i < newRangeItems.Length; i++ )
-        {
-          newItems[ newItemsStartPosition ] = newRangeItems[ i ];
-          newItemsStartPosition++;
-        }
+        newItemsList.AddRange( newRangeItems );
       }
 
-      lastRangeWithItems = new SelectionRangeWithItems(
-        new SelectionRange( rangeToUpdateStartIndex, newRangeEndIndex ),
-        newItems );
+      lastRangeWithItems = new SelectionRangeWithItems( new SelectionRange( rangeToUpdateStartIndex, newRangeEndIndex ), newItemsList );
     }
 
-    public int Add( SelectionRangeWithItems rangeWithItems )
+    public void Add( SelectionRangeWithItems rangeWithItems )
     {
       Debug.Assert( !this.Contains( rangeWithItems.Range ) );
 
       m_itemsCount += rangeWithItems.Length;
-      int count = m_list.Count;
 
-      if( count > 0 )
+      if( this.Count > 0 )
       {
-        int lastIndex = count - 1;
-        SelectionRangeWithItems lastRangeWithItems = m_list[ lastIndex ];
-        SelectionRange lastRange = lastRangeWithItems.Range;
+        var lastIndex = this.Count - 1;
+        var lastRangeWithItems = this[ lastIndex ];
+        var lastRange = lastRangeWithItems.Range;
 
         if( ( lastRange.EndIndex + 1 ) == rangeWithItems.Range.StartIndex )
         {
           Debug.Assert( rangeWithItems.Range.EndIndex > lastRange.EndIndex );
 
-          SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
-            m_dataGridContext, rangeWithItems, ref lastRangeWithItems );
+          SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd( m_dataGridContext, rangeWithItems, ref lastRangeWithItems );
 
-          m_list[ lastIndex ] = lastRangeWithItems;
-          return lastIndex;
+          this[ lastIndex ] = lastRangeWithItems;
+          return;
         }
         else if( ( lastRange.EndIndex - 1 ) == rangeWithItems.Range.StartIndex )
         {
           Debug.Assert( rangeWithItems.Range.EndIndex < lastRange.EndIndex );
 
-          SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
-            m_dataGridContext, rangeWithItems, ref lastRangeWithItems );
+          SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd( m_dataGridContext, rangeWithItems, ref lastRangeWithItems );
 
-          m_list[ lastIndex ] = lastRangeWithItems;
-          return lastIndex;
+          this[ lastIndex ] = lastRangeWithItems;
+          return;
         }
       }
 
-      SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
-        m_dataGridContext, rangeWithItems, ref rangeWithItems );
-
-      m_list.Add( rangeWithItems );
-      return m_list.Count - 1;
-    }
-
-    public void Insert( int index, SelectionRangeWithItems rangeWithItems )
-    {
-      Debug.Assert( !this.Contains( rangeWithItems.Range ) );
-      m_itemsCount += rangeWithItems.Length;
-
-      SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
-        m_dataGridContext, rangeWithItems, ref rangeWithItems );
+      SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd( m_dataGridContext, rangeWithItems, ref rangeWithItems );
 
-      m_list.Insert( index, rangeWithItems );
-    }
-
-    public void RemoveAt( int index )
-    {
-      m_itemsCount -= m_list[ index ].Length;
-      m_list.RemoveAt( index );
+      this.Insert( this.Count, rangeWithItems, true );
     }
 
     public void Clear()
     {
       m_itemsCount = 0;
-      m_list.Clear();
-    }
-
-    public SelectionRangeWithItems[] ToArray()
-    {
-      return m_list.ToArray();
+      m_unsortedRanges.Clear();
+      m_sortedRanges.Clear();
     }
 
     public SelectionRange[] ToSelectionRangeArray()
     {
-      int count = m_list.Count;
-      SelectionRange[] selections = new SelectionRange[ count ];
-
-      for( int i = 0; i < count; i++ )
-      {
-        selections[ i ] = m_list[ i ].Range;
-      }
-
-      return selections;
+      return ( from item in m_unsortedRanges
+               select item.Value.Range ).ToArray();
     }
 
     public bool Contains( int itemIndex )
     {
-      SelectionRange itemRange = new SelectionRange( itemIndex );
-      int count = m_list.Count;
-
-      for( int i = 0; i < count; i++ )
-      {
-        if( !m_list[ i ].Range.Intersect( itemRange ).IsEmpty )
-          return true;
-      }
-
-      return false;
+      return this.Contains( new SelectionRange( itemIndex ) );
     }
 
-    public bool Contains( SelectionRange itemRange )
+    public bool Contains( SelectionRange range )
     {
-      int count = m_list.Count;
-
-      for( int i = 0; i < count; i++ )
-      {
-        if( !m_list[ i ].Range.Intersect( itemRange ).IsEmpty )
-          return true;
-      }
+      if( range.IsEmpty )
+        return false;
 
-      return false;
+      return ( this.FindIndex( new RangeComparer( range ) ) >= 0 );
     }
 
-    public bool Contains( SelectionRangeWithItems rangeWithItemsToCompare )
+    public bool Contains( SelectionRangeWithItems rangeWithItems )
     {
-      int count = m_list.Count;
-      SelectionRange rangeToCompare = rangeWithItemsToCompare.Range;
-
-      for( int i = 0; i < count; i++ )
-      {
-        SelectionRangeWithItems rangeWithItem = m_list[ i ];
-        SelectionRange rangeIntersection = rangeWithItem.Range.Intersect( rangeToCompare );
+      return this.IndexOfOverlap( rangeWithItems ).Any();
+    }
 
-        if( !rangeIntersection.IsEmpty )
-        {
-          if( rangeWithItemsToCompare.IsItemsEqual( rangeIntersection, rangeWithItem ) )
-            return true;
-        }
-      }
+    public bool Remove( SelectionRangeWithItems rangeWithItems )
+    {
+      if( rangeWithItems.IsEmpty )
+        return this.RemoveEmptyRange( rangeWithItems );
 
-      return false;
+      return this.RemoveRangeWithItems( rangeWithItems );
     }
 
-    public bool Remove( SelectionRangeWithItems rangeWithItemsToRemove )
+    public void OffsetIndex( int startIndex, int offset )
     {
-      bool removed = false;
-      SelectionRange rangeToRemove = rangeWithItemsToRemove.Range;
-      object[] itemsToRemove = rangeWithItemsToRemove.Items;
-      int itemsToRemoveCount = ( itemsToRemove == null ) ? 0 : itemsToRemove.Length;
-      int itemOffsetToRemove = 0;
-      bool rangeToRemoveIsEmpty = rangeToRemove.IsEmpty;
+      if( m_sortedRanges.Count == 0 )
+        return;
 
-      do
+      // Used to offset index after an add or remove from the data source of the grid.
+      var offsetRange = new SelectionRange( startIndex, startIndex + Math.Abs( offset ) - 1 );
+      var comparer = new RangeComparer( offsetRange );
+
+      // Find the first range that is greater or that overlaps the target range.
+      var index = this.FindIndex( comparer );
+      if( index < 0 )
+      {
+        index = ~index;
+      }
+      else
       {
-        for( int i = m_list.Count - 1; i >= 0; i-- )
+        while( index > 0 )
         {
-          SelectionRangeWithItems rangeWithItems = m_list[ i ];
-          SelectionRange range = rangeWithItems.Range;
-          SelectionRange rangeIntersection;
-          object[] oldRangeItems = rangeWithItems.Items;
-
-          if( rangeToRemoveIsEmpty )
-          {
-            int itemOffset = Array.IndexOf( oldRangeItems, itemsToRemove[ itemOffsetToRemove ] );
-
-            if( itemOffset == -1 )
-              continue;
-
-            rangeIntersection = new SelectionRange( range.GetIndexFromItemOffset( itemOffset ) );
-          }
-          else
-          {
-            rangeIntersection = range.Intersect( rangeToRemove );
+          if( comparer.Compare( m_sortedRanges[ index - 1 ] ) != 0 )
+            break;
 
-            if( rangeIntersection.IsEmpty )
-              continue;
-
-            if( !rangeWithItems.IsItemsEqual( rangeIntersection, rangeWithItemsToRemove ) )
-              continue;
-          }
-
-          removed = true;
-          m_itemsCount -= rangeIntersection.Length;
-          SelectionRange[] newRanges = range.Exclude( rangeIntersection );
-
-          if( newRanges.Length == 0 )
-          {
-            m_list.RemoveAt( i );
-          }
-          else
-          {
-            SelectionRange newRange = newRanges[ 0 ];
-            m_list[ i ] = new SelectionRangeWithItems( newRange, rangeWithItems.GetItems( newRange ) );
-
-            if( newRanges.Length > 1 )
-            {
-              Debug.Assert( newRanges.Length == 2 );
-              newRange = newRanges[ 1 ];
-              m_list.Insert( i + 1, new SelectionRangeWithItems( newRange, rangeWithItems.GetItems( newRange ) ) );
-            }
-          }
+          index--;
         }
+      }
 
-        itemOffsetToRemove++;
-      } while( ( rangeToRemoveIsEmpty ) && ( itemOffsetToRemove < itemsToRemoveCount ) );
-
-      return removed;
-    }
-
-    public void OffsetIndex( int startIndex, int offset )
-    {
-      // Used to offset index after an add or remove from the data source of the grid.
-
-      SelectionRange offsetRange = new SelectionRange(
-        startIndex, startIndex + Math.Abs( offset ) - 1 );
+      var matches = m_sortedRanges.Skip( index ).OrderByDescending( item => item.Index ).ToList();
 
-      for( int i = this.Count - 1; i >= 0; i-- )
+      // Adjust the range of all ranges greater or that overlaps the target range.
+      foreach( var currentRangeWithItemsWrapper in matches )
       {
-        SelectionRangeWithItems rangeWithItems = m_list[ i ];
-        SelectionRange range = rangeWithItems.Range;
+        Debug.Assert( comparer.Compare( currentRangeWithItemsWrapper ) <= 0 );
+
+        var currentRangeIndex = currentRangeWithItemsWrapper.Index;
+        var currentRangeWithItems = currentRangeWithItemsWrapper.Value;
+        var currentRange = currentRangeWithItems.Range;
+        var currentRangeItems = currentRangeWithItems.Items;
 
-        if( offsetRange > range )
-          continue;
+        Debug.Assert( !( offsetRange > currentRange ) );
 
-        SelectionRange rangeIntersection = range.Intersect( offsetRange );
-        object[] originalItems = rangeWithItems.Items;
+        var currentRangeIntersection = currentRange.Intersect( offsetRange );
 
-        if( !rangeIntersection.IsEmpty )
+        // The range overlaps.
+        if( !currentRangeIntersection.IsEmpty )
         {
           // Should only happen when adding since when we remove data from the source, we remove the
           // the range from the list.
           Debug.Assert( offset > 0 );
 
-          // Offset the index higher than the start index of the new added item
           SelectionRange topRange;
           SelectionRange bottomRange;
 
-          if( range.StartIndex > range.EndIndex )
+          if( currentRange.StartIndex > currentRange.EndIndex )
           {
-            if( rangeIntersection.EndIndex == range.EndIndex )
+            if( currentRangeIntersection.EndIndex == currentRange.EndIndex )
             {
-              SelectionRange newRange = new SelectionRange( range.StartIndex + offset, range.EndIndex + offset );
-              m_list[ i ] = new SelectionRangeWithItems( newRange, originalItems );
+              this[ currentRangeIndex ] = new SelectionRangeWithItems(
+                                            new SelectionRange( currentRange.StartIndex + offset, currentRange.EndIndex + offset ),
+                                            currentRangeItems );
               continue;
             }
             else
             {
-              int bottomRangeEndIndex = startIndex + offset;
-              bottomRange = new SelectionRange( startIndex - 1, range.EndIndex );
-              topRange = new SelectionRange( range.Length - bottomRange.Length - 1 + bottomRangeEndIndex, bottomRangeEndIndex );
+              topRange = new SelectionRange( currentRange.StartIndex + offset, startIndex + offset );
+              bottomRange = new SelectionRange( startIndex - 1, currentRange.EndIndex );
             }
           }
           else
           {
-            if( rangeIntersection.StartIndex == range.StartIndex )
+            if( currentRangeIntersection.StartIndex == currentRange.StartIndex )
             {
-              SelectionRange newRange = new SelectionRange( range.StartIndex + offset, range.EndIndex + offset );
-              m_list[ i ] = new SelectionRangeWithItems( newRange, originalItems );
+              this[ currentRangeIndex ] = new SelectionRangeWithItems(
+                                            new SelectionRange( currentRange.StartIndex + offset, currentRange.EndIndex + offset ),
+                                            currentRangeItems );
               continue;
             }
             else
             {
-              int bottomRangeStartIndex = startIndex + offset;
-              topRange = new SelectionRange( range.StartIndex, startIndex - 1 );
-              bottomRange = new SelectionRange( bottomRangeStartIndex, range.Length - topRange.Length - 1 + bottomRangeStartIndex );
+              topRange = new SelectionRange( currentRange.StartIndex, startIndex - 1 );
+              bottomRange = new SelectionRange( startIndex + offset, currentRange.EndIndex + offset );
             }
           }
 
           object[] topItems = null;
           object[] bottomItems = null;
 
-          if( originalItems != null )
+          if( currentRangeItems != null )
           {
             topItems = new object[ topRange.Length ];
-            Array.Copy( originalItems, 0, topItems, 0, topItems.Length );
+            Array.Copy( currentRangeItems, 0, topItems, 0, topItems.Length );
+
             bottomItems = new object[ bottomRange.Length ];
-            Array.Copy( originalItems, topItems.Length, bottomItems, 0, bottomItems.Length );
+            Array.Copy( currentRangeItems, topItems.Length, bottomItems, 0, bottomItems.Length );
           }
 
-          m_list[ i ] = new SelectionRangeWithItems( topRange, topItems );
-          m_list.Insert( i + 1, new SelectionRangeWithItems( bottomRange, bottomItems ) );
+          this[ currentRangeIndex ] = new SelectionRangeWithItems( topRange, topItems );
+          this.Insert( currentRangeIndex + 1, new SelectionRangeWithItems( bottomRange, bottomItems ), true );
         }
+        // The range is greater.
         else
         {
-          // Offset the index by the count added
-          SelectionRange newRange = new SelectionRange( range.StartIndex + offset, range.EndIndex + offset );
-          m_list[ i ] = new SelectionRangeWithItems( newRange, originalItems );
+          this[ currentRangeIndex ] = new SelectionRangeWithItems(
+                                        new SelectionRange( currentRange.StartIndex + offset, currentRange.EndIndex + offset ),
+                                        currentRangeItems );
         }
       }
     }
@@ -459,19 +355,22 @@ namespace Xceed.Wpf.DataGrid
       if( m_dataGridContext == null )
         throw new InvalidOperationException( "We must have a DataGridContext to find the new index." );
 
-      CollectionView sourceItems = m_dataGridContext.Items;
+      if( maxOffset == 0 )
+        return;
+
+      var sourceItems = m_dataGridContext.Items;
 
       for( int i = this.Count - 1; i >= 0; i-- )
       {
-        SelectionRangeWithItems rangeWithItems = m_list[ i ];
-        object[] items = rangeWithItems.Items;
+        var rangeWithItems = this[ i ];
+        var rangeItems = rangeWithItems.Items;
 
-        if( items == null )
+        if( rangeItems == null )
           throw new InvalidOperationException( "We should have items to find the new index." );
 
-        object item = items[ 0 ];
-        SelectionRange range = rangeWithItems.Range;
-        int startIndex = Math.Min( range.StartIndex, range.EndIndex );
+        var item = rangeItems[ 0 ];
+        var range = rangeWithItems.Range;
+        var startIndex = range.StartIndex;
 
         if( maxOffset < 0 )
         {
@@ -481,8 +380,7 @@ namespace Xceed.Wpf.DataGrid
             {
               if( j != 0 )
               {
-                SelectionRange newRange = new SelectionRange( range.StartIndex + j, range.EndIndex + j );
-                m_list[ i ] = new SelectionRangeWithItems( newRange, items );
+                this[ i ] = new SelectionRangeWithItems( new SelectionRange( range.StartIndex + j, range.EndIndex + j ), rangeItems );
               }
 
               break;
@@ -496,7 +394,7 @@ namespace Xceed.Wpf.DataGrid
         }
         else
         {
-          int sourceItemCount = sourceItems.Count;
+          var sourceItemCount = sourceItems.Count;
 
           for( int j = 0; j <= maxOffset; j++ )
           {
@@ -504,8 +402,7 @@ namespace Xceed.Wpf.DataGrid
             {
               if( j != 0 )
               {
-                SelectionRange newRange = new SelectionRange( range.StartIndex + j, range.EndIndex + j );
-                m_list[ i ] = new SelectionRangeWithItems( newRange, items );
+                this[ i ] = new SelectionRangeWithItems( new SelectionRange( range.StartIndex + j, range.EndIndex + j ), rangeItems );
               }
 
               break;
@@ -520,10 +417,414 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion PUBLIC METHODS
+    private void Insert( int index, SelectionRangeWithItems item, bool repairIndex )
+    {
+      var wrapper = new SelectionRangeWithItemsWrapper( item, index );
 
-    private List<SelectionRangeWithItems> m_list;
-    private DataGridContext m_dataGridContext;
-    private int m_itemsCount;
+      m_unsortedRanges.Insert( index, wrapper );
+
+      if( repairIndex )
+      {
+        this.RepairIndex( index + 1 );
+      }
+
+      if( !item.IsEmpty )
+      {
+        var insertionIndex = ~this.FindIndex( new ItemComparer( wrapper ) );
+        Debug.Assert( insertionIndex >= 0 );
+
+        m_sortedRanges.Insert( insertionIndex, wrapper );
+      }
+    }
+
+    private void RemoveAt( int index, bool repairIndex )
+    {
+      var wrapper = m_unsortedRanges[ index ];
+      Debug.Assert( wrapper.Index == index );
+
+      if( !wrapper.Value.IsEmpty )
+      {
+        var removalIndex = this.FindIndex( new ItemComparer( wrapper ) );
+        Debug.Assert( removalIndex >= 0 );
+
+        m_sortedRanges.RemoveAt( removalIndex );
+      }
+
+      m_unsortedRanges.RemoveAt( index );
+
+      if( repairIndex )
+      {
+        this.RepairIndex( index );
+      }
+    }
+
+    private void RepairIndex( int index )
+    {
+      Debug.Assert( index >= 0 );
+
+      for( int i = index; i < m_unsortedRanges.Count; i++ )
+      {
+        m_unsortedRanges[ i ].Index = i;
+      }
+    }
+
+    private bool RemoveEmptyRange( SelectionRangeWithItems rangeWithItems )
+    {
+      Debug.Assert( rangeWithItems.IsEmpty );
+
+      bool removed = false;
+
+      var itemsToRemove = rangeWithItems.Items;
+      var itemsToRemoveCount = ( itemsToRemove == null ) ? 0 : itemsToRemove.Length;
+      var itemOffsetToRemove = 0;
+
+      do
+      {
+        for( int i = this.Count - 1; i >= 0; i-- )
+        {
+          var currentRangeWithItems = this[ i ];
+          var currentRange = currentRangeWithItems.Range;
+
+          var itemOffset = Array.IndexOf( currentRangeWithItems.Items, itemsToRemove[ itemOffsetToRemove ] );
+          if( itemOffset == -1 )
+            continue;
+
+          var overlap = new SelectionRange( currentRange.GetIndexFromItemOffset( itemOffset ) );
+
+          removed = true;
+          m_itemsCount -= overlap.Length;
+
+          var newRanges = currentRange.Exclude( overlap );
+
+          if( newRanges.Length == 0 )
+          {
+            this.RemoveAt( i, true );
+          }
+          else
+          {
+            this[ i ] = new SelectionRangeWithItems( newRanges[ 0 ], currentRangeWithItems.GetItems( newRanges[ 0 ] ) );
+
+            if( newRanges.Length > 1 )
+            {
+              Debug.Assert( newRanges.Length == 2 );
+              this.Insert( i + 1, new SelectionRangeWithItems( newRanges[ 1 ], currentRangeWithItems.GetItems( newRanges[ 1 ] ) ), true );
+            }
+          }
+        }
+
+        itemOffsetToRemove++;
+      }
+      while( itemOffsetToRemove < itemsToRemoveCount );
+
+      return removed;
+    }
+
+    private bool RemoveRangeWithItems( SelectionRangeWithItems rangeWithItems )
+    {
+      Debug.Assert( !rangeWithItems.IsEmpty );
+
+      var rangeToRemove = rangeWithItems.Range;
+      var matches = this.IndexOfOverlap( rangeWithItems ).OrderBy( item => item ).ToList();
+
+      for( int i = matches.Count - 1; i >= 0; i-- )
+      {
+        var index = matches[ i ];
+        var currentRangeWithItems = this[ index ];
+        var currentRange = currentRangeWithItems.Range;
+        var overlap = rangeToRemove.Intersect( currentRange );
+
+        Debug.Assert( !overlap.IsEmpty );
+
+        m_itemsCount -= overlap.Length;
+
+        var newRanges = currentRange.Exclude( overlap );
+
+        if( newRanges.Length == 0 )
+        {
+          this.RemoveAt( index, true );
+        }
+        else
+        {
+          this[ index ] = new SelectionRangeWithItems( newRanges[ 0 ], currentRangeWithItems.GetItems( newRanges[ 0 ] ) );
+
+          if( newRanges.Length > 1 )
+          {
+            Debug.Assert( newRanges.Length == 2 );
+            this.Insert( index + 1, new SelectionRangeWithItems( newRanges[ 1 ], currentRangeWithItems.GetItems( newRanges[ 1 ] ) ), true );
+          }
+        }
+      }
+
+      return ( matches.Count > 0 );
+    }
+
+    private IEnumerable<int> IndexOfOverlap( SelectionRangeWithItems rangeWithItems )
+    {
+      if( rangeWithItems.IsEmpty )
+        yield break;
+
+      var targetRange = rangeWithItems.Range;
+      var comparer = new RangeComparer( targetRange );
+
+      var index = this.FindIndex( comparer );
+      if( index < 0 )
+        yield break;
+
+      while( index > 0 )
+      {
+        if( comparer.Compare( m_sortedRanges[ index - 1 ] ) != 0 )
+          break;
+
+        index--;
+      }
+
+      for( int i = index; i < m_sortedRanges.Count; i++ )
+      {
+        var wrapper = m_sortedRanges[ i ];
+        if( comparer.Compare( wrapper ) != 0 )
+          break;
+
+        var currentRangeWithItems = wrapper.Value;
+        var overlap = targetRange.Intersect( currentRangeWithItems.Range );
+
+        if( !overlap.IsEmpty && ( rangeWithItems.IsItemsEqual( overlap, currentRangeWithItems ) ) )
+          yield return wrapper.Index;
+      }
+    }
+
+    private int FindIndex( ISelectionRangeComparer comparer )
+    {
+      Debug.Assert( comparer != null );
+
+      var lowerBound = 0;
+      var upperBound = m_sortedRanges.Count - 1;
+
+      while( lowerBound <= upperBound )
+      {
+        var middle = lowerBound + ( upperBound - lowerBound ) / 2;
+        var compare = comparer.Compare( m_sortedRanges[ middle ] );
+
+        if( compare < 0 )
+        {
+          if( middle == lowerBound )
+            return ~middle;
+
+          upperBound = middle - 1;
+        }
+        else if( compare > 0 )
+        {
+          if( middle == upperBound )
+            return ~( middle + 1 );
+
+          lowerBound = middle + 1;
+        }
+        else
+        {
+          return middle;
+        }
+      }
+
+      return ~0;
+    }
+
+    #region ICloneable Members
+
+    public object Clone()
+    {
+      var copy = new SelectedItemsStorage( m_dataGridContext );
+
+      for( int i = 0; i < m_unsortedRanges.Count; i++ )
+      {
+        copy.Insert( i, m_unsortedRanges[ i ].Value, false );
+      }
+
+      copy.m_itemsCount = m_itemsCount;
+
+      return copy;
+    }
+
+    #endregion
+
+    #region IEnumerable<SelectionRangeWithItems> Members
+
+    public IEnumerator<SelectionRangeWithItems> GetEnumerator()
+    {
+      return m_unsortedRanges.Select( item => item.Value ).GetEnumerator();
+    }
+
+    #endregion
+
+    #region IEnumerable Members
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+      return this.GetEnumerator();
+    }
+
+    #endregion
+
+    #region Private Fields
+
+    private readonly List<SelectionRangeWithItemsWrapper> m_unsortedRanges = new List<SelectionRangeWithItemsWrapper>();
+    private readonly List<SelectionRangeWithItemsWrapper> m_sortedRanges = new List<SelectionRangeWithItemsWrapper>();
+
+    #endregion
+
+    #region SelectionRangeWithItemsWrapper Private Class
+
+    // We are wrapping the SelectionRangeWithItems structure inside a class so our collections
+    // may target the same object.
+    private sealed class SelectionRangeWithItemsWrapper
+    {
+      internal SelectionRangeWithItemsWrapper( SelectionRangeWithItems value, int index )
+      {
+        m_value = value;
+        m_index = index;
+      }
+
+      internal SelectionRangeWithItems Value
+      {
+        get
+        {
+          return m_value;
+        }
+      }
+
+      internal int Index
+      {
+        get
+        {
+          return m_index;
+        }
+        set
+        {
+          m_index = value;
+        }
+      }
+
+      private readonly SelectionRangeWithItems m_value;
+      private int m_index;
+    }
+
+    #endregion
+
+    #region ISelectionRangeComparer Private Interface
+
+    private interface ISelectionRangeComparer
+    {
+      int Compare( SelectionRangeWithItemsWrapper item );
+    }
+
+    #endregion
+
+    #region ItemComparer Private Class
+
+    private sealed class ItemComparer : ISelectionRangeComparer
+    {
+      internal ItemComparer( SelectionRangeWithItemsWrapper target )
+      {
+        if( target == null )
+          throw new ArgumentNullException( "target" );
+
+        if( target.Value.IsEmpty )
+          throw new ArgumentException( "The selection range must not be empty.", "target" );
+
+        m_target = target;
+      }
+
+      public int Compare( SelectionRangeWithItemsWrapper item )
+      {
+        if( item == m_target )
+          return 0;
+
+        var xr = m_target.Value.Range;
+        var yr = item.Value.Range;
+
+        int xs, xe, ys, ye;
+        ItemComparer.GetBounds( xr, out xs, out xe );
+        ItemComparer.GetBounds( yr, out ys, out ye );
+
+        if( xs < ys )
+        {
+          Debug.Assert( RangeComparer.Compare( xr, item ) <= 0 );
+          return -1;
+        }
+        else if( xs > ys )
+        {
+          Debug.Assert( RangeComparer.Compare( xr, item ) >= 0 );
+          return 1;
+        }
+
+        Debug.Assert( RangeComparer.Compare( xr, item ) == 0 );
+
+        if( xe < ye )
+        {
+          return -1;
+        }
+        else if( xe > ye )
+        {
+          return 1;
+        }
+
+        Debug.Assert( xr == yr );
+
+        return ( m_target.Index - item.Index );
+      }
+
+      private static void GetBounds( SelectionRange range, out int startIndex, out int endIndex )
+      {
+        if( range.StartIndex <= range.EndIndex )
+        {
+          startIndex = range.StartIndex;
+          endIndex = range.EndIndex;
+        }
+        else
+        {
+          endIndex = range.StartIndex;
+          startIndex = range.EndIndex;
+        }
+      }
+
+      private readonly SelectionRangeWithItemsWrapper m_target;
+    }
+
+    #endregion
+
+    #region RangeComparer Private Class
+
+    private sealed class RangeComparer : ISelectionRangeComparer
+    {
+      internal RangeComparer( SelectionRange target )
+      {
+        if( target.IsEmpty )
+          throw new ArgumentException( "The selection range must not be empty.", "target" );
+
+        m_target = target;
+      }
+
+      public int Compare( SelectionRangeWithItemsWrapper item )
+      {
+        return RangeComparer.Compare( m_target, item );
+      }
+
+      internal static int Compare( SelectionRange range, SelectionRangeWithItemsWrapper wrapper )
+      {
+        var itemRange = wrapper.Value.Range;
+
+        if( range < itemRange )
+          return -1;
+
+        if( range > itemRange )
+          return 1;
+
+        Debug.Assert( !range.Intersect( itemRange ).IsEmpty );
+
+        return 0;
+      }
+
+      private readonly SelectionRange m_target;
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Settings/UserSettingsEnum.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionChangedInternalEventArgs.cs
similarity index 59%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Settings/UserSettingsEnum.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionChangedInternalEventArgs.cs
index d33ce024..128258f1 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Settings/UserSettingsEnum.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionChangedInternalEventArgs.cs
@@ -19,23 +19,20 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
-namespace Xceed.Wpf.DataGrid.Settings
+namespace Xceed.Wpf.DataGrid
 {
-  [Flags]
-  public enum UserSettings
+  internal class SelectionChangedInternalEventArgs : EventArgs
   {
-    None                    = 0x0000000,
 
-    ColumnWidths            = 0x0000001,
-    ColumnPositions         = 0x0000010,
-    ColumnVisibilities      = 0x0000100, 
+    public SelectionChangedInternalEventArgs(SelectionInfo selectionInfo)
+    {
+      this.SelectionInfo = selectionInfo;
+    }
 
-    FixedColumnCounts       = 0x0001000,
-    Sorting                 = 0x0010000,
-    Grouping                = 0x0100000,
-
-    CardWidths              = 0x1000000,
-
-    All                     = 0x1111111,
+    public SelectionInfo SelectionInfo
+    {
+      get;
+      private set;
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionChanger.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionChanger.cs
index b854c5f2..05698a9f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionChanger.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionChanger.cs
@@ -34,10 +34,10 @@ namespace Xceed.Wpf.DataGrid
     public SelectionChanger( DataGridContext owner )
     {
       m_owner = owner;
-      m_itemsToSelect = new SelectedItemsStorage( owner, 2 );
-      m_itemsToUnselect = new SelectedItemsStorage( owner, 2 );
-      m_cellsToSelect = new SelectedCellsStorage( owner, 2 );
-      m_cellsToUnselect = new SelectedCellsStorage( owner, 2 );
+      m_itemsToSelect = new SelectedItemsStorage( owner );
+      m_itemsToUnselect = new SelectedItemsStorage( owner );
+      m_cellsToSelect = new SelectedCellsStorage( owner );
+      m_cellsToUnselect = new SelectedCellsStorage( owner );
       m_toDeferSelect = new List<object>( 1 );
       m_sourceChanges = new List<SourceChangeInfo>( 2 );
     }
@@ -102,7 +102,7 @@ namespace Xceed.Wpf.DataGrid
       {
         bool selectionChanged = m_itemsToUnselect.Remove( rangeWithItems );
 
-        SelectedItemsStorage tempStorage = new SelectedItemsStorage( m_owner, 8 );
+        SelectedItemsStorage tempStorage = new SelectedItemsStorage( m_owner );
         tempStorage.Add( rangeWithItems );
 
         // Remove the currently selected item from the new range to select
@@ -157,7 +157,7 @@ namespace Xceed.Wpf.DataGrid
       {
         bool selectionChanged = m_cellsToUnselect.Remove( cellRangeWithItems );
 
-        SelectedCellsStorage tempStorage = new SelectedCellsStorage( m_owner, 8 );
+        SelectedCellsStorage tempStorage = new SelectedCellsStorage( m_owner );
         tempStorage.Add( cellRangeWithItems );
 
         // Remove the currently selected item from the new range to select
@@ -285,7 +285,7 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        SelectedItemsStorage tempStorage = new SelectedItemsStorage( m_owner, 8 );
+        SelectedItemsStorage tempStorage = new SelectedItemsStorage( m_owner );
         tempStorage.Add( rangeWithItems );
 
         // Remove the currently selected item from the new range to select
@@ -413,7 +413,7 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
-        SelectedCellsStorage tempStorage = new SelectedCellsStorage( m_owner, 8 );
+        SelectedCellsStorage tempStorage = new SelectedCellsStorage( m_owner );
         tempStorage.Add( cellRangeWithItems );
 
         // Remove the currently selected item from the new range to select
@@ -550,7 +550,7 @@ namespace Xceed.Wpf.DataGrid
 
       // Remove all currently selected Cells from the new selectionRange
       // to avoid duplicate SelectionCellRange
-      SelectedCellsStorage tempStorage = new SelectedCellsStorage( null, 1 );
+      SelectedCellsStorage tempStorage = new SelectedCellsStorage( null );
       tempStorage.Add( rangeWithItemsToSelect );
 
       for( int i = 0; i < selectedCellsInChange.Count; i++ )
@@ -598,7 +598,7 @@ namespace Xceed.Wpf.DataGrid
         {
           foreach( SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange )
           {
-            tempStorage = new SelectedCellsStorage( null, 1 );
+            tempStorage = new SelectedCellsStorage( null );
             tempStorage.Add( selectedCellRangeWithItems );
             tempStorage.Remove( rangeWithItemsToSelect );
             tempStorageCount = tempStorage.Count;
@@ -1012,8 +1012,8 @@ namespace Xceed.Wpf.DataGrid
       List<SelectionCellRangeWithItems> removedCellsRangeWithItems;
       List<SelectionCellRangeWithItems> unselectedCellsFromRemove = this.GetUnselectedCellsFromRemove( out removedCellsRangeWithItems );
 
-      SelectedItemsStorage itemsToUnselect = new SelectedItemsStorage( m_itemsToUnselect );
-      SelectedCellsStorage cellsToUnselect = new SelectedCellsStorage( m_cellsToUnselect );
+      SelectedItemsStorage itemsToUnselect = ( SelectedItemsStorage )m_itemsToUnselect.Clone();
+      SelectedCellsStorage cellsToUnselect = ( SelectedCellsStorage )m_cellsToUnselect.Clone();
 
       foreach( SelectionRangeWithItems rangeWithItems in unselectedItemsFromRemove )
       {
@@ -1026,8 +1026,8 @@ namespace Xceed.Wpf.DataGrid
       }
 
       return new SelectionInfo(
-        m_owner, itemsToUnselect, new SelectedItemsStorage( m_itemsToSelect ),
-        cellsToUnselect, new SelectedCellsStorage( m_cellsToSelect ) );
+        m_owner, itemsToUnselect, ( SelectedItemsStorage )m_itemsToSelect.Clone(),
+        cellsToUnselect, ( SelectedCellsStorage )m_cellsToSelect.Clone() );
     }
 
     #endregion PUBLIC METHODS
@@ -1093,7 +1093,7 @@ namespace Xceed.Wpf.DataGrid
 
         removedCellsRangeWithItems.Add( cellRangeWithItemsToRemove );
 
-        List<SelectionCellRangeWithItems> intersectedCellRangesWithItems =
+        IEnumerable<SelectionCellRangeWithItems> intersectedCellRangesWithItems =
           m_owner.SelectedCellsStore.GetIntersectedCellRangesWithItems( cellRangeWithItemsToRemove.CellRange );
 
         foreach( SelectionCellRangeWithItems cellRangeWithItems in intersectedCellRangesWithItems )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionManager.cs
index 34befa1f..861900b8 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionManager.cs
@@ -36,6 +36,7 @@ namespace Xceed.Wpf.DataGrid
       MouseUp = 2,
       SpaceDown = 3,
       RowSelector = 4,
+      MouseMove = 5,
       None = 99
     }
 
@@ -171,9 +172,16 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
+    public bool ToggleItemSelection( SelectionRangePoint rangePosition )
+    {
+      return this.ToggleItemSelection( 
+        rangePosition.DataGridContext, 
+        rangePosition.ItemIndex, rangePosition.Item );
+    }
+
     public bool ToggleItemSelection( DataGridContext context, int itemIndex, object item )
     {
-      if( context.SelectedItemsStore.Contains( itemIndex ) )
+      if( this.IsItemSelected( context, itemIndex ) )
       {
         return this.UnselectItems( context, new SelectionRangeWithItems( itemIndex, item ) );
       }
@@ -185,7 +193,7 @@ namespace Xceed.Wpf.DataGrid
 
     public bool ToggleCellSelection( DataGridContext context, int itemIndex, object item, int columnIndex )
     {
-      if( context.SelectedCellsStore.Contains( itemIndex, columnIndex ) )
+      if( this.IsCellSelected( context, itemIndex, columnIndex) )
       {
         return this.UnselectCells( context, new SelectionCellRangeWithItems( itemIndex, item, columnIndex ) );
       }
@@ -200,40 +208,11 @@ namespace Xceed.Wpf.DataGrid
       int itemIndex,
       object item )
     {
-      SelectionRange itemRange = new SelectionRange( itemIndex );
-
-      SelectionRange cellRange = new SelectionRange( 0,
-        Math.Max( 0, dataGridContext.Columns.Count - 1 ) );
-
-      // Select all visible cells for this itemIndex
-      SelectionCellRangeWithItems selection = new SelectionCellRangeWithItems( itemRange,
-        new object[] { item },
-        cellRange );
-
-      SelectedCellsStorage tempStorage = new SelectedCellsStorage( null, 1 );
-      tempStorage.Add( selection );
-
-      foreach( ColumnBase column in dataGridContext.ColumnsByVisiblePosition )
-      {
-        if( !column.Visible )
-          tempStorage.Remove( new SelectionCellRangeWithItems( itemIndex, item, column.VisiblePosition ) );
-      }
-
-      int tempStorageCount = tempStorage.Count;
-      bool allCellSelected = true;
-
-      foreach( SelectionCellRangeWithItems allCellSelection in tempStorage )
-      {
-        if( !dataGridContext.SelectedCellsStore.Contains( allCellSelection ) )
-        {
-          allCellSelected = false;
-          break;
-        }
-      }
+      SelectedCellsStorage tempStorage = this.GetItemCellStorage( dataGridContext, itemIndex, item );
 
       bool selectionDone = true;
 
-      if( allCellSelected )
+      if( this.IsItemCellsSelected( dataGridContext, tempStorage ) )
       {
         foreach( SelectionCellRangeWithItems allCellSelection in tempStorage )
         {
@@ -257,6 +236,11 @@ namespace Xceed.Wpf.DataGrid
       return selectionChanger.SelectCells( cellRangeWithItems );
     }
 
+    public bool SelectItems( SelectionRangePoint position )
+    {
+      return this.SelectItems( position.DataGridContext, position.ToSelectionRangeWithItems() );
+    }
+
     public bool SelectItems( DataGridContext dataGridContext, SelectionRangeWithItems rangeWithItems )
     {
       SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext );
@@ -331,6 +315,20 @@ namespace Xceed.Wpf.DataGrid
       return selected;
     }
 
+    public bool SelectJustThisItem( SelectionRangePoint point )
+    {
+      bool selected = false;
+
+      var item = point.Item;
+      var itemIndex = point.ItemIndex;
+      if( itemIndex != -1 )
+      {
+        selected = this.SelectJustThisItem( point.DataGridContext, itemIndex, item );
+      }
+
+      return selected;
+    }
+
     public bool SelectJustThisItem( DataGridContext dataGridContext, int itemIndex, object item )
     {
       bool selected = false;
@@ -480,8 +478,7 @@ namespace Xceed.Wpf.DataGrid
               // there is any changes to the selection.  This is usefull when resetting due to a Sort operation for instance.
               this.EnsureRootSelectedItemAndSelectedIndex();
 
-              m_rangeSelectionItemStartAnchor = -1;
-              m_rangeSelectionColumnStartAnchor = -1;
+              m_selectionRangeStartPoint = null;
               SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext );
               selectionChanger.UpdateSelectionAfterSourceDataItemAdded( e );
             }
@@ -504,8 +501,7 @@ namespace Xceed.Wpf.DataGrid
               // there is any changes to the selection.  This is usefull when resetting due to a Sort operation for instance.
               this.EnsureRootSelectedItemAndSelectedIndex();
 
-              m_rangeSelectionItemStartAnchor = -1;
-              m_rangeSelectionColumnStartAnchor = -1;
+              m_selectionRangeStartPoint = null;
               SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext );
               selectionChanger.UpdateSelectionAfterSourceDataItemRemoved( e );
             }
@@ -529,8 +525,7 @@ namespace Xceed.Wpf.DataGrid
               // there is any changes to the selection.  This is usefull when resetting due to a Sort operation for instance.
               this.EnsureRootSelectedItemAndSelectedIndex();
 
-              m_rangeSelectionItemStartAnchor = -1;
-              m_rangeSelectionColumnStartAnchor = -1;
+              m_selectionRangeStartPoint = null;
 
               SelectedItemsStorage selectedItemsStorage = dataGridContext.SelectedItemsStore;
               int selectedItemsCount = selectedItemsStorage.Count;
@@ -651,20 +646,13 @@ namespace Xceed.Wpf.DataGrid
     }
 
     public void UpdateSelection(
-      DataGridContext oldCurrentDataGridContext,
-      object oldCurrentItem,
-      ColumnBase oldCurrentColumn,
-      DataGridContext dataGridContext,
+      SelectionRangePoint oldPosition,
+      SelectionRangePoint newPosition,
       bool oldFocusWasInTheGrid,
       bool rowIsBeingEditedAndCurrentRowNotChanged,
-      int sourceDataItemIndex,
-      object item,
-      int columnIndex,
       Nullable<UpdateSelectionSource> updateSelectionSourceParam )
     {
-      int oldCurrentColumnIndex = ( oldCurrentColumn == null ) ? -1 : oldCurrentColumn.VisiblePosition;
-
-      if( item == null )
+      if( newPosition == null )
         return;
 
       UpdateSelectionSource updateSelectionSource = ( updateSelectionSourceParam.HasValue )
@@ -675,7 +663,8 @@ namespace Xceed.Wpf.DataGrid
       this.EnsureNodeTreeCreatedOnAllSubContext( m_owner.DataGridContext );
 
       if( ( updateSelectionSource != UpdateSelectionSource.RowSelector )
-          && ( updateSelectionSource != UpdateSelectionSource.MouseUp ) )
+          && ( updateSelectionSource != UpdateSelectionSource.MouseUp )
+          && ( updateSelectionSource != UpdateSelectionSource.MouseMove ) )
       {
         // Reset the fromRowSelector to ensure nothing special is done
         // on next MouseUp
@@ -694,8 +683,8 @@ namespace Xceed.Wpf.DataGrid
           case SelectionMode.Single:
             {
               this.DoSingleSelection(
-                dataGridContext, oldFocusWasInTheGrid, rowIsBeingEditedAndCurrentRowNotChanged,
-                sourceDataItemIndex, item, columnIndex, updateSelectionSource );
+                newPosition, 
+                oldFocusWasInTheGrid, rowIsBeingEditedAndCurrentRowNotChanged, updateSelectionSource );
 
               break;
             }
@@ -703,8 +692,7 @@ namespace Xceed.Wpf.DataGrid
           case SelectionMode.Multiple:
             {
               this.DoMultipleSelection(
-                dataGridContext, rowIsBeingEditedAndCurrentRowNotChanged,
-                sourceDataItemIndex, item, columnIndex, updateSelectionSource );
+                newPosition, rowIsBeingEditedAndCurrentRowNotChanged, updateSelectionSource );
 
               break;
             }
@@ -712,9 +700,8 @@ namespace Xceed.Wpf.DataGrid
           case SelectionMode.Extended:
             {
               this.DoExtendedSelection(
-                oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                dataGridContext, oldFocusWasInTheGrid, rowIsBeingEditedAndCurrentRowNotChanged,
-                sourceDataItemIndex, item, columnIndex, updateSelectionSource );
+                oldPosition, newPosition,
+                oldFocusWasInTheGrid, rowIsBeingEditedAndCurrentRowNotChanged, updateSelectionSource );
 
               break;
             }
@@ -744,145 +731,100 @@ namespace Xceed.Wpf.DataGrid
     }
 
     private void DoSingleSelection(
-      DataGridContext dataGridContext,
+      SelectionRangePoint newPosition,
       bool oldFocusWasInTheGrid,
       bool rowIsBeingEditedAndCurrentRowNotChanged,
-      int sourceDataItemIndex,
-      object item,
-      int columnIndex,
       UpdateSelectionSource updateSelectionSource )
     {
-      bool doSelection = false;
+
+      //Group selection is not valid in single selection mode.
+      if( newPosition == null )
+        return;
+
+      bool applySelection = true;
 
       if( updateSelectionSource == UpdateSelectionSource.Navigation )
       {
-        if( oldFocusWasInTheGrid )
-        {
-          if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.None )
-          {
-            doSelection = true;
-          }
-          else //this means that CTRL was pressed
-          {
-            //if PageUp or PageDown or Home or End are pressed, it means its page navigation and in this case, I want to do SingleSelection
-            if( Keyboard.IsKeyDown( Key.PageUp )
+        bool isPageKeys = Keyboard.IsKeyDown( Key.PageUp )
               || Keyboard.IsKeyDown( Key.PageDown )
               || Keyboard.IsKeyDown( Key.End )
-              || Keyboard.IsKeyDown( Key.Home ) )
-            {
-              doSelection = true;
-            }
-          }
+              || Keyboard.IsKeyDown( Key.Home );
+
+        bool isCtrlPressed = ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control;
+
+        //Special cases where selection should not be applied:
+        //1. Focus was not in the datagrid
+        //2. Ctrl is pressed but not the "page keys".
+        if(!oldFocusWasInTheGrid || (isCtrlPressed && !isPageKeys))
+        {
+          applySelection = false;
         }
       }
-      else
-      {
-        doSelection = true;
-      }
 
       // Special case for RowSelector : We do not want the
       // MouseUp to clear the Selection when it was just set
       // by the RowSelector
-      if( updateSelectionSource == UpdateSelectionSource.RowSelector )
-      {
-        m_fromRowSelector = true;
-      }
-
-      if( !doSelection )
-        return;
+      m_fromRowSelector |= ( updateSelectionSource == UpdateSelectionSource.RowSelector );
 
-      if( m_owner.SelectionUnit == SelectionUnit.Row )
-      {
-        if( sourceDataItemIndex != -1 )
-        {
-          this.SelectJustThisItem( dataGridContext, sourceDataItemIndex, item );
-        }
-        else
-        {
-          this.UnselectAll();
-        }
-      }
-      else
+      if( applySelection )
       {
-        if( ( sourceDataItemIndex != -1 ) && ( columnIndex != -1 ) )
-        {
-          this.SelectJustThisCell( dataGridContext, sourceDataItemIndex, item, columnIndex );
-        }
-        else
-        {
-          // Do not remove selection when it comes from the RowSelector
-          if( !m_fromRowSelector )
-          {
-            this.UnselectAll();
-          }
-        }
+        //Handle the case where the selected item is not a datarow/cell.
+        bool isValid = ( m_owner.SelectionUnit == SelectionUnit.Row )
+          ? ( newPosition.ItemIndex != -1 )
+          : ( newPosition.ItemIndex != -1 ) && ( newPosition.ColumnIndex != -1 );
+
+        // In cell selection, Do not remove selection when it comes from the RowSelector
+        bool cellSelection = ( m_owner.SelectionUnit == SelectionUnit.Cell );
+
+        this.ApplySelection( null, newPosition, m_fromRowSelector, isValid,
+          doRangeSelection: false,
+          allowRangeUnselection:false,
+          toggleSelection: false,
+          keepSelection: m_fromRowSelector && cellSelection );
       }
     }
 
     private void DoMultipleSelection(
-      DataGridContext dataGridContext,
+      SelectionRangePoint newPosition,
       bool rowIsBeingEditedAndCurrentRowNotChanged,
-      int sourceDataItemIndex,
-      object item,
-      int columnIndex,
       UpdateSelectionSource updateSelectionSource )
     {
+      if( newPosition == null )
+        return;
+
+      bool applySelection = true;
+      bool fromRowSelector = ( updateSelectionSource == UpdateSelectionSource.RowSelector ) || m_fromRowSelector;
+      bool toggleSelection = true;
+
+      //Handle the case where the selected item is not a datarow/cell.
+      bool isValid = ( m_owner.SelectionUnit == SelectionUnit.Row ) || fromRowSelector
+        ? ( newPosition.ItemIndex != -1 )
+        : ( newPosition.ItemIndex != -1 ) && ( newPosition.ColumnIndex != -1 );
+
       switch( updateSelectionSource )
       {
+        case UpdateSelectionSource.RowSelector:
+          {
+            m_fromRowSelector = true;
+            goto case UpdateSelectionSource.MouseDown;
+          }
         case UpdateSelectionSource.MouseDown:
           {
-            if( m_owner.SelectionUnit == SelectionUnit.Row )
-            {
-              if( sourceDataItemIndex != -1 )
-              {
-                // this.Select return false when the item is already selected.
-                m_updateSelectionOnNextMouseUp = !this.SelectItems(
-                  dataGridContext, new SelectionRangeWithItems( sourceDataItemIndex, item ) );
-              }
-            }
-            else
+            m_updateSelectionOnNextMouseUp =
+              newPosition.GetIsSelected( m_owner.SelectionUnit );
+
+            if( m_updateSelectionOnNextMouseUp )
             {
-              if( ( sourceDataItemIndex != -1 ) && ( columnIndex != -1 ) )
-              {
-                // this.Select return false when the cell is already selected.
-                m_updateSelectionOnNextMouseUp = !this.SelectCells(
-                  dataGridContext, new SelectionCellRangeWithItems( sourceDataItemIndex, item, columnIndex ) );
-              }
+              applySelection = false;
             }
-
             break;
           }
 
         case UpdateSelectionSource.MouseUp:
           {
-            if( ( m_updateSelectionOnNextMouseUp ) && ( !rowIsBeingEditedAndCurrentRowNotChanged ) )
+            if( !isValid || !m_updateSelectionOnNextMouseUp || rowIsBeingEditedAndCurrentRowNotChanged )
             {
-              if( m_owner.SelectionUnit == SelectionUnit.Row )
-              {
-                if( sourceDataItemIndex != -1 )
-                {
-                  this.ToggleItemSelection( dataGridContext, sourceDataItemIndex, item );
-                }
-              }
-              else
-              {
-                if( sourceDataItemIndex != -1 )
-                {
-                  if( m_fromRowSelector )
-                  {
-                    this.ToggleItemCellsSelection( dataGridContext,
-                      sourceDataItemIndex,
-                      item );
-                  }
-                  else if( columnIndex != -1 )
-                  {
-                    this.ToggleCellSelection( dataGridContext,
-                      sourceDataItemIndex,
-                      item,
-                      columnIndex );
-                  }
-                }
-              }
+              applySelection = false;
             }
 
             // Reset the fromRowSelector to ensure nothing special is done
@@ -897,362 +839,196 @@ namespace Xceed.Wpf.DataGrid
 
         case UpdateSelectionSource.SpaceDown:
           {
-            if( m_owner.SelectionUnit == SelectionUnit.Row )
-            {
-              if( sourceDataItemIndex != -1 )
-              {
-                this.ToggleItemSelection( dataGridContext, sourceDataItemIndex, item );
-              }
-            }
-            else
-            {
-              if( ( sourceDataItemIndex != -1 ) && ( columnIndex != -1 ) )
-              {
-                this.ToggleCellSelection( dataGridContext,
-                  sourceDataItemIndex,
-                  item,
-                  columnIndex );
-              }
-            }
-
             break;
           }
-        case UpdateSelectionSource.RowSelector:
+        case UpdateSelectionSource.MouseMove:
           {
-            m_fromRowSelector = true;
-
-            // We must raise the same flags as in the MouseDown to ensure
-            // the MouseUp is correctly handled
-            if( m_owner.SelectionUnit == SelectionUnit.Row )
-            {
-              if( sourceDataItemIndex != -1 )
-              {
-                // this.Select return false when the item is already selected.
-                m_updateSelectionOnNextMouseUp = !this.SelectItems(
-                  dataGridContext, new SelectionRangeWithItems( sourceDataItemIndex, item ) );
-              }
-            }
-            else
-            {
-              if( ( sourceDataItemIndex != -1 ) && ( columnIndex != -1 ) )
-              {
-                // this.Select return false when the cell is already selected.
-                m_updateSelectionOnNextMouseUp = !this.SelectItemCells( dataGridContext,
-                  sourceDataItemIndex,
-                  item,
-                  true );
-              }
-            }
+            //This is no "unselection" or "toggle" when doing drag selection.
+            toggleSelection = false;
+            break;
+          }
 
+        default:
+          {
+            //Fallback for "None", "Navigation" or other futur cases:
+            applySelection = false;
             break;
           }
       }
+
+      if( applySelection )
+      {
+        //Never do range selections, Always keep selection, always toggle.
+        this.ApplySelection( null, newPosition,
+          fromRowSelector, isValid, 
+          doRangeSelection:false, 
+          allowRangeUnselection:false,
+          toggleSelection:toggleSelection, 
+          keepSelection:true );
+      }
     }
 
     private void DoExtendedSelection(
-      DataGridContext oldCurrentDataGridContext,
-      object oldCurrentItem,
-      int oldCurrentColumnIndex,
-      DataGridContext dataGridContext,
+      SelectionRangePoint oldPosition,
+      SelectionRangePoint newPosition,
       bool oldFocusWasInTheGrid,
       bool rowIsBeingEditedAndCurrentRowNotChanged,
-      int sourceDataItemIndex,
-      object item,
-      int columnIndex,
       UpdateSelectionSource updateSelectionSource )
     {
+      if( newPosition == null )
+        return;
+
+      DataGridContext dataGridContext = newPosition.DataGridContext;
+      object item = newPosition.Item;
+      int sourceDataItemIndex = newPosition.ItemIndex;
+      int columnIndex = newPosition.ColumnIndex;
+
+      bool shift = ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift;
+      bool ctrl = ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control;
+
+      //Default behavior
+      //Ctrl : Keep the current selection
+      //Shift : Do a range selection and Do not update the selection anchor.
+      //Ctrl+!Shift: Toggle current.
+
+      bool keepSelection = ctrl;
+      bool toggleSelection = ctrl && !shift;
+      bool doRangeSelection = shift;
+      bool allowRangeUnselection = ctrl;
+      bool updateRangeStartPosition = !shift;
+      bool applySelection = true;
+      bool fromRowSelector = ( updateSelectionSource == UpdateSelectionSource.RowSelector ) || m_fromRowSelector;
+      bool cellSelection = ( m_owner.SelectionUnit == SelectionUnit.Cell );
+
+      //Handle the case where the selected item is not a datarow/cell.
+      bool isValid = ( m_owner.SelectionUnit == SelectionUnit.Row || fromRowSelector )
+        ? ( newPosition.ItemIndex != -1 )
+        : ( newPosition.ItemIndex != -1 ) && ( newPosition.ColumnIndex != -1 );
+
+      //Special case management in relation to update selection source
       switch( updateSelectionSource )
       {
         case UpdateSelectionSource.Navigation:
           {
-            if( oldFocusWasInTheGrid )
+            // Focus was not in the grid, do nothing.
+            if( !oldFocusWasInTheGrid )
             {
-              if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
-              {
-                if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-                {
-                  this.DoRangeSelection(
-                    oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                    dataGridContext, sourceDataItemIndex, item, columnIndex, true );
-                }
-                else
-                {
-                  m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-                  m_rangeSelectionColumnStartAnchor = columnIndex;
+              updateRangeStartPosition = false;
+              applySelection = false;
+              break;
+            }
 
-                  if( Keyboard.IsKeyDown( Key.PageUp )
-                    || Keyboard.IsKeyDown( Key.PageDown )
-                    || Keyboard.IsKeyDown( Key.End )
-                    || Keyboard.IsKeyDown( Key.Home ) )
-                  {
-                    if( m_owner.SelectionUnit == SelectionUnit.Row )
-                    {
-                      if( sourceDataItemIndex == -1 )
-                      {
-                        this.UnselectAll();
-                      }
-                      else
-                      {
-                        this.SelectJustThisItem( dataGridContext, sourceDataItemIndex, item );
-                      }
-                    }
-                    else
-                    {
-                      if( ( sourceDataItemIndex == -1 ) || ( columnIndex == -1 ) )
-                      {
-                        this.UnselectAll();
-                      }
-                      else
-                      {
-                        this.SelectJustThisCell( dataGridContext, sourceDataItemIndex, item, columnIndex );
-                      }
-                    }
-                  }
-                }
-              }
-              else if( ( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift ) && ( !Keyboard.IsKeyDown( Key.Tab ) ) )
+            // About every behavior of the selection is different in 
+            // keyboard navigation...
+
+            // Navigation never toggle. "Ctrl+Space" is the way
+            // to select with the keyboard
+            toggleSelection = false;
+
+            // Do not make range selection for the "Shift-Tab" case...
+            // Ignore the "Shift", just as it was not pressed.
+            if( Keyboard.IsKeyDown( Key.Tab ) )
+            {
+              shift = false;
+              doRangeSelection = false;
+            }
+
+            // Anchor also is keeped when Ctrl is pressed
+            updateRangeStartPosition = !ctrl && !shift;
+
+            // Ctrl + Page[Up/Down] and Ctrl+ [Home/End] are special ways
+            // to scroll using navigation, and does reset the selection.
+            if( !shift && ctrl )
+            {
+              if( Keyboard.IsKeyDown( Key.PageUp )
+                || Keyboard.IsKeyDown( Key.PageDown )
+                || Keyboard.IsKeyDown( Key.End )
+                || Keyboard.IsKeyDown( Key.Home ) )
               {
-                this.DoRangeSelection(
-                  oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                  dataGridContext, sourceDataItemIndex, item, columnIndex, false );
+                keepSelection = false;
               }
               else
               {
-                m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-                m_rangeSelectionColumnStartAnchor = columnIndex;
-
-                if( m_owner.SelectionUnit == SelectionUnit.Row )
-                {
-                  if( sourceDataItemIndex == -1 )
-                  {
-                    this.UnselectAll();
-                  }
-                  else
-                  {
-                    if( ( !dataGridContext.SelectedItemsStore.Contains( sourceDataItemIndex ) ) || ( !rowIsBeingEditedAndCurrentRowNotChanged ) )
-                    {
-                      this.SelectJustThisItem( dataGridContext, sourceDataItemIndex, item );
-                    }
-                  }
-                }
-                else
-                {
-                  if( ( sourceDataItemIndex == -1 ) || ( columnIndex == -1 ) )
-                  {
-                    this.UnselectAll();
-                  }
-                  else
-                  {
-                    if( ( !dataGridContext.SelectedCellsStore.Contains( sourceDataItemIndex, columnIndex ) ) || ( !rowIsBeingEditedAndCurrentRowNotChanged ) )
-                    {
-                      this.SelectJustThisCell( dataGridContext, sourceDataItemIndex, item, columnIndex );
-                    }
-                  }
-                }
+                //Do not apply selection when moving with the Ctrl pressed.
+                applySelection = false;
               }
             }
 
+            if( !keepSelection && !doRangeSelection )
+            {
+              bool isSelected = ( cellSelection )
+                ? dataGridContext.SelectedCellsStore.Contains( sourceDataItemIndex, columnIndex )
+                : dataGridContext.SelectedItemsStore.Contains( sourceDataItemIndex );
+              if( isSelected && rowIsBeingEditedAndCurrentRowNotChanged )
+              {
+                applySelection = false;
+              }
+            }
             break;
           }
 
         case UpdateSelectionSource.MouseDown:
           {
-            if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
+            if( doRangeSelection )
             {
-              if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-              {
-                this.DoRangeSelection(
-                  oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                  dataGridContext, sourceDataItemIndex, item, columnIndex, true );
-
-                m_updateSelectionOnNextMouseUp = false;
-              }
-              else
+              m_updateSelectionOnNextMouseUp = false;
+            }
+            else
+            {
+              m_updateSelectionOnNextMouseUp =
+                newPosition.GetIsSelected( m_owner.SelectionUnit );
+              // If the target item is already selected, do not update
+              // the selection on mouse down, differ this to mouse up.
+              if( m_updateSelectionOnNextMouseUp )
               {
-                m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-                m_rangeSelectionColumnStartAnchor = columnIndex;
-
-                if( m_owner.SelectionUnit == SelectionUnit.Row )
-                {
-                  if( sourceDataItemIndex != -1 )
-                  {
-                    // this.Select return false when the item is already selected.
-                    m_updateSelectionOnNextMouseUp = !this.SelectItems(
-                      dataGridContext, new SelectionRangeWithItems( sourceDataItemIndex, item ) );
+                applySelection = false;
 
-                    m_rowIsBeingEditedAndCurrentRowNotChanged = false;
-                  }
-                }
-                else
+                if( isValid )
                 {
-                  if( ( sourceDataItemIndex != -1 ) && ( columnIndex != -1 ) )
+                  if( !(ctrl && !shift) )
                   {
-                    // this.Select return false when the item is already selected.
-                    m_updateSelectionOnNextMouseUp = !this.SelectCells(
-                      dataGridContext, new SelectionCellRangeWithItems( sourceDataItemIndex, item, columnIndex ) );
-                    m_rowIsBeingEditedAndCurrentRowNotChanged = rowIsBeingEditedAndCurrentRowNotChanged;
+                    m_updateSelectionOnNextMouseUp = !rowIsBeingEditedAndCurrentRowNotChanged;
                   }
                 }
               }
             }
-            else if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
+            break;
+          }
+        case UpdateSelectionSource.RowSelector:
+          {
+            if( doRangeSelection )
             {
-              this.DoRangeSelection(
-                oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                dataGridContext, sourceDataItemIndex, item, columnIndex, false );
-
               m_updateSelectionOnNextMouseUp = false;
             }
             else
             {
-              m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-              m_rangeSelectionColumnStartAnchor = columnIndex;
+              newPosition.ColumnIndex = 0;
+              isValid = ( newPosition.ItemIndex != -1 );
 
-              if( m_owner.SelectionUnit == SelectionUnit.Row )
-              {
-                if( sourceDataItemIndex == -1 )
-                {
-                  this.UnselectAll();
-                }
-                else
-                {
-                  if( !dataGridContext.SelectedItemsStore.Contains( sourceDataItemIndex ) )
-                  {
-                    this.SelectJustThisItem( dataGridContext, sourceDataItemIndex, item );
-                    m_updateSelectionOnNextMouseUp = false;
-                  }
-                  else
-                  {
-                    m_updateSelectionOnNextMouseUp = true;
-                    m_rowIsBeingEditedAndCurrentRowNotChanged = rowIsBeingEditedAndCurrentRowNotChanged;
-                  }
-                }
-              }
-              else
+              if( isValid )
               {
-                if( ( sourceDataItemIndex == -1 ) || ( columnIndex == -1 ) )
-                {
-                  this.UnselectAll();
-                }
-                else
+                // If the target item is already selected, do not update
+                // the selection on mouse down, differ this to mouse up.
+                m_updateSelectionOnNextMouseUp =
+                  newPosition.GetIsSelected( SelectionUnit.Row );
+
+                if( m_updateSelectionOnNextMouseUp )
                 {
-                  if( !dataGridContext.SelectedCellsStore.Contains( sourceDataItemIndex, columnIndex ) )
-                  {
-                    this.SelectJustThisCell( dataGridContext, sourceDataItemIndex, item, columnIndex );
-                    m_updateSelectionOnNextMouseUp = false;
-                  }
-                  else
-                  {
-                    m_updateSelectionOnNextMouseUp = true;
-                    m_rowIsBeingEditedAndCurrentRowNotChanged = rowIsBeingEditedAndCurrentRowNotChanged;
-                  }
+                  applySelection = false;
                 }
               }
             }
-
             break;
           }
 
         case UpdateSelectionSource.MouseUp:
           {
-            if( ( m_updateSelectionOnNextMouseUp ) && ( !m_rowIsBeingEditedAndCurrentRowNotChanged ) )
+            if( !isValid || !m_updateSelectionOnNextMouseUp )
             {
-              if( m_owner.SelectionUnit == SelectionUnit.Row )
-              {
-                if( sourceDataItemIndex != -1 )
-                {
-                  if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-                  {
-                    bool keepPreviousSelection = ( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control );
-
-                    this.DoRangeSelection(
-                      oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                      dataGridContext, sourceDataItemIndex, item, columnIndex, keepPreviousSelection );
-                  }
-                  else
-                  {
-                    m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-                    m_rangeSelectionColumnStartAnchor = columnIndex;
+              applySelection = false;
+              updateRangeStartPosition = false;
+            }
 
-                    if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
-                    {
-                      this.ToggleItemSelection( dataGridContext, sourceDataItemIndex, item );
-                    }
-                    else if( !rowIsBeingEditedAndCurrentRowNotChanged )
-                    {
-                      this.SelectJustThisItem( dataGridContext, sourceDataItemIndex, item );
-                    }
-                  }
-                }
-              }
-              else
-              {
-                if( sourceDataItemIndex != -1 )
-                {
-                  if( m_fromRowSelector )
-                  {
-                    if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-                    {
-                      bool keepPreviousSelection = ( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control );
-
-                      this.DoRangeSelection(
-                        oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                        dataGridContext, sourceDataItemIndex, item, columnIndex, keepPreviousSelection, true );
-                    }
-                    else
-                    {
-                      m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-                      m_rangeSelectionColumnStartAnchor = columnIndex;
-
-                      if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
-                      {
-                        this.ToggleItemCellsSelection( dataGridContext,
-                          sourceDataItemIndex,
-                          item );
-                      }
-                      else
-                      {
-                        this.SelectItemCells( dataGridContext,
-                          sourceDataItemIndex,
-                          item,
-                          false );
-                      }
-                    }
-                  }
-                  else if( columnIndex != -1 )
-                  {
-                    if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-                    {
-                      bool keepPreviousSelection = ( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control );
-
-                      this.DoRangeSelection(
-                        oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                        dataGridContext, sourceDataItemIndex, item, columnIndex, keepPreviousSelection );
-                    }
-                    else
-                    {
-                      m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-                      m_rangeSelectionColumnStartAnchor = columnIndex;
-
-                      if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
-                      {
-                        this.ToggleCellSelection( dataGridContext,
-                          sourceDataItemIndex,
-                          item,
-                          columnIndex );
-                      }
-                      else
-                      {
-                        this.SelectJustThisCell( dataGridContext,
-                          sourceDataItemIndex,
-                          item,
-                          columnIndex );
-                      }
-                    }
-                  }
-                }
-              }
-            }
 
             // Reset the fromRowSelector to ensure nothing special is done
             // on next MouseUp (failsafe, should be reset by UpdateSelection)
@@ -1262,191 +1038,176 @@ namespace Xceed.Wpf.DataGrid
             // around that mouse up will toggle selection
             m_updateSelectionOnNextMouseUp = true;
 
-            m_rowIsBeingEditedAndCurrentRowNotChanged = false;
-
             break;
           }
 
         case UpdateSelectionSource.SpaceDown:
           {
-            if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
+            //Space Will add to selection without removing the existing
+            //selection. (ie. Like Windows Explorer)
+            if( !ctrl && !shift )
             {
-              m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-              m_rangeSelectionColumnStartAnchor = columnIndex;
-
-              if( m_owner.SelectionUnit == SelectionUnit.Row )
-              {
-                if( sourceDataItemIndex != -1 )
-                {
-                  this.ToggleItemSelection( dataGridContext, sourceDataItemIndex, item );
-                }
-              }
-              else
-              {
-                if( ( sourceDataItemIndex != -1 ) && ( columnIndex != -1 ) )
-                {
-                  this.ToggleCellSelection( dataGridContext, sourceDataItemIndex, item, columnIndex );
-                }
-              }
+              keepSelection = true;
             }
-
             break;
           }
-
-        case UpdateSelectionSource.RowSelector:
+        case UpdateSelectionSource.MouseMove:
           {
-            // We must raise the same flags as in the MouseDown to ensure
-            // the MouseUp is correctly handled
-            if( ( Keyboard.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
-            {
-              if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-              {
-                this.DoRangeSelection(
-                  oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                  dataGridContext, sourceDataItemIndex, item, columnIndex, true, true );
+            toggleSelection = false;
+            doRangeSelection = true;
+            updateRangeStartPosition = false;
+            break;
+          }
+        default:
+          {
+            //Fallback for "None" or other futur cases:
+            applySelection = false;
+            updateRangeStartPosition = false;
+            break;
+          }
+      }
 
-                m_updateSelectionOnNextMouseUp = false;
-              }
-              else
-              {
-                m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-                m_rangeSelectionColumnStartAnchor = 0;
+      if( updateRangeStartPosition )
+      {
+        m_selectionRangeStartPoint = newPosition;
+      }
 
-                if( m_owner.SelectionUnit == SelectionUnit.Row )
-                {
-                  if( sourceDataItemIndex != -1 )
-                  {
-                    // this.Select return false when the item is already selected.
-                    m_updateSelectionOnNextMouseUp = !this.SelectItems(
-                      dataGridContext, new SelectionRangeWithItems( sourceDataItemIndex, item ) );
-                  }
-                }
-                else
-                {
-                  if( sourceDataItemIndex != -1 )
-                  {
-                    // this.Select return false when the item is already selected.
-                    m_updateSelectionOnNextMouseUp = !this.SelectItemCells( dataGridContext,
-                      sourceDataItemIndex,
-                      item,
-                      true );
-                  }
-                }
-              }
-            }
-            else if( ( Keyboard.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-            {
-              this.DoRangeSelection(
-                oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-                dataGridContext, sourceDataItemIndex, item, columnIndex, false, true );
+      if( applySelection )
+      {
+        this.ApplySelection(
+          oldPosition, newPosition,
+          fromRowSelector,
+          isValid,
+          doRangeSelection,
+          allowRangeUnselection,
+          toggleSelection, keepSelection );
+      }
+    }
 
-              m_updateSelectionOnNextMouseUp = false;
-            }
-            else
-            {
-              m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-              m_rangeSelectionColumnStartAnchor = 0;
+    private void ApplySelection(
+      SelectionRangePoint oldPosition,
+      SelectionRangePoint newPosition,
+      bool fromRowSelector,
+      bool isValid,
+      bool doRangeSelection,
+      bool allowRangeUnselection,
+      bool toggleSelection,
+      bool keepSelection )
+    {
+      if( !isValid )
+      {
+        if( !keepSelection )
+        {
+          this.UnselectAll();
+        }
+        return;
+      }
 
-              if( m_owner.SelectionUnit == SelectionUnit.Row )
-              {
-                if( sourceDataItemIndex == -1 )
-                {
-                  this.UnselectAll();
-                }
-                else
-                {
-                  if( !dataGridContext.SelectedItemsStore.Contains( sourceDataItemIndex ) )
-                  {
-                    this.SelectJustThisItem( dataGridContext,
-                      sourceDataItemIndex,
-                      item );
+      if( doRangeSelection )
+      {
+        this.DoRangeSelection( oldPosition, newPosition, keepSelection, fromRowSelector, allowRangeUnselection );
+        return;
+      }
 
-                    m_updateSelectionOnNextMouseUp = false;
-                  }
-                  else
-                  {
-                    m_updateSelectionOnNextMouseUp = true;
-                  }
-                }
-              }
-              else
-              {
-                if( ( sourceDataItemIndex == -1 ) || ( columnIndex == -1 ) )
-                {
-                  this.UnselectAll();
-                }
-                else
-                {
-                  m_updateSelectionOnNextMouseUp =
-                    !this.SelectItemCells( dataGridContext, sourceDataItemIndex, item, false );
-                }
-              }
-            }
-            break;
-          }
+      DataGridContext dataGridContext = newPosition.DataGridContext;
+      object item = newPosition.Item;
+      int sourceDataItemIndex = newPosition.ItemIndex;
+      int columnIndex = newPosition.ColumnIndex;
+
+      Action toggleAction;
+      Action selectAndClearAction;
+      Action addToSelectionAction;
+
+      if( m_owner.SelectionUnit == SelectionUnit.Cell )
+      {
+        if( fromRowSelector )
+        {
+          toggleAction = () => this.ToggleItemCellsSelection( dataGridContext, sourceDataItemIndex, item );
+          selectAndClearAction = () => this.SelectItemCells( dataGridContext, sourceDataItemIndex, item, false );
+          addToSelectionAction = () => this.SelectItemCells( dataGridContext, sourceDataItemIndex, item, true );
+        }
+        else
+        {
+          toggleAction = () => this.ToggleCellSelection( dataGridContext, sourceDataItemIndex, item, columnIndex );
+          selectAndClearAction = () => this.SelectJustThisCell( dataGridContext, sourceDataItemIndex, item, columnIndex );
+          addToSelectionAction = () => this.SelectCells( dataGridContext, new SelectionCellRangeWithItems( sourceDataItemIndex, item, columnIndex ) );
+        }
+      }
+      else
+      {
+        toggleAction = () => this.ToggleItemSelection( newPosition );
+        selectAndClearAction = () => this.SelectJustThisItem( newPosition );
+        addToSelectionAction = () => this.SelectItems( newPosition );
       }
-    }
 
-    private void DoRangeSelection(
-      DataGridContext oldCurrentDataGridContext,
-      object oldCurrentItem,
-      int oldCurrentColumnIndex,
-      DataGridContext dataGridContext,
-      int sourceDataItemIndex,
-      object item,
-      int columnIndex,
-      bool keepPreviousSelection )
-    {
-      this.DoRangeSelection(
-        oldCurrentDataGridContext, oldCurrentItem, oldCurrentColumnIndex,
-        dataGridContext, sourceDataItemIndex, item, columnIndex,
-        keepPreviousSelection, false );
+      if( toggleSelection )
+      {
+        toggleAction();
+      }
+      else if( !keepSelection )
+      {
+        selectAndClearAction();
+      }
+      else
+      {
+        addToSelectionAction();
+      }
     }
 
     private void DoRangeSelection(
-      DataGridContext oldCurrentDataGridContext,
-      object oldCurrentItem,
-      int oldCurrentColumnIndex,
-      DataGridContext dataGridContext,
-      int sourceDataItemIndex,
-      object item,
-      int columnIndex,
+      SelectionRangePoint oldPosition,
+      SelectionRangePoint newPosition,
       bool keepPreviousSelection,
-      bool fromRowSelector )
+      bool fromRowSelector,
+      bool allowRangeUnselection )
     {
-      if( item == null )
-        return;
+      // Un-select a range if we keep previous selection, and
+      // the selection anchor is a unselected item.
 
-      IDataGridContextVisitable visitable = ( IDataGridContextVisitable )m_owner.DataGridContext;
+      if( m_selectionRangeStartPoint == null )
+      {
+        m_selectionRangeStartPoint = oldPosition ?? newPosition;
+      }
 
-      if( m_rangeSelectionItemStartAnchor == -1 )
+      bool unselect = false;
+      if( allowRangeUnselection && keepPreviousSelection )
       {
-        if( ( oldCurrentDataGridContext != null ) && ( oldCurrentItem != null ) )
+        if( m_owner.SelectionUnit == SelectionUnit.Cell )
         {
-          m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( oldCurrentDataGridContext, oldCurrentItem );
-          m_rangeSelectionColumnStartAnchor = oldCurrentColumnIndex;
+          unselect = ( fromRowSelector )
+            ? !this.IsItemCellsSelected( m_selectionRangeStartPoint )
+            : !this.IsCellSelected( m_selectionRangeStartPoint );
         }
         else
         {
-          m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-          m_rangeSelectionColumnStartAnchor = columnIndex;
+          unselect = !this.IsItemSelected( m_selectionRangeStartPoint );
         }
       }
 
+      this.DoRangeSelectionNoGroupSupport( newPosition, keepPreviousSelection, fromRowSelector, unselect );
+    }
+
+    private void DoRangeSelectionNoGroupSupport(
+      SelectionRangePoint newPosition,
+      bool keepPreviousSelection,
+      bool fromRowSelector,
+      bool unselect )
+    {
+      int starting_index = m_selectionRangeStartPoint.ItemGlobalIndex;
+      int ending_index = newPosition.ItemGlobalIndex;
+
       if( !keepPreviousSelection )
       {
         this.UnselectAll();
       }
 
-      int starting_index = m_rangeSelectionItemStartAnchor;
-      int ending_index = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
-
-      int min = Math.Min( starting_index, ending_index );
-      int max = Math.Max( starting_index, ending_index );
-
       // here I need to normalize the values to ensure that I'm not catching the Fixed Headers or Fixed Footers
-      if( ( min != -1 ) && ( max != -1 ) )
+      if( starting_index != -1 && ending_index != -1 )
       {
+
+        int min = Math.Min( starting_index, ending_index );
+        int max = Math.Max( starting_index, ending_index );
+
         SelectionRange[] selectedColumns;
 
         if( m_owner.SelectionUnit == SelectionUnit.Row )
@@ -1462,25 +1223,25 @@ namespace Xceed.Wpf.DataGrid
           // what was the previous anchor
           if( fromRowSelector )
           {
-            m_rangeSelectionColumnStartAnchor = 0;
-            fullColumnRange = new SelectionRange( 0, Math.Max( 0, dataGridContext.ColumnsByVisiblePosition.Count - 1 ) );
+            m_selectionRangeStartPoint.ColumnIndex = 0;
+            fullColumnRange = new SelectionRange( 0, Math.Max( 0, newPosition.DataGridContext.ColumnsByVisiblePosition.Count - 1 ) );
           }
           else
           {
-            if( m_rangeSelectionColumnStartAnchor == -1 )
-              m_rangeSelectionColumnStartAnchor = 0;
+            if( m_selectionRangeStartPoint.ColumnIndex == -1 )
+              m_selectionRangeStartPoint.ColumnIndex = 0;
 
-            if( columnIndex == -1 )
+            if( newPosition.ColumnIndex == -1 )
               return;
 
-            fullColumnRange = new SelectionRange( m_rangeSelectionColumnStartAnchor, columnIndex );
+            fullColumnRange = new SelectionRange( m_selectionRangeStartPoint.ColumnIndex, newPosition.ColumnIndex );
           }
 
-          SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage( null, 8 );
+          SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage( null );
           selectedColumnStore.Add( new SelectionRangeWithItems( fullColumnRange, null ) );
           int index = 0;
 
-          foreach( ColumnBase column in dataGridContext.ColumnsByVisiblePosition )
+          foreach( ColumnBase column in newPosition.DataGridContext.ColumnsByVisiblePosition )
           {
             if( !column.Visible )
             {
@@ -1493,15 +1254,304 @@ namespace Xceed.Wpf.DataGrid
           selectedColumns = selectedColumnStore.ToSelectionRangeArray();
         }
 
+        IDataGridContextVisitable visitable = ( IDataGridContextVisitable )m_owner.DataGridContext;
         bool visitWasStopped;
 
         visitable.AcceptVisitor(
           min, max,
-          new RangeSelectionVisitor( selectedColumns ),
+          new RangeSelectionVisitor( selectedColumns, unselect ),
           DataGridContextVisitorType.ItemsBlock, out visitWasStopped );
       }
     }
 
+    private void AffectSelectionRange( List<SelectionRangePoint> startPath, List<SelectionRangePoint> endPath, bool unselect )
+    {
+      // For each DataContext depth of each path.
+      for( int i = Math.Max( startPath.Count, endPath.Count ) - 1; i >= 0;i--)
+      {
+        DataGridContext startContext = null;
+        DataGridContext endContext = null;
+        int startIndex = -1;
+        int endIndex = -1;
+        int notUsed;
+
+        if( i < startPath.Count )
+        {
+          startContext = startPath[ i ].DataGridContext;
+          this.ExtractRangePositionIndexes( startPath[ i ], out startIndex, out notUsed );
+          if( i != startPath.Count - 1 )
+          {
+            // Except for the deepest level of the start path,
+            // We should not include the start index in the selection
+            // This is because the parent item placeholder (ie. the master row) is
+            // over/before the displayed children, and is not visually within
+            // the range of the selection.
+            startIndex++;
+          }
+        }
+
+        if( i < endPath.Count )
+        {
+          endContext = endPath[ i ].DataGridContext;
+          this.ExtractRangePositionIndexes( endPath[ i ], out notUsed, out endIndex );
+        }
+
+        if( startContext != endContext )
+        {
+          if( startContext != null )
+          {
+            // This is a sub context unique to the start selection path.
+            // Since the selection go beyond this data context, select all items starting
+            // at the startIndex to the last item of this context.
+            int lastItemIndex = startContext.Items.Count - 1;
+            this.AffectSelectionRecursivelyForSelectRange( startContext, startIndex, lastItemIndex, unselect );
+          }
+
+          if( endContext != null )
+          {
+            // This is a sub context unique to the end selection path.
+            // Since the selection is starting before this data context, select all items from
+            // the first of this data context down to the endIndex.
+            this.AffectSelectionRecursivelyForSelectRange( endContext, 0, endIndex, unselect );
+          }
+        }
+        else
+        {
+          // The context is the same for start and end path.
+          // Select only items within the range of the startIndex down to the
+          // endIndex.
+          Debug.Assert( startContext != null );
+          this.AffectSelectionRecursivelyForSelectRange( startContext, startIndex, endIndex, unselect );
+        }
+      }
+    }
+
+
+    private void AffectSelectionRecursivelyForSelectRange( DataGridContext dataGridContext, int startIndex, int endIndex, bool unselect )
+    {
+      if( startIndex > endIndex)
+        return;
+
+      // We do not Recursively select the last item since the children
+      // of theses will go beyond this last item.
+      if( startIndex < endIndex )
+      {
+        this.AffectSelectionRecursivelyOnDetails( dataGridContext, startIndex, endIndex - 1, unselect );
+      }
+
+      //Select, not recursively the last item of the range.
+      var selectionRange = new SelectionRangeWithItems( new SelectionRange( endIndex, endIndex ), null );
+      this.AffectSelection( dataGridContext, selectionRange, unselect );
+    }
+
+    private bool AffectSelectionRecursivelyOnDetails(
+      DataGridContext dataGridContext,
+      int startIndex,
+      int endIndex,
+      bool unselect )
+    {
+      if( startIndex < 0 || endIndex < 0 )
+        return false;
+
+      //Apply the selection operation at the current level.
+      var rangeWithItem = new SelectionRangeWithItems( new SelectionRange( startIndex, endIndex ), null );
+      bool wasAlreadyDone = this.AffectSelection( dataGridContext, rangeWithItem, unselect );
+
+      if( dataGridContext.DetailConfigurations.Count > 0 )
+      {
+        int firstIndex = Math.Min( startIndex, endIndex );
+        int lastIndex = Math.Max( startIndex, endIndex );
+
+        for( int i = firstIndex; i <= lastIndex; i++ )
+        {
+          // If the items are not provided, extract them from the DataGridContext.
+          var item = dataGridContext.Items.GetItemAt( i );
+          foreach( var configuration in dataGridContext.DetailConfigurations )
+          {
+            var subContext = dataGridContext.GetChildContext( item, configuration );
+            if( subContext != null )
+            {
+              wasAlreadyDone = wasAlreadyDone
+                && this.AffectSelectionRecursivelyOnDetails( subContext, 0, subContext.Items.Count - 1, unselect );
+            }
+          }
+        }
+      }
+
+      return wasAlreadyDone;
+    }
+
+    private bool AffectSelection( 
+      DataGridContext dataGridContext,
+      SelectionRangeWithItems selectionRange, 
+      bool unselect )
+    {
+      return ( unselect )
+        ? this.UnselectItems( dataGridContext, selectionRange )
+        : this.SelectItems( dataGridContext, selectionRange );
+    }
+
+    private bool IsItemSelected( SelectionRangePoint rangePosition )
+    {
+      return this.IsItemSelected( rangePosition.DataGridContext, rangePosition.ItemIndex );
+    }
+
+    private bool IsItemSelected( DataGridContext context, int itemIndex )
+    {
+      return context.SelectedItemsStore.Contains( itemIndex );
+    }
+
+    private bool IsCellSelected( SelectionRangePoint selectionPoint )
+    {
+      return this.IsCellSelected( selectionPoint.DataGridContext, selectionPoint.ItemIndex, selectionPoint.ColumnIndex );
+    }
+
+    private bool IsCellSelected( DataGridContext context, int itemIndex, int columnIndex )
+    {
+      return context.SelectedCellsStore.Contains( itemIndex, columnIndex );
+    }
+
+    private bool IsItemCellsSelected( SelectionRangePoint selectionPoint )
+    {
+      SelectedCellsStorage itemCells = this.GetItemCellStorage( selectionPoint.DataGridContext, 
+        selectionPoint.ItemIndex, selectionPoint.Item );
+
+      return this.IsItemCellsSelected( selectionPoint.DataGridContext, itemCells );
+    }
+
+    private bool IsItemCellsSelected( DataGridContext dataGridContext, SelectedCellsStorage itemCellsStorage )
+    {
+      bool allCellSelected = true;
+
+      foreach( SelectionCellRangeWithItems allCellSelection in itemCellsStorage )
+      {
+        if( !dataGridContext.SelectedCellsStore.Contains( allCellSelection ) )
+        {
+          allCellSelected = false;
+          break;
+        }
+      }
+
+      return allCellSelected;
+    }
+
+    private SelectedCellsStorage GetItemCellStorage( DataGridContext dataGridContext, int itemIndex, object item )
+    {
+      SelectedCellsStorage tempStorage = new SelectedCellsStorage( null );
+      tempStorage.Add( this.GetItemCellRange( dataGridContext, itemIndex, item ) );
+
+      foreach( ColumnBase column in dataGridContext.ColumnsByVisiblePosition )
+      {
+        if( !column.Visible )
+          tempStorage.Remove( new SelectionCellRangeWithItems( itemIndex, item, column.VisiblePosition ) );
+      }
+
+      return tempStorage;
+    }
+
+    private SelectionCellRangeWithItems GetItemCellRange( DataGridContext dataGridContext, int itemIndex, object item )
+    {
+      SelectionRange itemRange = new SelectionRange( itemIndex );
+
+      SelectionRange cellRange = new SelectionRange( 0,
+        Math.Max( 0, dataGridContext.Columns.Count - 1 ) );
+
+      // Select all visible cells for this itemIndex
+      return new SelectionCellRangeWithItems( itemRange, new object[] { item }, cellRange );
+    }
+
+    private int CompareRangePosition( List<SelectionRangePoint> range1Indexes, List<SelectionRangePoint> range2Indexes )
+    {
+      for( int i = 0; i < range1Indexes.Count && i < range2Indexes.Count; i++ )
+      {
+        SelectionRangePoint node1 = range1Indexes[ i ];
+        SelectionRangePoint node2 = range2Indexes[ i ];
+
+        Debug.Assert( node1.DataGridContext == node2.DataGridContext );
+        int node1First, node1Last;
+        int node2First, node2Last;
+
+        this.ExtractRangePositionIndexes( node1, out node1First, out node1Last );
+        this.ExtractRangePositionIndexes( node2, out node2First, out node2Last );
+
+        if( node1First < node2First )
+        {
+          return -1;
+        }
+        else if( node1First > node2First )
+        {
+          return 1;
+        }
+        else
+        {
+          // Both node have the same first index. They may however represent
+          // different items (Ex. A the first item or subgroup of a group 
+          // in relation to this parent group)
+          //
+          // In this case, since the group is visually represented as 
+          // the "header" of it's children, consider 
+          // the parent group to be "before" its children.
+          // The the parent group of an item/subgroup will have a
+          // higher last index than its children.
+          if( node1Last != node2Last )
+          {
+            return ( node1Last > node2Last )
+              ? -1
+              : 1;
+          }
+        }
+      }
+
+      // Since the visual representation of the master is before the children,
+      // any Master->Children comparaision will identify the master to be "before" 
+      // the children.
+      if( range1Indexes.Count != range2Indexes.Count )
+      {
+        return ( range1Indexes.Count < range2Indexes.Count ) ? -1 : 1;
+      }
+
+      // Paths are perfectly equals
+      return 0;
+    }
+
+    private List<SelectionRangePoint> CreatePathForSelectionPoint( SelectionRangePoint rangePoint )
+    {
+      List<SelectionRangePoint> indexList = new List<SelectionRangePoint>();
+
+      int firstIndex;
+      int lastIndex;
+      this.ExtractRangePositionIndexes( rangePoint, out firstIndex, out lastIndex );
+
+      indexList.Insert( 0, rangePoint );
+
+      var context = rangePoint.DataGridContext;
+      var parentContext = context.ParentDataGridContext;
+      while( parentContext != null )
+      {
+        int parentIndex = parentContext.Items.IndexOf( context.ParentItem );
+        indexList.Insert( 0, new SelectionRangePoint( parentContext, context.ParentItem, parentIndex, -1 ) );
+        context = parentContext;
+        parentContext = parentContext.ParentDataGridContext;
+      }
+
+      return indexList;
+    }
+
+    private void ExtractRangePositionIndexes( SelectionRangePoint rangePosition, out int firstIndex, out int lastIndex )
+    {
+      firstIndex = -1;
+      lastIndex = -1;
+
+      if( rangePosition.Item != null )
+      {
+        Debug.Assert( rangePosition.ItemIndex != -1 );
+        firstIndex = rangePosition.ItemIndex;
+        lastIndex = firstIndex;
+      }
+
+      Debug.Assert( firstIndex <= lastIndex );
+    }
+
     #endregion PUBLIC METHODS
 
     #region PRIVATE METHODS
@@ -1574,10 +1624,8 @@ namespace Xceed.Wpf.DataGrid
       {
         if( ( currentItemIndex != -1 ) && ( currentColumn != null )
           && currentContext.SelectedCellsStore.GetIntersectedColumnRanges(
-            new SelectionCellRange( currentItemIndex, currentColumn.VisiblePosition ) ).Count > 0 )
-        {
+            new SelectionCellRange( currentItemIndex, currentColumn.VisiblePosition ) ).Any() )
           return;
-        }
 
         selectedColumn = currentContext.ColumnsByVisiblePosition.ElementAtOrDefault( selectedColumnIndex );
       }
@@ -1589,7 +1637,7 @@ namespace Xceed.Wpf.DataGrid
         selectedColumn = currentContext.CurrentColumn;
       }
 
-      currentContext.SetCurrent( selectedItem, null, selectedItemIndex, selectedColumn, false, true, false );
+      currentContext.SetCurrent( selectedItem, null, selectedItemIndex, selectedColumn, false, true, false, AutoScrollCurrentItemSourceTriggers.SelectionChanged );
     }
 
     #endregion PRIVATE METHODS
@@ -1600,13 +1648,13 @@ namespace Xceed.Wpf.DataGrid
     private Hashtable m_activatedSelectionChanger = new Hashtable();
     private DataGridControl m_owner;
 
-    private int m_rangeSelectionItemStartAnchor = -1;
-    private int m_rangeSelectionColumnStartAnchor = -1;
+    private SelectionRangePoint m_selectionRangeStartPoint;
 
     private bool m_updateSelectionOnNextMouseUp = true;
-    private bool m_rowIsBeingEditedAndCurrentRowNotChanged; // = false;
     private bool m_fromRowSelector; // = false;
-    private UpdateSelectionSource m_currentUpdateSelectionSource;
+
+    // = Navigation ?
+    private UpdateSelectionSource m_currentUpdateSelectionSource; 
 
     #endregion FIELDS
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangePoint.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangePoint.cs
new file mode 100644
index 00000000..50f8c2ea
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangePoint.cs
@@ -0,0 +1,142 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Controls;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class SelectionRangePoint
+  {
+    public object Item { get; private set; }
+    public int ColumnIndex { get; set; }
+    public DataGridContext DataGridContext { get; private set; }
+
+    public int ItemIndex
+    {
+      get
+      {
+        if( m_localIndex == null )
+        {
+          m_localIndex = this.DataGridContext.Items.IndexOf( this.Item );
+        }
+
+        return m_localIndex.Value;
+      }
+
+    }
+
+    public int ItemGlobalIndex
+    {
+      get
+      {
+        if( m_globalIndex == null )
+        {
+          m_globalIndex = this.DataGridContext.DataGridControl
+            .GetGlobalGeneratorIndexFromItem( this.DataGridContext, this.Item );
+        }
+
+        return m_globalIndex.Value;
+      }
+    }
+
+    public bool GetIsSelected( SelectionUnit selectionUnit )
+    {
+      if(selectionUnit == SelectionUnit.Cell)
+      {
+        if(this.ItemIndex != -1 && this.ColumnIndex != -1)
+        {
+          return this.DataGridContext.SelectedCellsStore.Contains( this.ItemIndex, this.ColumnIndex );
+        }
+      }
+      else if(selectionUnit == SelectionUnit.Row)
+      {
+        if(this.ItemIndex != -1)
+        {
+          return this.DataGridContext.SelectedItemsStore.Contains( this.ItemIndex );
+        }
+      }
+
+      return false;
+    }
+
+    private SelectionRangePoint() { }
+
+    public SelectionRangePoint( DataGridContext dataGridContext, object item, int itemIndex, int columnPosition )
+    {
+      if( dataGridContext == null )
+        throw new ArgumentNullException();
+
+      if( item == null )
+        throw new ArgumentNullException();
+
+      m_localIndex = itemIndex;
+      this.Item = item;
+      this.ColumnIndex = columnPosition;
+      this.DataGridContext = dataGridContext;
+    }
+
+    public static SelectionRangePoint TryCreateRangePoint( DataGridContext dataGridContext, object item, int itemIndex, int columnIndex )
+    {
+      if( dataGridContext != null && item != null )
+        return new SelectionRangePoint( dataGridContext, item, itemIndex, columnIndex );
+
+      return null;
+    }
+
+    public static SelectionRangePoint TryCreateFromCurrent( DataGridContext dataGridContext )
+    {
+      if( dataGridContext == null )
+        return null;
+
+      var column = dataGridContext.CurrentColumn;
+      int columnIndex = ( column != null ) ? column.VisiblePosition : -1;
+
+      var oldPosition = SelectionRangePoint.TryCreateRangePoint(
+        dataGridContext, dataGridContext.CurrentItem,
+        dataGridContext.CurrentItemIndex, columnIndex );
+
+      return oldPosition;
+    }
+
+
+
+    public SelectionRangePoint CreateCopy()
+    {
+      var copy = new SelectionRangePoint();
+
+      copy.m_globalIndex = this.m_globalIndex;
+      copy.m_localIndex = this.m_localIndex;
+      copy.Item = this.Item;
+      copy.ColumnIndex = this.ColumnIndex;
+      copy.DataGridContext = this.DataGridContext;
+
+      return copy;
+    }
+
+    public SelectionRangeWithItems ToSelectionRangeWithItems()
+    {
+      return new SelectionRangeWithItems( this.ItemIndex, this.Item );
+    }
+
+
+    private int? m_globalIndex;
+    private int? m_localIndex;
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangeWithItems.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangeWithItems.cs
index 726bd2b2..8a70c3b8 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangeWithItems.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SelectionRangeWithItems.cs
@@ -36,10 +36,21 @@ namespace Xceed.Wpf.DataGrid
       if( ( items != null ) && ( items.Length != range.Length ) && ( !range.IsEmpty ) ) 
         throw new ArgumentException( "selectionRange and items must have the same length." );
 
-      m_items = items;
+      m_items = ( items != null ) ? new OptimizedItemsList( items ) : null;
       m_range = range;
     }
 
+    internal SelectionRangeWithItems( SelectionRange range, SharedList items )
+    {
+      if( ( items.Count != range.Length ) && ( !range.IsEmpty ) )
+        throw new ArgumentException( "selectionRange and items must have the same length." );
+
+      m_items = new OptimizedItemsList( items );
+      m_range = range;
+    }
+
+
+
     #region SelectionRange Property
 
     public SelectionRange Range
@@ -60,14 +71,32 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return m_items;
+        if( m_items == null )
+          return null;
+
+        return m_items.ItemsArray;
       }
     }
 
-    private object[] m_items;
+    private OptimizedItemsList m_items;
 
     #endregion Items Property
 
+    #region ItemsList Property
+
+    internal SharedList? SharedList
+    {
+      get
+      {
+        if( m_items == null )
+          return null;
+
+        return m_items.SharedList;
+      }
+    }
+
+    #endregion ItemsList Property
+
     #region Length Property
 
     public int Length
@@ -112,7 +141,7 @@ namespace Xceed.Wpf.DataGrid
 
     public bool IsItemsEqual( SelectionRange rangeIntersection, SelectionRangeWithItems rangeWithItemsToCompare )
     {
-      object[] itemsToCompare = rangeWithItemsToCompare.m_items;
+      OptimizedItemsList itemsToCompare = rangeWithItemsToCompare.m_items;
 
       if( ( m_items == null ) || ( itemsToCompare == null ) )
         return true;
@@ -180,7 +209,7 @@ namespace Xceed.Wpf.DataGrid
       }
 
       object[] items = new object[ rangeIntersection.Length ];
-      Array.Copy( m_items, startOffset, items, 0, items.Length );
+      m_items.CopyItemsToArray( startOffset, items, 0, items.Length );
 
       if( reverseOrder )
       {
@@ -204,5 +233,83 @@ namespace Xceed.Wpf.DataGrid
     }
 
     #endregion PUBLIC METHODS
+
+    // Performance optimization.
+    // This wrapper class allow to store items as an array (exclusive)OR as an SharedList.
+    // This allow an uniform API to access the items, whether they are stored as an Array or an SharedList. 
+    //
+    // The SharedList allow us to be more efficient when we need to add items to the existing ones. 
+    // The Array allow to return a value to the SelectionRangeWithItems.Items property more efficiently.
+    private class OptimizedItemsList
+    {
+      public OptimizedItemsList( SharedList list )
+      {
+        m_itemsArray = null;
+        m_itemsList = list;
+      }
+
+      public OptimizedItemsList( object[] items )
+      {
+        if( items == null )
+          throw new ArgumentNullException( "items" );
+
+        m_itemsArray = items;
+        m_itemsList = null;
+      }
+
+      public object this[int index]
+      {
+        get
+        {
+          if( m_itemsArray != null )
+          {
+            return m_itemsArray[ index ];
+          }
+          else
+          {
+            Debug.Assert( m_itemsList != null );
+            return m_itemsList.Value[ index ];
+          }
+        }
+      }
+
+      public SharedList? SharedList
+      {
+        get { return m_itemsList; }
+      }
+
+      public object[] ItemsArray
+      {
+        get
+        {
+          //Convert the list to an array if needed.
+          if( m_itemsList != null )
+          {
+            Debug.Assert( m_itemsArray == null );
+            m_itemsArray = m_itemsList.Value.ToArray();
+            m_itemsList = null;
+          }
+
+          return m_itemsArray;
+        }
+      }
+
+      public void CopyItemsToArray( int index, object[] array, int arrayIndex, int length )
+      {
+        if( m_itemsArray != null )
+        {
+          Array.Copy( m_itemsArray, index, array, arrayIndex, length );
+        }
+        else
+        {
+          Debug.Assert( m_itemsList != null );
+          m_itemsList.Value.CopyTo( index, array, arrayIndex, length );
+        }
+      }
+
+      private object[] m_itemsArray;
+      private SharedList? m_itemsList;
+    }
+
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Settings/XmlColumnWidthStruct.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Settings/XmlColumnWidthStruct.cs
deleted file mode 100644
index 85b1eec4..00000000
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Settings/XmlColumnWidthStruct.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-/*************************************************************************************
-
-   Extended WPF Toolkit
-
-   Copyright (C) 2007-2013 Xceed Software Inc.
-
-   This program is provided to you under the terms of the Microsoft Public
-   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
-
-   For more features, controls, and fast professional support,
-   pick up the Plus Edition at http://xceed.com/wpf_toolkit
-
-   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
-
-  ***********************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Xceed.Wpf.DataGrid.Settings
-{
-  public struct XmlColumnWidth
-  {
-    #region CONSTRUCTORS
-
-    public XmlColumnWidth( ColumnWidth columnWidth )
-    {
-      m_value = columnWidth.Value;
-      m_unitType = columnWidth.UnitType;
-    }
-
-    #endregion CONSTRUCTORS
-
-    #region Value Property
-
-    public double Value
-    {
-      get
-      {
-        return m_value;
-      }
-      set
-      {
-        m_value = value;
-      }
-    }
-
-    #endregion Value Property
-
-    #region UnitType Property
-
-    public ColumnWidthUnitType UnitType
-    {
-      get
-      {
-        return m_unitType;
-      }
-      set
-      {
-        m_unitType = value;
-      }
-    }
-
-    #endregion UnitType Property
-
-    #region PUBLIC METHODS
-
-    public ColumnWidth ConvertToColumnWidth()
-    {
-      return new ColumnWidth( this.Value, this.UnitType );
-    }
-
-    #endregion PUBLIC METHODS
-
-    #region PRIVATE FIELDS
-
-    private double m_value;
-    private ColumnWidthUnitType m_unitType;
-
-    #endregion PRIVATE FIELDS
-  }
-}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SharedListStruct.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SharedListStruct.cs
new file mode 100644
index 00000000..a19ffe49
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SharedListStruct.cs
@@ -0,0 +1,118 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+
+namespace Xceed.Wpf.DataGrid
+{
+  // The idea behind this struct is to share the same "List" instance
+  // (eg. m_internalList) across many "SharedList" instances 
+  // (note: SharedList is a value type, so the reference is copied on every
+  //  assignation) without having to create and copy of the list every time.
+  // As long as each SharedList intances shares the same first items,
+  // each instances can add new items to the list without affecting other instances.
+  internal struct SharedList
+  {
+    public SharedList( int capacity )
+    {
+      m_internalList = new List<object>( capacity );
+      m_localCount = 0;
+    }
+
+    public object this[ int index ]
+    {
+      get
+      {
+        if( index >= m_localCount )
+          throw new ArgumentException( "Provided index is out of range", "index" );
+
+        return m_internalList[ index ];
+      }
+    }
+
+    public int Count
+    {
+      get { return m_localCount; }
+    }
+
+    public void EnsureCapacity( int capacity )
+    {
+      if( m_internalList.Capacity < capacity )
+      {
+        // Performance optimization. 
+        // To avoid increasing to frequently, at least double the list capacity
+        m_internalList.Capacity = Math.Max( m_internalList.Capacity * 2, capacity );
+      }
+    }
+
+    public void Add( object item )
+    {
+      this.TrunkExcessiveContent( 1 );
+      m_internalList.Add( item );
+      m_localCount++;
+    }
+
+    public void AddRange( object[] e )
+    {
+      this.TrunkExcessiveContent( e.Length );
+      m_internalList.AddRange( e );
+      m_localCount += e.Length;
+    }
+
+    public object[] ToArray()
+    {
+      object[] newArray = new object[ m_localCount ];
+      m_internalList.CopyTo( 0, newArray, 0, m_localCount );
+      return newArray;
+    }
+
+    public void CopyTo( int startIndex, object[] array, int arrayIndex, int length )
+    {
+      if( ( startIndex < 0 )
+        || ( length < 0 )
+        || ( startIndex + length > m_localCount ) )
+        throw new DataGridInternalException( "specified range is invalid" );
+
+      m_internalList.CopyTo( startIndex, array, arrayIndex, length );
+    }
+
+    private void TrunkExcessiveContent( int newListExtraCapacity )
+    {
+      if( m_localCount < m_internalList.Count )
+      {
+        // This is the scenario that should not happen very often 
+        // where we loose the "same list copy" advantage. If we need
+        // to add items to a list that already contains others "added" items,
+        // we need to "branch" the list instance.
+        var newList = new List<object>( m_localCount + newListExtraCapacity );
+        for( int i = 0; i < m_localCount; i++ )
+        {
+          newList[ i ] = m_internalList[ i ];
+        }
+        m_internalList = newList;
+      }
+    }
+
+    #region Fields
+
+    private int m_localCount; //0
+    private List<object> m_internalList;
+
+    #endregion
+
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SortingHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SortingHelper.cs
deleted file mode 100644
index d460648b..00000000
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/SortingHelper.cs
+++ /dev/null
@@ -1,240 +0,0 @@
-/*************************************************************************************
-
-   Extended WPF Toolkit
-
-   Copyright (C) 2007-2013 Xceed Software Inc.
-
-   This program is provided to you under the terms of the Microsoft Public
-   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
-
-   For more features, controls, and fast professional support,
-   pick up the Plus Edition at http://xceed.com/wpf_toolkit
-
-   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
-
-  ***********************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.ComponentModel;
-using System.Collections.ObjectModel;
-using System.Windows.Input;
-using System.Diagnostics;
-using System.Windows.Data;
-using System.Collections;
-
-namespace Xceed.Wpf.DataGrid
-{
-  internal static class SortingHelper
-  {
-    private static void ApplyColumnSort( DataGridContext dataGridContext, SortDescriptionCollection sortDescriptions, ColumnCollection columns, ColumnBase column, SortDirection sortDirection )
-    {
-      if( column == null )
-        throw new ArgumentNullException( "column" );
-
-      Debug.Assert( ( dataGridContext != null ) || ( column.ParentDetailConfiguration != null ) );
-
-      if( ( dataGridContext == null ) && ( column.ParentDetailConfiguration == null ) )
-        throw new DataGridInternalException( "DataGridContext or ParentDetailConfiguration cannot be null." );
-
-      if( !columns.Contains( column ) )
-        throw new ArgumentException( "The specified column is not part of the DataGridContext.", "column" );
-
-      string fieldName = column.FieldName;
-
-      bool canSort = ( dataGridContext != null ) ? dataGridContext.Items.CanSort : true;
-
-      if( ( !string.IsNullOrEmpty( fieldName ) ) && ( canSort == true ) )
-      {
-        SortDescription existingSort;
-        int sortDescriptionIndex = sortDescriptions.Count;
-
-        for( int i = sortDescriptions.Count - 1; i >= 0; i-- )
-        {
-          existingSort = sortDescriptions[ i ];
-
-          if( existingSort.PropertyName == fieldName )
-          {
-            if( ( ( existingSort.Direction == ListSortDirection.Ascending ) && ( sortDirection == SortDirection.Ascending ) ) ||
-                ( ( existingSort.Direction == ListSortDirection.Descending ) && ( sortDirection == SortDirection.Descending ) ) )
-            {
-              // Nothing to change!
-              sortDescriptionIndex = -1;
-            }
-            else
-            {
-              sortDescriptionIndex = i;
-              sortDescriptions.Remove( existingSort );
-            }
-
-            break;
-          }
-        }
-
-        int maxDescriptions = ( dataGridContext != null ) ? dataGridContext.MaxSortLevels 
-          : column.ParentDetailConfiguration.MaxSortLevels;
-
-        if( ( maxDescriptions != -1 ) && ( sortDescriptions.Count >= maxDescriptions ) )
-        {
-          // Cannot insert sort description since it would go beyond the max sort description count.
-          sortDescriptionIndex = -1;
-          sortDirection = SortDirection.None;
-        }
-
-        if( ( sortDescriptionIndex > -1 ) && ( sortDirection != SortDirection.None ) )
-        {
-          SortDescription sortDescription = new SortDescription( fieldName,
-            ( sortDirection == SortDirection.Ascending ) ? ListSortDirection.Ascending : ListSortDirection.Descending );
-
-          sortDescriptions.Insert( sortDescriptionIndex, sortDescription );
-          column.SetSortIndex( sortDescriptionIndex );
-          column.SetSortDirection( sortDirection );
-        }
-
-        SortingHelper.SynchronizeSortIndexes( sortDescriptions, columns );
-      }
-    }
-
-    private static IDisposable DeferResortHelper( 
-      IEnumerable itemsSourceCollection, 
-      CollectionView collectionView, 
-      SortDescriptionCollection sortDescriptions )
-    {
-      IDisposable resortDisposable = null;
-      DataGridSortDescriptionCollection dataGridSortDescriptions = sortDescriptions as DataGridSortDescriptionCollection;
-
-      if( dataGridSortDescriptions != null )
-      {
-        // We are in a detail
-        resortDisposable = dataGridSortDescriptions.DeferResort();
-      }
-      else
-      {
-        Debug.Assert( collectionView != null, "We must have a CollectionView when we are not processing a Detail" );
-
-        DataGridCollectionViewBase dataGridCollectionView = itemsSourceCollection as DataGridCollectionViewBase;
-
-        if( dataGridCollectionView != null )
-        {
-          resortDisposable = dataGridCollectionView.DataGridSortDescriptions.DeferResort();
-        }
-        else
-        {
-          resortDisposable = collectionView.DeferRefresh();
-        }
-      }
-      Debug.Assert( resortDisposable != null );
-
-      return resortDisposable;
-    }
-
-    private static void SynchronizeSortIndexes( SortDescriptionCollection sortDescriptions, ColumnCollection columns )
-    {
-      SortDescription sortDescription;
-      Collection<ColumnBase> handledColumns = new Collection<ColumnBase>();
-
-      for( int i = sortDescriptions.Count - 1; i >= 0; i-- )
-      {
-        sortDescription = sortDescriptions[ i ];
-
-        foreach( ColumnBase column in columns )
-        {
-          string fieldName = column.FieldName;
-
-          if( fieldName == sortDescription.PropertyName )
-          {
-            column.SetSortIndex( i );
-            handledColumns.Add( column );
-            break;
-          }
-        }
-      }
-
-      foreach( ColumnBase column in columns )
-      {
-        if( !handledColumns.Contains( column ) )
-        {
-          column.SetSortIndex( -1 );
-          column.SetSortDirection( SortDirection.None );
-        }
-      }
-    }
-
-    internal static void ToggleColumnSort(
-      DataGridContext dataGridContext,
-      SortDescriptionCollection sortDescriptions,
-      ColumnCollection columns,
-      ColumnBase column,
-      bool shiftUnpressed )
-    {
-      if( column == null )
-        throw new ArgumentNullException( "column" );
-
-      Debug.Assert( ( dataGridContext != null ) || ( column.ParentDetailConfiguration != null ) );
-
-      if( ( dataGridContext == null ) && ( column.ParentDetailConfiguration == null ) )
-        throw new DataGridInternalException( "DataGridContext or ParentDetailConfiguration can't be null." );
-
-      DataGridContext parentDataGridContext = ( dataGridContext == null ) ? null : dataGridContext.ParentDataGridContext;
-
-      // Defer the RestoreState of each DataGridContext of the same level
-      // to ensure all the DataGridContext will be correctly restored once
-      // all of them are completely resorted
-      HashSet<IDisposable> deferRestoreStateDisposable = new HashSet<IDisposable>();
-
-      if( parentDataGridContext != null )
-      {
-        foreach( DataGridContext childContext in parentDataGridContext.GetChildContexts() )
-        {
-          deferRestoreStateDisposable.Add( childContext.DeferRestoreState() );
-        }
-      }
-
-      IDisposable deferResortHelper = ( dataGridContext == null ) ? null :
-        SortingHelper.DeferResortHelper( dataGridContext.ItemsSourceCollection, dataGridContext.Items, sortDescriptions );
-
-      //this will ensure that all DataGridCollectionViews mapped to this SortDescriptions collection will only refresh their sorting once!
-      SortDirection newSortDirection = column.SortDirection;
-      if( ( shiftUnpressed ) &&
-          ( ( column.SortIndex == -1 ) || ( sortDescriptions.Count > 1 ) ) )
-        sortDescriptions.Clear();
-
-      switch( newSortDirection )
-      {
-        case SortDirection.None:
-          newSortDirection = SortDirection.Ascending;
-          break;
-        case SortDirection.Ascending:
-          newSortDirection = SortDirection.Descending;
-          break;
-
-        case SortDirection.Descending:
-          newSortDirection = SortDirection.None;
-          break;
-      }
-
-      SortingHelper.ApplyColumnSort( dataGridContext, sortDescriptions, columns, column, newSortDirection );
-
-      if( deferResortHelper != null )
-      {
-        //end of the DeferResort(), any DataGridCollectionView listening to the SortDescriptions instance will refresh its sorting!
-        deferResortHelper.Dispose();
-      }
-
-      foreach( IDisposable disposable in deferRestoreStateDisposable )
-      {
-        try
-        {
-          // Try/Catch to ensure all contexts are restored
-          disposable.Dispose();
-        }
-        catch( Exception )
-        {
-        }
-      }
-
-      deferRestoreStateDisposable.Clear();
-    }
-  }
-}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/InvalidSourcePropertyNameException.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/InvalidSourcePropertyNameException.cs
deleted file mode 100644
index d9af23d6..00000000
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/InvalidSourcePropertyNameException.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-/*************************************************************************************
-
-   Extended WPF Toolkit
-
-   Copyright (C) 2007-2013 Xceed Software Inc.
-
-   This program is provided to you under the terms of the Microsoft Public
-   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
-
-   For more features, controls, and fast professional support,
-   pick up the Plus Edition at http://xceed.com/wpf_toolkit
-
-   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
-
-  ***********************************************************************************/
-
-using System;
-using System.Runtime.Serialization;
-
-namespace Xceed.Wpf.DataGrid.Stats
-{
-  [Serializable]
-  internal class InvalidSourcePropertyNameException : DataGridException
-  {
-    public InvalidSourcePropertyNameException()
-      : base()
-    {
-    }
-
-    public InvalidSourcePropertyNameException( string message )
-      : base( message )
-    {
-    }
-
-    public InvalidSourcePropertyNameException( string message, string sourcePropertyName )
-      : base( message )
-    {
-      m_sourcePropertyName = sourcePropertyName;
-    }
-
-    public InvalidSourcePropertyNameException( string message, Exception innerException )
-      : base( message, innerException )
-    {
-    }
-
-    protected InvalidSourcePropertyNameException( SerializationInfo info, StreamingContext context )
-      : base( info, context )
-    {
-      m_sourcePropertyName = info.GetString( "SourcePropertyName" );
-    }
-
-    [System.Security.Permissions.SecurityPermissionAttribute( System.Security.Permissions.SecurityAction.Demand, SerializationFormatter = true )]
-    public override void GetObjectData( SerializationInfo info, StreamingContext context )
-    {
-      base.GetObjectData( info, context );
-      info.AddValue( "SourcePropertyName", m_sourcePropertyName, typeof( string ) );
-    }
-
-    private string m_sourcePropertyName;
-
-    public string SourcePropertyName
-    {
-      get
-      {
-        return m_sourcePropertyName;
-      }
-      set
-      {
-        m_sourcePropertyName = value;
-      }
-    }
-  }
-}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunction.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunction.cs
index 9cf55333..bf36d778 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunction.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunction.cs
@@ -31,6 +31,9 @@ namespace Xceed.Wpf.DataGrid.Stats
   {
     static StatFunction()
     {
+#if DEBUG
+      //StatFunction.TestStatFunctions();
+#endif
     }
 
     protected StatFunction()
@@ -211,24 +214,17 @@ namespace Xceed.Wpf.DataGrid.Stats
       m_initialized = true;
     }
 
-    protected internal virtual void Reset()
-    {
-    }
+    protected internal abstract void Reset();
 
     protected internal virtual void InitializePrerequisites( StatResult[] prerequisitesValues )
     {
       throw new NotImplementedException( "InitializePrerequisites must also be overridden when PrerequisiteFunctions has been overridden." ); 
     }
 
-    protected internal virtual void Accumulate( object[] values )
-    {
-    }
+    protected internal abstract void Accumulate( object[] values );
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate" )]
-    protected internal virtual StatResult GetResult()
-    {
-      return new StatResult( new InvalidOperationException( Log.NotToolkitStr( "Statistical functions" ) ) );
-    }
+    protected internal abstract StatResult GetResult();
 
     protected void CheckSealed()
     {
@@ -238,9 +234,12 @@ namespace Xceed.Wpf.DataGrid.Stats
 
     protected internal virtual bool IsEquivalent( StatFunction statFunction )
     {
-      if( statFunction == null )
+      if( object.ReferenceEquals( statFunction, null ) )
         return false;
 
+      if( object.ReferenceEquals( statFunction, this ) )
+        return true;
+
       return ( this.GetType() == statFunction.GetType() ) &&
              ( this.SourcePropertyName == statFunction.SourcePropertyName );
     }
@@ -248,7 +247,7 @@ namespace Xceed.Wpf.DataGrid.Stats
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate" )]
     protected internal virtual int GetEquivalenceKey()
     {
-      return this.GetType().GetHashCode() ^ this.SourcePropertyName.GetHashCode();
+      return this.SourcePropertyName.GetHashCode();
     }
 
     internal static bool AreEquivalents( StatFunction statFunctionA, StatFunction statFunctionB )
@@ -320,6 +319,64 @@ namespace Xceed.Wpf.DataGrid.Stats
       return accType;
     }
 
+#if DEBUG
+    private static StatResult RunStatFunction( StatFunction statFunction, Type[] dataTypes, params object[] values )
+    {
+      return StatFunction.RunStatFunction( statFunction, dataTypes, values, null );
+    }
+
+    private static StatResult RunStatFunction( 
+      StatFunction statFunction, 
+      Type[] dataTypes, 
+      object[] valuesX, 
+      object[] valuesY )
+    {
+      statFunction.InitializeAccumulationTypes( dataTypes );
+      statFunction.StartCalculation();
+      statFunction.Reset();
+
+      try
+      {
+        if( statFunction.PrerequisiteFunctions != null && statFunction.PrerequisiteFunctions.Length > 0 )
+        {
+          StatResult[] preValues = new StatResult[ statFunction.PrerequisiteFunctions.Length ];
+
+          for( int i = 0; i < statFunction.PrerequisiteFunctions.Length; i++ )
+          {
+            preValues[ i ] = StatFunction.RunStatFunction( statFunction.PrerequisiteFunctions[ i ], dataTypes, valuesX, valuesY );
+
+            if( preValues[ i ].Value is Exception )
+              throw ( Exception )preValues[ i ].Value;
+          }
+
+          statFunction.InitializePrerequisites( preValues );
+        }
+
+        if( statFunction.RequiresAccumulation )
+        {
+          for( int i = 0; i < valuesX.Length; i++ )
+          {
+            if( valuesY == null )
+            {
+              statFunction.Accumulate( new object[] { valuesX[ i ] } );
+            }
+            else
+            {
+              statFunction.Accumulate( new object[] { valuesX[ i ], valuesY[ i ] } );
+            }
+          }
+        }
+
+        statFunction.EndCalculation();
+        return statFunction.GetResult();
+      }
+      catch( Exception ex )
+      {
+        return new StatResult( ex );
+      }
+    }
+#endif
+
     private bool m_initialized; // = false
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionCollection.cs
index 38b1d3c2..b258d705 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionCollection.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionCollection.cs
@@ -15,38 +15,49 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
 
 namespace Xceed.Wpf.DataGrid.Stats
 {
-  internal class StatFunctionCollection : ObservableCollection<StatFunction>
+  internal sealed class StatFunctionCollection : ObservableCollection<StatFunction>
   {
+    #region Constructor
+
     internal StatFunctionCollection()
-      :base()
+      : base()
     {
     }
 
+    #endregion
+
+    #region [] Property
+
     public StatFunction this[ string resultPropertyName ]
     {
       get
       {
-        StatFunction statFunction;
-
-        for( int i = 0; i < this.Count; i++ )
-        {
-          statFunction = this[ i ];
+        if( resultPropertyName == null )
+          return null;
 
-          if( string.Equals( statFunction.ResultPropertyName, resultPropertyName ) )
-            return statFunction;
-        }
+        StatFunction value;
+        if( m_lookup.TryGetValue( resultPropertyName, out value ) )
+          return value;
 
         return null;
       }
     }
 
+    #endregion
+
     public bool Contains( string resultPropertyName )
     {
-      return this[ resultPropertyName ] != null;
+      if( resultPropertyName == null )
+        return false;
+
+      return m_lookup.ContainsKey( resultPropertyName );
     }
 
     protected override void InsertItem( int index, StatFunction item )
@@ -61,26 +72,74 @@ namespace Xceed.Wpf.DataGrid.Stats
       base.SetItem( index, item );
     }
 
-    internal StatFunction GetEquivalentOf( StatFunction statFunction )
+    protected override void OnCollectionChanged( NotifyCollectionChangedEventArgs e )
     {
-      int count = this.Count;
-
-      for( int i = 0; i < count; i++ )
+      switch( e.Action )
       {
-        if( StatFunction.AreEquivalents( statFunction, this[ i ] ) )
-          return this[ i ];
+        case NotifyCollectionChangedAction.Add:
+          this.AddStatFunctions( e.NewItems.Cast<StatFunction>() );
+          break;
+
+        case NotifyCollectionChangedAction.Remove:
+          this.RemoveStatFunctions( e.OldItems.Cast<StatFunction>() );
+          break;
+
+        case NotifyCollectionChangedAction.Replace:
+          this.RemoveStatFunctions( e.OldItems.Cast<StatFunction>() );
+          this.AddStatFunctions( e.NewItems.Cast<StatFunction>() );
+          break;
+
+        case NotifyCollectionChangedAction.Reset:
+          this.ResetStatFunctions();
+          break;
       }
 
-      return null;
+      base.OnCollectionChanged( e );
     }
 
     private void PrepareStatFunction( StatFunction item )
     {
-      if( this.Contains( item.ResultPropertyName ) )
-        throw new ArgumentException( "A StatFunction with the same ResultPropertyName already exists in the StatFunctionCollection." ); 
+      if( item == null )
+        throw new ArgumentNullException( "item" );
+
+      var key = item.ResultPropertyName;
+      if( key == null )
+        throw new ArgumentException( "TODODOC: The StatFunction must have a ResultPropertyName", "item" );
+
+      if( this.Contains( key ) )
+        throw new ArgumentException( "A StatFunction with the same ResultPropertyName already exists in the StatFunctionCollection." );
 
       item.Validate();
       item.Seal();
     }
+
+    private void AddStatFunctions( IEnumerable<StatFunction> items )
+    {
+      foreach( StatFunction item in items )
+      {
+        m_lookup.Add( item.ResultPropertyName, item );
+      }
+    }
+
+    private void RemoveStatFunctions( IEnumerable<StatFunction> items )
+    {
+      foreach( StatFunction item in items )
+      {
+        m_lookup.Remove( item.ResultPropertyName );
+      }
+    }
+
+    private void ResetStatFunctions()
+    {
+      m_lookup.Clear();
+
+      this.AddStatFunctions( this );
+    }
+
+    #region Private Fields
+
+    private readonly Dictionary<string, StatFunction> m_lookup = new Dictionary<string, StatFunction>();
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionComparer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionComparer.cs
index 11fb7d06..daca1e0f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionComparer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Stats/StatFunctionComparer.cs
@@ -14,13 +14,14 @@
 
   ***********************************************************************************/
 
-using System;
 using System.Collections.Generic;
 
 namespace Xceed.Wpf.DataGrid.Stats
 {
   internal class StatFunctionComparer : IEqualityComparer<StatFunction>
   {
+    internal static readonly StatFunctionComparer Default = new StatFunctionComparer();
+
     public bool Equals( StatFunction x, StatFunction y )
     {
       return StatFunction.AreEquivalents( x, y );
@@ -29,7 +30,7 @@ namespace Xceed.Wpf.DataGrid.Stats
     public int GetHashCode( StatFunction statFunction )
     {
       if( statFunction == null )
-        throw new ArgumentNullException( "statFunction" );
+        return 0;
 
       return statFunction.GetEquivalenceKey();
     }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/StringFormatDataTemplate.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/StringFormatDataTemplate.cs
new file mode 100644
index 00000000..7f93410b
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/StringFormatDataTemplate.cs
@@ -0,0 +1,282 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class StringFormatDataTemplate : DataTemplate
+  {
+    #region Static Fields
+
+    private static readonly List<Entry> s_templates = new List<Entry>( 0 );
+    private static readonly StringFormatConverter s_converter = new StringFormatConverter();
+    private static readonly StringFormatComparer s_comparer = new StringFormatComparer();
+
+    #endregion
+
+    #region Constructor
+
+    private StringFormatDataTemplate( DataTemplate contentTemplate )
+    {
+      m_contentTemplate = contentTemplate;
+    }
+
+    #endregion
+
+    internal static StringFormatDataTemplate Get( DataTemplate contentTemplate, string format, CultureInfo culture )
+    {
+      if( string.IsNullOrEmpty( format ) )
+        throw new ArgumentException( "The format must be non empty.", "format" );
+
+      lock( ( ( ICollection )s_templates ).SyncRoot )
+      {
+        int insertionIndex = 0;
+        bool cleanUp = false;
+        StringFormatDataTemplate template = null;
+
+        if( s_templates.Count > 0 )
+        {
+          var lookup = new Entry( format, culture );
+          insertionIndex = s_templates.BinarySearch( lookup, s_comparer );
+
+          if( insertionIndex >= 0 )
+          {
+            for( int i = insertionIndex; i < s_templates.Count; i++ )
+            {
+              var item = s_templates[ i ];
+              if( s_comparer.Compare( lookup, item ) != 0 )
+                break;
+
+              var target = item.Template;
+              if( target == null )
+              {
+                cleanUp = true;
+              }
+              else
+              {
+                Debug.Assert( object.Equals( item.Format, format ) && object.Equals( item.Culture, culture ) );
+
+                if( target.m_contentTemplate == contentTemplate )
+                {
+                  template = target;
+                  break;
+                }
+              }
+            }
+          }
+          else
+          {
+            insertionIndex = ~insertionIndex;
+            cleanUp = ( insertionIndex < s_templates.Count ) && ( s_templates[ insertionIndex ].Template == null );
+          }
+        }
+
+        if( template == null )
+        {
+          template = StringFormatDataTemplate.Create( contentTemplate, format, culture );
+          s_templates.Insert( insertionIndex, new Entry( template, format, culture ) );
+        }
+
+        if( cleanUp )
+        {
+          StringFormatDataTemplate.CleanUpCache();
+        }
+
+        Debug.Assert( template != null );
+
+        return template;
+      }
+    }
+
+    private static StringFormatDataTemplate Create( DataTemplate contentTemplate, string format, CultureInfo culture )
+    {
+      // We are using a converter to format the target value instead of using the
+      // ContentPresenter.ContentStringFormat or Binding.StringFormat property because
+      // it is not applied if a ContentPresenter.ContentTemplate is given or if the binding is
+      // not targeting a string property.
+      var template = new StringFormatDataTemplate( contentTemplate );
+      var control = new FrameworkElementFactory( typeof( ContentPresenter ) );
+
+      var binding = new Binding();
+      binding.Path = new PropertyPath( FrameworkElement.DataContextProperty );
+      binding.RelativeSource = RelativeSource.TemplatedParent;
+      binding.Converter = s_converter;
+      binding.ConverterParameter = format;
+      binding.ConverterCulture = culture;
+
+      control.SetValue( ContentPresenter.ContentTemplateProperty, contentTemplate );
+      control.SetValue( ContentPresenter.ContentProperty, binding );
+
+      template.VisualTree = control;
+      template.Seal();
+
+      return template;
+    }
+
+    private static void CleanUpCache()
+    {
+      for( int i = s_templates.Count - 1; i >= 0; i-- )
+      {
+        if( s_templates[ i ].Template == null )
+        {
+          s_templates.RemoveAt( i );
+        }
+      }
+
+      s_templates.TrimExcess();
+    }
+
+    #region Private Fields
+
+    private readonly DataTemplate m_contentTemplate;
+
+    #endregion
+
+    #region StringFormatConverter Private Class
+
+    private sealed class StringFormatConverter : IValueConverter
+    {
+      public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
+      {
+        var format = parameter as string;
+        if( string.IsNullOrEmpty( format ) )
+          return value;
+
+        return string.Format( culture, format, value );
+      }
+
+      public object ConvertBack( object value, Type targetType, object parameter, CultureInfo culture )
+      {
+        throw new NotSupportedException();
+      }
+    }
+
+    #endregion
+
+    #region StringFormatComparer Private Class
+
+    private sealed class StringFormatComparer : IComparer<Entry>
+    {
+      public int Compare( Entry x, Entry y )
+      {
+        if( object.ReferenceEquals( x, y ) )
+          return 0;
+
+        if( object.ReferenceEquals( x, null ) )
+          return -1;
+
+        if( object.ReferenceEquals( y, null ) )
+          return 1;
+
+        var xf = x.Format;
+        var yf = y.Format;
+
+        if( !string.Equals( xf, yf, StringComparison.InvariantCulture ) )
+        {
+          if( xf == null )
+            return -1;
+
+          if( yf == null )
+            return 1;
+
+          return string.Compare( xf, yf, StringComparison.InvariantCulture );
+        }
+
+        var xc = x.Culture;
+        var yc = y.Culture;
+
+        if( !object.Equals( xc, yc ) )
+        {
+          if( xc == null )
+            return -1;
+
+          if( yc == null )
+            return 1;
+
+          return xc.LCID.CompareTo( yc.LCID );
+        }
+
+        return 0;
+      }
+    }
+
+    #endregion
+
+    #region Entry Private Class
+
+    private class Entry
+    {
+      internal Entry( string format, CultureInfo culture )
+        : this( null, format, culture )
+      {
+      }
+
+      internal Entry( StringFormatDataTemplate template, string format, CultureInfo culture )
+      {
+        Debug.Assert( format != null );
+
+        if( template != null )
+        {
+          m_template = new WeakReference( template );
+        }
+
+        m_format = format;
+        m_culture = culture;
+      }
+
+      internal StringFormatDataTemplate Template
+      {
+        get
+        {
+          if( m_template == null )
+            return null;
+
+          return ( StringFormatDataTemplate )m_template.Target;
+        }
+      }
+
+      internal string Format
+      {
+        get
+        {
+          return m_format;
+        }
+      }
+
+      internal CultureInfo Culture
+      {
+        get
+        {
+          return m_culture;
+        }
+      }
+
+      private readonly WeakReference m_template;
+      private readonly string m_format;
+      private readonly CultureInfo m_culture;
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ToggleColumnSortCommand.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ToggleColumnSortCommand.cs
new file mode 100644
index 00000000..0586c10d
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ToggleColumnSortCommand.cs
@@ -0,0 +1,318 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class ToggleColumnSortCommand : ColumnSortCommand
+  {
+    #region Constructor
+
+    protected ToggleColumnSortCommand()
+    {
+    }
+
+    #endregion
+
+    #region Properties
+
+    #region CanSort Protected Property
+
+    protected abstract bool CanSort
+    {
+      get;
+    }
+
+    #endregion
+
+    #region Columns Protected Property
+
+    protected abstract ColumnCollection Columns
+    {
+      get;
+    }
+
+    #endregion
+
+    #region DataGridContext Protected Property
+
+    protected abstract DataGridContext DataGridContext
+    {
+      get;
+    }
+
+    #endregion       
+
+    #region MaxSortLevels Protected Property
+
+    protected abstract int MaxSortLevels
+    {
+      get;
+    }
+
+    #endregion
+
+    #region SortDescriptions Protected Property
+
+    protected abstract SortDescriptionCollection SortDescriptions
+    {
+      get;
+    }
+
+    #endregion
+
+    #endregion
+
+    #region Methods
+
+    public bool CanExecute( ColumnBase column, bool resetSort )
+    {
+      return ( column != null )
+          && ( this.CanExecuteCore( column, resetSort ) );
+    }
+
+    public void Execute( ColumnBase column, bool resetSort )
+    {
+      if( !this.CanExecute( column, resetSort ) )
+        return;
+
+      using( this.SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers.CollectionViewCurrentItemChanged ) )
+      {
+        this.ExecuteCore( column, resetSort );
+      }
+    }
+
+    protected virtual bool CanExecuteCore( ColumnBase column, bool resetSort )
+    {
+      if( string.IsNullOrEmpty( column.FieldName ) )
+        return false;
+
+      if( !this.CanSort || !this.Columns.Contains( column ) )
+        return false;
+
+      if( column.SortDirection == SortDirection.None )
+      {
+        int maxSortCount = this.MaxSortLevels;
+
+        // Cannot insert sort description since it would go beyond the max sort description count, but only if Shift key is pressed
+        if( !resetSort && ( maxSortCount >= 0 ) && ( this.SortDescriptions.Count >= maxSortCount ) )
+          return false;
+
+        //When Shift key is not pressed, simply evaluate if one sort description can be added, since all others will be cleared.
+        if( resetSort && maxSortCount == 0 )
+          return false;
+      }
+
+      return true;
+    }
+
+    protected virtual void ExecuteCore( ColumnBase column, bool resetSort )
+    {
+      if( !this.ToggleColumnSort( column, resetSort ) )
+        return;
+
+      this.UpdateColumnSort();
+    }
+
+    protected virtual SortDescriptionsSyncContext GetSortDescriptionsSyncContext()
+    {
+      return null;
+    }
+
+    protected virtual void ValidateSynchronizationContext( SynchronizationContext synchronizationContext )
+    {
+    }
+
+    protected virtual IDisposable DeferResortHelperItemsSourceCollection()
+    {
+      return null;
+    }
+
+    protected virtual bool TryDeferResortSourceDetailConfiguration( out IDisposable defer )
+    {
+      defer = null;
+      return false;
+    }
+
+    protected virtual IDisposable SetQueueBringIntoViewRestrictions( AutoScrollCurrentItemSourceTriggers triggers )
+    {
+      return null;
+    }
+
+    protected virtual void ValidateToggleColumnSort()
+    {
+    }
+
+    protected virtual void DeferRestoreStateOnLevel( Disposer disposer )
+    {
+    }
+
+    protected virtual void UpdateColumnSort()
+    {
+      var dataGridContext = this.DataGridContext;
+
+      if( this.DataGridContext != null )
+      {
+        var command = dataGridContext.UpdateColumnSortCommand;
+        if( command.CanExecute() )
+        {
+          command.Execute();
+        }
+      }
+    }
+
+    protected override bool CanExecuteImpl( object parameter )
+    {
+      return this.CanExecute( parameter as ColumnBase, true );
+    }
+
+    protected override void ExecuteImpl( object parameter )
+    {
+      this.Execute( parameter as ColumnBase, true );
+    }
+
+    protected static SortDirection GetNextSortDirection( SortDirection direction )
+    {
+      switch( direction )
+      {
+        case SortDirection.Ascending:
+          return SortDirection.Descending;
+
+        case SortDirection.Descending:
+          return SortDirection.None;
+
+        default:
+          return SortDirection.Ascending;
+      }
+    }
+
+    protected static void DeferRestoreStateOnLevel( Disposer disposer, DataGridContext dataGridContext )
+    {
+      ToggleColumnSortCommand.ThrowIfNull( disposer, "disposer" );
+      ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
+
+      var parentDataGridContext = dataGridContext.ParentDataGridContext;
+
+      // Defer the RestoreState of each DataGridContext of the same level
+      // to ensure all the DataGridContext will be correctly restored once
+      // all of them are completely resorted
+      if( parentDataGridContext != null )
+      {
+        foreach( var childContext in parentDataGridContext.GetChildContexts() )
+        {
+          disposer.Add( childContext.DeferRestoreState(), DisposableType.DeferRestoreState );
+        }
+      }
+    }
+
+    #endregion
+
+    #region Private Methods
+
+    private static ListSortDirection Convert( SortDirection value )
+    {
+      if( value == SortDirection.None )
+        throw new ArgumentException( "Cannot convert the value to ListSortDirection.", "value" );
+
+      if( value == SortDirection.Descending )
+        return ListSortDirection.Descending;
+
+      return ListSortDirection.Ascending;
+    }
+
+    private bool ToggleColumnSort( ColumnBase column, bool resetSort )
+    {
+      ToggleColumnSortCommand.ThrowIfNull( column, "column" );
+
+      this.ValidateToggleColumnSort();
+
+      using( var synchronizationContext = this.StartSynchronizing( this.GetSortDescriptionsSyncContext() ) )
+      {
+        this.ValidateSynchronizationContext( synchronizationContext );
+
+        using( var disposer = new Disposer() )
+        {
+          this.DeferRestoreStateOnLevel( disposer );
+
+          // This will ensure that all DataGridCollectionViews mapped to the SortDescriptions collection will only refresh their sorting once!
+          var sortDescriptions = this.SortDescriptions;
+          disposer.Add( this.DeferResortHelper( sortDescriptions ), DisposableType.DeferResort );
+
+          var newSortDirection = ToggleColumnSortCommand.GetNextSortDirection( column.SortDirection );
+          string columnName = column.FieldName;
+          int insertionIndex;
+
+          if( ( resetSort ) &&
+              ( ( column.SortIndex == -1 ) || ( sortDescriptions.Count > 1 ) ) )
+          {
+            insertionIndex = 0;
+
+            if( sortDescriptions.Count > 0 )
+            {
+              sortDescriptions.Clear();
+            }
+
+            Debug.Assert( sortDescriptions.Count == 0 );
+          }
+          else
+          {
+            for( insertionIndex = 0; insertionIndex < sortDescriptions.Count; insertionIndex++ )
+            {
+              if( sortDescriptions[ insertionIndex ].PropertyName == columnName )
+                break;
+            }
+          }
+
+          if( insertionIndex < sortDescriptions.Count )
+          {
+            if( newSortDirection == SortDirection.None )
+            {
+              sortDescriptions.RemoveAt( insertionIndex );
+            }
+            else
+            {
+              sortDescriptions[ insertionIndex ] = new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) );
+            }
+          }
+          else if( newSortDirection != SortDirection.None )
+          {
+            sortDescriptions.Add( new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) ) );
+          }
+        }
+      }
+
+      return true;
+    }
+
+    private IDisposable DeferResortHelper( SortDescriptionCollection sortDescriptions )
+    {
+      IDisposable defer;
+
+      if( this.TryDeferResort( sortDescriptions, out defer ) )
+        return defer;
+
+      if( this.TryDeferResortSourceDetailConfiguration( out defer ) )
+        return defer;
+
+      return this.DeferResortHelperItemsSourceCollection();
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UnboundColumn.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UnboundColumn.cs
index c7fa81fe..5fe08b0e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UnboundColumn.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UnboundColumn.cs
@@ -73,6 +73,24 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion AllowGroup Property
 
+    #region GroupValueStringFormat Property
+
+    [EditorBrowsable( EditorBrowsableState.Never )]
+    [Browsable( false )]
+    public new string GroupValueStringFormat
+    {
+      get
+      {
+        return base.GroupValueStringFormat;
+      }
+      set
+      {
+        base.GroupValueStringFormat = value;
+      }
+    }
+
+    #endregion GroupValueStringFormat Property
+
     #region GroupValueTemplate Property
 
     [EditorBrowsable( EditorBrowsableState.Never )]
@@ -257,8 +275,8 @@ namespace Xceed.Wpf.DataGrid
 
     #region ReadOnly Property
 
-    public static new readonly DependencyProperty ReadOnlyProperty =
-        DataGridControl.ReadOnlyProperty.AddOwner( typeof( UnboundColumn ), new FrameworkPropertyMetadata( true ) );
+    public static new readonly DependencyProperty ReadOnlyProperty = DependencyProperty.Register(
+      "ReadOnly", typeof( bool ), typeof( UnboundColumn ), new FrameworkPropertyMetadata( true ) );
 
     public override bool ReadOnly
     {
@@ -275,6 +293,6 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    #endregion ReadOnly Property
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UpdateColumnSortCommand.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UpdateColumnSortCommand.cs
new file mode 100644
index 00000000..3a4d3cc4
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/UpdateColumnSortCommand.cs
@@ -0,0 +1,209 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Threading;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal abstract class UpdateColumnSortCommand : ColumnSortCommand
+  {
+    #region SortDescriptionsSyncContext Protected Property
+
+    protected abstract SortDescriptionsSyncContext SortDescriptionsSyncContext
+    {
+      get;
+    }
+
+    #endregion
+
+    public bool CanExecute()
+    {
+      return this.CanExecuteCore();
+    }
+
+    public void Execute()
+    {
+      if( !this.CanExecute() )
+        return;
+
+      this.ExecuteCore();
+    }
+
+    protected abstract bool CanExecuteCore();
+    protected abstract void ExecuteCore();
+
+    protected override bool CanExecuteImpl( object parameter )
+    {
+      return this.CanExecuteCore();
+    }
+
+    protected override void ExecuteImpl( object parameter )
+    {
+      this.Execute();
+    }
+
+    protected void SynchronizeColumnSort(
+      SynchronizationContext synchronizationContext,
+      SortDescriptionCollection sortDescriptions,
+      ColumnCollection columns )
+    {
+      ColumnSortCommand.ThrowIfNull( synchronizationContext, "synchronizationContext" );
+      ColumnSortCommand.ThrowIfNull( sortDescriptions, "sortDescriptions" );
+      ColumnSortCommand.ThrowIfNull( columns, "columns" );
+
+      if( !synchronizationContext.Own || !columns.Any() )
+        return;
+
+      this.SetResortCallback( sortDescriptions, columns );
+
+      int count = sortDescriptions.Count;
+      Dictionary<string, ColumnSortInfo> sortOrder = new Dictionary<string, ColumnSortInfo>( count );
+
+      for( int i = 0; i < count; i++ )
+      {
+        var sortDescription = sortDescriptions[ i ];
+        string propertyName = sortDescription.PropertyName;
+
+        if( sortOrder.ContainsKey( propertyName ) )
+          continue;
+
+        sortOrder.Add( propertyName, new ColumnSortInfo( i, sortDescription.Direction ) );
+      }
+
+      foreach( var column in columns )
+      {
+        ColumnSortInfo entry;
+
+        if( sortOrder.TryGetValue( column.FieldName, out entry ) )
+        {
+          column.SetSortIndex( entry.Index );
+          column.SetSortDirection( entry.Direction );
+        }
+        else
+        {
+          column.SetSortIndex( -1 );
+          column.SetSortDirection( SortDirection.None );
+        }
+      }
+    }
+
+    private void SetResortCallback( SortDescriptionCollection sortDescriptions, ColumnCollection columns )
+    {
+      var collection = sortDescriptions as DataGridSortDescriptionCollection;
+      if( ( m_resortCallback != null ) || ( collection == null ) || !collection.IsResortDefered )
+        return;
+
+      m_resortCallback = new ResortCallback( this, sortDescriptions, columns );
+      collection.AddResortNotification( m_resortCallback );
+    }
+
+    private void OnResortCallback( SortDescriptionCollection sortDescriptions, ColumnCollection columns )
+    {
+      using( var synchronizationContext = this.StartSynchronizing( this.SortDescriptionsSyncContext ) )
+      {
+        this.SynchronizeColumnSort( synchronizationContext, sortDescriptions, columns );
+      }
+    }
+
+    #region Private Fields
+
+    private IDisposable m_resortCallback; //null
+
+    #endregion
+
+    #region ColumnSortInfo Private Nested Type
+
+    private struct ColumnSortInfo
+    {
+      public ColumnSortInfo( int index, ListSortDirection direction )
+      {
+        this.Index = index;
+        this.Direction = ColumnSortInfo.Convert( direction );
+      }
+
+      private static SortDirection Convert( ListSortDirection value )
+      {
+        if( value == ListSortDirection.Descending )
+          return SortDirection.Descending;
+
+        return SortDirection.Ascending;
+      }
+
+      public readonly int Index;
+      public readonly SortDirection Direction;
+    }
+
+    #endregion
+
+    #region ResortCallback Private Class
+
+    private sealed class ResortCallback : IDisposable
+    {
+      internal ResortCallback(
+        UpdateColumnSortCommand owner,
+        SortDescriptionCollection sortDescriptions,
+        ColumnCollection columns )
+      {
+        if( owner == null )
+          throw new ArgumentNullException( "owner" );
+
+        m_owner = new WeakReference( owner );
+        m_sortDescriptions = sortDescriptions;
+        m_columns = columns;
+      }
+
+      void IDisposable.Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        if( !disposing )
+          return;
+
+        var ownerRef = m_owner;
+        if( Interlocked.CompareExchange<WeakReference>( ref m_owner, null, ownerRef ) == null )
+          return;
+
+        var owner = ( UpdateColumnSortCommand )ownerRef.Target;
+        if( owner != null )
+        {
+          owner.OnResortCallback( m_sortDescriptions, m_columns );
+        }
+
+        m_sortDescriptions = null;
+        m_columns = null;
+      }
+
+      ~ResortCallback()
+      {
+        this.Dispose( false );
+      }
+
+      private WeakReference m_owner;
+      private SortDescriptionCollection m_sortDescriptions;
+      private ColumnCollection m_columns;
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/DoubleFenwickTree.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/DoubleFenwickTree.cs
new file mode 100644
index 00000000..91031212
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/DoubleFenwickTree.cs
@@ -0,0 +1,41 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+
+namespace Xceed.Utils.Collections
+{
+  internal sealed class DoubleFenwickTree : FenwickTree<double>
+  {
+    #region Constructor
+
+    public DoubleFenwickTree( int capacity )
+      : base( capacity )
+    {
+    }
+
+    #endregion
+
+    protected override double Add( double x, double y )
+    {
+      return x + y;
+    }
+
+    protected override double Substract( double x, double y )
+    {
+      return x - y;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/FenwickTree.Generic.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/FenwickTree.Generic.cs
new file mode 100644
index 00000000..6f75e22a
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/FenwickTree.Generic.cs
@@ -0,0 +1,134 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Utils.Collections
+{
+  internal abstract class FenwickTree<T>
+  {
+    #region Constructor
+
+    protected FenwickTree( int capacity )
+    {
+      if( capacity < 0 )
+        throw new ArgumentException( "The capacity must be greater than or equal to zero.", "capacity" );
+
+      if( capacity > 0 )
+      {
+        m_collection = new T[ capacity + 1 ];
+      }
+    }
+
+    #endregion
+
+    #region Count Property
+
+    public int Count
+    {
+      get
+      {
+        if( m_collection != null )
+          return m_collection.Length - 1;
+
+        return 0;
+      }
+    }
+
+    #endregion
+
+    #region [] Property
+
+    public T this[ int index ]
+    {
+      get
+      {
+        return this.GetRunningSum( index, index );
+      }
+      set
+      {
+        var current = this[ index ];
+        if( object.Equals( current, value ) )
+          return;
+
+        var diff = this.Substract( value, current );
+        var x = FenwickTree<T>.ConvertIndex( index );
+
+        while( x < m_collection.Length )
+        {
+          m_collection[ x ] = this.Add( m_collection[ x ], diff );
+          x += FenwickTree<T>.FindLastDigit( x );
+        }
+      }
+    }
+
+    #endregion
+
+    public T GetRunningSum( int index )
+    {
+      return this.GetRunningSum( 0, index );
+    }
+
+    public T GetRunningSum( int startIndex, int endIndex )
+    {
+      if( ( startIndex < 0 ) || ( startIndex >= this.Count ) )
+        throw new ArgumentOutOfRangeException( "startIndex", startIndex, "The index must be greater or equal to zero and lesser than the collection Count." );
+
+      if( ( endIndex < 0 ) || ( endIndex >= this.Count ) )
+        throw new ArgumentOutOfRangeException( "endIndex", endIndex, "The index must be greater or equal to zero and lesser than the collection Count." );
+
+      if( startIndex > endIndex )
+        throw new ArgumentException( "The start index must be lesser than or equal to the end index.", "startIndex" );
+
+      var x = FenwickTree<T>.ConvertIndex( endIndex );
+      var y = FenwickTree<T>.ConvertIndex( startIndex - 1 );
+      var sum = default( T );
+
+      while( x > y )
+      {
+        sum = this.Add( sum, m_collection[ x ] );
+        x -= FenwickTree<T>.FindLastDigit( x );
+      }
+
+      while( y > x )
+      {
+        sum = this.Substract( sum, m_collection[ y ] );
+        y -= FenwickTree<T>.FindLastDigit( y );
+      }
+
+      return sum;
+    }
+
+    protected abstract T Add( T x, T y );
+    protected abstract T Substract( T x, T y );
+
+    private static int ConvertIndex( int value )
+    {
+      return value + 1;
+    }
+
+    private static int FindLastDigit( int value )
+    {
+      return ( value & -value );
+    }
+
+    #region Private Fields
+
+    private T[] m_collection; //null
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/IndexWeakHeapSort.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/IndexWeakHeapSort.cs
index 2d827c5d..673d1dfa 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/IndexWeakHeapSort.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/IndexWeakHeapSort.cs
@@ -38,7 +38,7 @@ namespace Xceed.Utils.Collections
         throw new InvalidOperationException( "A dataIndexArray must be passed at construction in order to sort." );
 
       if( length < 0 )
-        throw new ArgumentOutOfRangeException( "length", length, "length must be greater than or equal to zero." );        
+        throw new ArgumentOutOfRangeException( "length", length, "length must be greater than or equal to zero." );
 
       if( length >= m_dataIndexArray.Length )
         throw new ArgumentOutOfRangeException( "length", length, "length must be less than dataIndexArray.Length - 1." );
@@ -52,7 +52,9 @@ namespace Xceed.Utils.Collections
 
         // Gparent //
         while( ( parent & 1 ) == 0 )
+        {
           parent >>= 1;
+        }
 
         parent >>= 1;
         // End GParent //
@@ -100,7 +102,7 @@ namespace Xceed.Utils.Collections
       }
 
       do
-      { 
+      {
         // Merge //
         if( this.Compare( m_dataIndexArray[ m ], m_dataIndexArray[ x ] ) < 0 )
         {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/LongestIncreasingSubsequence.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/LongestIncreasingSubsequence.cs
new file mode 100644
index 00000000..b5ca6012
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/LongestIncreasingSubsequence.cs
@@ -0,0 +1,119 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace Xceed.Utils.Collections
+{
+  internal static class LongestIncreasingSubsequence
+  {
+    internal static IList<int> Find( IList<int> values )
+    {
+      if( values == null )
+        throw new ArgumentNullException( "values" );
+
+      if( values.Count <= 0 )
+        return new int[ 0 ];
+
+      var maximum = 1;
+      var predecessors = new int[ values.Count ];
+      var positions = new int[ values.Count ];
+
+      predecessors[ 0 ] = -1;
+      positions[ 0 ] = 0;
+
+      for( var i = 1; i < values.Count; i++ )
+      {
+        // We have found an element that extend the longest subsequence found so far.
+        if( values[ i ] > values[ positions[ maximum - 1 ] ] )
+        {
+          predecessors[ i ] = positions[ maximum - 1 ];
+          positions[ maximum ] = i;
+          maximum++;
+        }
+        else
+        {
+          var index = LongestIncreasingSubsequence.FindLeastIndex( i, values, positions, maximum );
+
+          // This is the lowest value found so far.
+          if( index < 0 )
+          {
+            predecessors[ i ] = -1;
+            positions[ 0 ] = i;
+          }
+          // We have found an element that could help to find new future subsequences.
+          else
+          {
+            Debug.Assert( index + 1 < maximum );
+
+            predecessors[ i ] = positions[ index ];
+            positions[ index + 1 ] = i;
+          }
+        }
+      }
+
+      var result = new int[ maximum ];
+      var position = positions[ maximum - 1 ];
+
+      for( var i = maximum - 1; i >= 0; i-- )
+      {
+        result[ i ] = values[ position ];
+        position = predecessors[ position ];
+      }
+
+      return result;
+    }
+
+    private static int FindLeastIndex( int index, IList<int> values, int[] positions, int maximum )
+    {
+      Debug.Assert( ( values != null ) && ( values.Count > 0 ) );
+      Debug.Assert( ( positions != null ) && ( maximum <= positions.Length ) );
+      Debug.Assert( ( index >= 0 ) && ( index < values.Count ) );
+
+      var lower = 0;
+      var upper = maximum - 1;
+      var value = values[ index ];
+
+      while( lower <= upper )
+      {
+        var middle = lower + ( upper - lower ) / 2;
+        var compare = value.CompareTo( values[ positions[ middle ] ] );
+
+        if( compare <= 0 )
+        {
+          if( middle == 0 )
+            break;
+
+          if( lower == middle )
+            return middle - 1;
+
+          upper = middle - 1;
+        }
+        else
+        {
+          if( upper == middle )
+            return middle;
+
+          lower = middle + 1;
+        }
+      }
+
+      return -1;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/ObservableHashList.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/ObservableHashList.cs
index 47feb128..dd294afe 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/ObservableHashList.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Collections/ObservableHashList.cs
@@ -15,14 +15,14 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.Specialized;
-using Xceed.Wpf.DataGrid;
-using Xceed.Utils.Data;
-using System.Diagnostics;
 using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using Xceed.Wpf.DataGrid;
 
 namespace Xceed.Utils.Collections
 {
@@ -34,6 +34,12 @@ namespace Xceed.Utils.Collections
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix" )]
   public sealed class ObservableHashList : IList, INotifyCollectionChanged, INotifyPropertyChanged
   {
+    #region CONSTANTS
+
+    private const int UseHashSetThreshold = 10;
+
+    #endregion
+
     #region INTERNAL CONSTRUCTOR
 
     internal ObservableHashList()
@@ -44,26 +50,34 @@ namespace Xceed.Utils.Collections
 
     #region IList Members
 
-    public int Add( object value )
+    public bool IsFixedSize
+    {
+      get
+      {
+        return false;
+      }
+    }
+
+    public bool IsReadOnly
     {
-      if( !m_hashSet.Add( value ) )
+      get
       {
-        string strValue = ( value == null ) ? "null" : value.ToString();
-        throw new ArgumentException( "Item has already been added. (Key being added: '" + strValue + "')", "value" );
+        return false;
       }
+    }
 
-      int index = m_list.Add( value );
+    public int Add( object value )
+    {
+      int index = this.Count;
+      this.InsertCore( index, value );
 
-      this.OnPropertyChanged( "Item[]" );
-      this.OnPropertyChanged( "Count" );
-      this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, value, index ) );
       return index;
     }
 
     public void Clear()
     {
-      m_list.Clear();
-      m_hashSet.Clear();
+      m_items = null;
+      m_set = null;
       this.OnPropertyChanged( "Item[]" );
       this.OnPropertyChanged( "Count" );
       this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
@@ -71,84 +85,67 @@ namespace Xceed.Utils.Collections
 
     public bool Contains( object value )
     {
-      return m_hashSet.Contains( value );
-    }
+      if( m_set != null )
+        return m_set.Contains( value );
 
-    public int IndexOf( object value )
-    {
-      return m_list.IndexOf( value );
-    }
-
-    public void Insert( int index, object value )
-    {
-      if( !m_hashSet.Add( value ) )
-      {
-        string strValue = ( value == null ) ? "null" : value.ToString();
-        throw new ArgumentException( "Item has already been added. (Key being added: '" + strValue + "')", "value" );
-      }
+      if( m_items != null )
+        return m_items.Contains( value );
 
-      m_list.Insert( index, value );
-      this.OnPropertyChanged( "Item[]" );
-      this.OnPropertyChanged( "Count" );
-      this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, value, index ) );
+      return false;
     }
 
-    public bool IsFixedSize
+    public int IndexOf( object value )
     {
-      get
-      {
-        return false;
-      }
+      if( m_items == null )
+        return -1;
+
+      return m_items.IndexOf( value );
     }
 
-    public bool IsReadOnly
+    public void Insert( int index, object value )
     {
-      get
-      {
-        return false;
-      }
+      this.InsertCore( index, value );
     }
 
     public void Remove( object value )
     {
       int index = this.IndexOf( value );
+      if( index < 0 )
+        return;
 
-      if( index >= 0 )
-      {
-        m_hashSet.Remove( value );
-        m_list.RemoveAt( index );
-        this.OnPropertyChanged( "Item[]" );
-        this.OnPropertyChanged( "Count" );
-        this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Remove, value, index ) );
-      }
+      this.RemoveAtCore( index );
     }
 
     public void RemoveAt( int index )
     {
-      if( ( index < 0 ) || ( index >= this.Count ) )
-        throw new ArgumentOutOfRangeException( "index" );
-
-      object value = m_list[ index ];
-      m_hashSet.Remove( value );
-      m_list.RemoveAt( index );
-      this.OnPropertyChanged( "Item[]" );
-      this.OnPropertyChanged( "Count" );
-      this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Remove, value, index ) );
+      this.RemoveAtCore( index );
     }
 
     public object this[ int index ]
     {
       get
       {
-        return m_list[ index ];
+        if( ( index < 0 ) || ( index >= this.Count ) )
+          throw new ArgumentOutOfRangeException( "index" );
+
+        Debug.Assert( m_items != null );
+
+        return m_items[ index ];
       }
       set
       {
-        object oldValue = m_list[ index ];
-        m_list[ index ] = value;
-        this.OnPropertyChanged( "Item[]" );
-        this.OnPropertyChanged( "Count" );
-        this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Replace, value, oldValue, index ) );
+        int count = this.Count;
+        if( ( index < 0 ) || ( index > count ) )
+          throw new ArgumentOutOfRangeException( "index" );
+
+        if( index == count )
+        {
+          this.InsertCore( index, value );
+        }
+        else
+        {
+          this.ReplaceCore( index, value );
+        }
       }
     }
 
@@ -156,16 +153,14 @@ namespace Xceed.Utils.Collections
 
     #region ICollection Members
 
-    public void CopyTo( Array array, int index )
-    {
-      m_list.CopyTo( array, index );
-    }
-
     public int Count
     {
       get
       {
-        return m_list.Count;
+        if( m_items == null )
+          return 0;
+
+        return m_items.Count;
       }
     }
 
@@ -181,17 +176,34 @@ namespace Xceed.Utils.Collections
     {
       get
       {
-        return m_list.SyncRoot;
+        if( m_syncRoot == null )
+        {
+          Interlocked.CompareExchange<object>( ref m_syncRoot, new object(), null );
+        }
+
+        return m_syncRoot;
       }
     }
 
+    public void CopyTo( Array array, int index )
+    {
+      if( m_items == null )
+        return;
+
+      IList items = m_items;
+      items.CopyTo( array, index );
+    }
+
     #endregion
 
     #region IEnumerable Members
 
     public IEnumerator GetEnumerator()
     {
-      return m_list.GetEnumerator();
+      if( m_items == null )
+        return Enumerable.Empty<object>().GetEnumerator();
+
+      return m_items.GetEnumerator();
     }
 
     #endregion
@@ -204,14 +216,15 @@ namespace Xceed.Utils.Collections
     {
       if( m_deferOperationCount == 0 )
       {
-        if( this.CollectionChanged != null )
-        {
-          this.CollectionChanged( this, args );
-        }
+        var handler = this.CollectionChanged;
+        if( handler == null )
+          return;
+
+        handler.Invoke( this, args );
       }
       else
       {
-        m_operationsCount++;
+        m_deferOperationCount = m_deferOperationCount.DeferOperation();
       }
     }
 
@@ -228,13 +241,14 @@ namespace Xceed.Utils.Collections
 
     private void OnPropertyChanged( PropertyChangedEventArgs e )
     {
-      if( m_deferOperationCount == 0 )
-      {
-        if( this.PropertyChanged != null )
-        {
-          this.PropertyChanged( this, e );
-        }
-      }
+      if( m_deferOperationCount != 0 )
+        return;
+
+      var handler = this.PropertyChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, e );
     }
 
     #endregion
@@ -251,85 +265,299 @@ namespace Xceed.Utils.Collections
 
     public void Sort( IComparer comparer )
     {
-      if( comparer == null )
-        comparer = ObjectComparer.Singleton;
+      if( m_items == null )
+        return;
+
+      var comparerWrapper = new ComparerWrapper( ( comparer != null ) ? comparer : ObjectComparer.Singleton );
+      m_items.Sort( comparerWrapper );
+
+      this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+    }
+
+    private void InsertCore( int index, object value )
+    {
+      int count = this.Count;
+      if( ( index < 0 ) || ( index > count ) )
+        throw new ArgumentOutOfRangeException( "index" );
 
-      lock( this.SyncRoot )
+      if( m_items == null )
+      {
+        Debug.Assert( count == 0 );
+        m_items = new List<object>() { value };
+      }
+      else
       {
-        m_list.Sort( comparer );
-        this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
+        if( ( m_set == null ) && ( count >= ObservableHashList.UseHashSetThreshold ) )
+          m_set = new HashSet<object>( m_items );
+
+        if( this.Contains( value ) )
+          throw new ArgumentException( string.Format( "Item has already been added. (Key being added: '{0}')", "value", ( value == null ) ? "null" : value.ToString() ) );
+
+        m_items.Insert( index, value );
+
+        if( m_set != null )
+        {
+          var result = m_set.Add( value );
+          Debug.Assert( result );
+        }
       }
+
+      this.OnPropertyChanged( "Item[]" );
+      this.OnPropertyChanged( "Count" );
+      this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, value, index ) );
     }
 
-    private HashSet<object> m_hashSet = new HashSet<object>();
-    private ArrayList m_list = new ArrayList();
-    private int m_deferOperationCount;
-    private int m_operationsCount;
+    private void RemoveAtCore( int index )
+    {
+      int count = this.Count;
+      if( ( index < 0 ) || ( index >= count ) )
+        throw new ArgumentOutOfRangeException( "index" );
+
+      Debug.Assert( m_items != null );
+
+      object value = m_items[ index ];
+
+      if( count > 1 )
+      {
+        m_items.RemoveAt( index );
+      }
+      else
+      {
+        m_items = null;
+      }
+
+      if( m_set != null )
+      {
+        if( count > ObservableHashList.UseHashSetThreshold )
+        {
+          Debug.Assert( m_items != null );
+
+          m_set.Remove( value );
+        }
+        else
+        {
+          m_set = null;
+        }
+      }
+
+      this.OnPropertyChanged( "Item[]" );
+      this.OnPropertyChanged( "Count" );
+      this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Remove, value, index ) );
+    }
+
+    private void ReplaceCore( int index, object value )
+    {
+      Debug.Assert( ( index >= 0 ) && ( index < this.Count ) );
+      Debug.Assert( m_items != null );
+
+      if( m_items[ index ] == value )
+        return;
+
+      if( this.Contains( value ) )
+        throw new ArgumentException( string.Format( "Item has already been added. (Key being added: '{0}')", "value", ( value == null ) ? "null" : value.ToString() ) );
+
+      var oldValue = m_items[ index ];
+      m_items[ index ] = value;
+
+      if( m_set != null )
+      {
+        m_set.Remove( oldValue );
+        m_set.Add( value );
+      }
+
+      this.OnPropertyChanged( "Item[]" );
+      this.OnPropertyChanged( "Count" );
+      this.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Replace, value, oldValue, index ) );
+    }
+
+    #region Private Fields
 
-    #region DeferOperationNotifications class
+    private List<object> m_items; // = null
+    private HashSet<object> m_set; // = null
+    private DeferCount m_deferOperationCount;
+    private object m_syncRoot; // = null
+
+    #endregion
+
+    #region DeferOperationNotifications Class
 
     private class DeferOperationNotifications : IDisposable
     {
-      public DeferOperationNotifications( ObservableHashList list )
+      public DeferOperationNotifications( ObservableHashList owner )
       {
-        m_innerList = list;
-        m_innerList.m_deferOperationCount++;
+        Debug.Assert( owner != null );
+
+        m_owner = owner;
+        m_owner.m_deferOperationCount++;
       }
 
       public void Dispose()
       {
-        if( m_innerList == null )
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        var target = m_owner;
+        if( target == null )
           return;
 
-        m_innerList.m_deferOperationCount--;
+        target = Interlocked.CompareExchange( ref m_owner, null, target );
+        if( target == null )
+          return;
+
+        target.m_deferOperationCount--;
 
-        if( ( m_innerList.m_deferOperationCount == 0 ) && ( m_innerList.m_operationsCount > 0 ) )
+        if( target.m_deferOperationCount.HasDeferredOperation && ( target.m_deferOperationCount == 0 ) )
         {
           // We always force a Reset after any deferred operation
-          m_innerList.OnPropertyChanged( "Item[]" );
-          m_innerList.OnPropertyChanged( "Count" );
-          m_innerList.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
-          m_innerList.m_operationsCount = 0;
+          target.m_deferOperationCount = new DeferCount();
+          target.OnPropertyChanged( "Item[]" );
+          target.OnPropertyChanged( "Count" );
+          target.FireCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset ) );
         }
-        m_innerList = null;
       }
 
-      private ObservableHashList m_innerList; // = null;
+      ~DeferOperationNotifications()
+      {
+        this.Dispose( false );
+      }
+
+      private ObservableHashList m_owner; // = null;
     }
 
     #endregion
 
-    #region Debugger helper classes
+    #region Debugger Helper Class
 
     internal class ObservableHashListDebugView
     {
-      private ObservableHashList m_hashList;
+      public ObservableHashListDebugView( ObservableHashList list )
+      {
+        if( list == null )
+          throw new ArgumentNullException( "list" );
+
+        m_list = list;
+      }
 
-      public ObservableHashListDebugView( ObservableHashList hashlist )
+      public object[] Values
       {
-        if( hashlist == null )
+        get
         {
-          throw new ArgumentNullException( "hashlist" );
+          var items = m_list.m_items;
+          if( items == null )
+            return new object[ 0 ];
+
+          return items.ToArray();
         }
-        m_hashList = hashlist;
       }
 
-      public object[] Values
+      private readonly ObservableHashList m_list;
+    }
+
+    #endregion
+
+    #region ComparerWrapper Private Class
+
+    private sealed class ComparerWrapper : IComparer<object>
+    {
+      internal ComparerWrapper( IComparer comparer )
       {
-        get
+        Debug.Assert( comparer != null );
+
+        m_comparer = comparer;
+      }
+
+      public int Compare( object x, object y )
+      {
+        return m_comparer.Compare( x, y );
+      }
+
+      private readonly IComparer m_comparer;
+    }
+
+    #endregion
+
+    #region DeferCount Private Nested Type
+
+    private struct DeferCount
+    {
+      private const uint DeferredOperationMask = 1u << 31;
+      private const uint CountMask = ~DeferCount.DeferredOperationMask;
+
+      private DeferCount( int count, bool hasDeferredOperation )
+      {
+        if( count < 0 )
+          throw new ArgumentException( "count" );
+
+        uint data = ( uint )count;
+        if( hasDeferredOperation )
         {
-          object[] values = new object[ m_hashList.m_hashSet.Count ];
+          data |= DeferCount.DeferredOperationMask;
+        }
 
-          int i = 0;
-          foreach( object key in m_hashList.m_hashSet )
-          {
-            values[ i ] = key;
-            i++;
-          }
+        this.Data = data;
+      }
 
-          return values;
+      public int Count
+      {
+        get
+        {
+          return Convert.ToInt32( this.Data & DeferCount.CountMask );
         }
       }
+
+      public bool HasDeferredOperation
+      {
+        get
+        {
+          return ( this.Data & DeferCount.DeferredOperationMask ) != 0u;
+        }
+      }
+
+      public DeferCount DeferOperation()
+      {
+        if( this.HasDeferredOperation )
+          return this;
+
+        return new DeferCount( this.Count, true );
+      }
+
+      public static DeferCount operator ++( DeferCount source )
+      {
+        return source + 1;
+      }
+
+      public static DeferCount operator --( DeferCount source )
+      {
+        return source - 1;
+      }
+
+      public static DeferCount operator +( DeferCount source, int value )
+      {
+        if( value == 0 )
+          return source;
+
+        return new DeferCount( source.Count + value, source.HasDeferredOperation );
+      }
+
+      public static DeferCount operator -( DeferCount source, int value )
+      {
+        return source + ( -value );
+      }
+
+      public static implicit operator int( DeferCount source )
+      {
+        return source.Count;
+      }
+
+      public static implicit operator DeferCount( int count )
+      {
+        return new DeferCount( count, false );
+      }
+
+      private readonly uint Data;
     }
 
     #endregion
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/PropertyHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/PropertyHelper.cs
new file mode 100644
index 00000000..db465ea6
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/PropertyHelper.cs
@@ -0,0 +1,36 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Linq.Expressions;
+
+namespace Xceed.Wpf.DataGrid.Utils
+{
+  internal static class PropertyHelper
+  {
+    internal static string GetPropertyName<TSource, TResult>( Expression<Func<TSource, TResult>> expression )
+    {
+      if( expression == null )
+        throw new ArgumentNullException( "expression" );
+
+      var memberExpression = expression.Body as MemberExpression;
+      if( memberExpression == null )
+        throw new ArgumentException( "The body of the expression must be a MemberExpression.", "expression" );
+
+      return memberExpression.Member.Name;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/WeakEventHandler.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/WeakEventHandler.cs
index 683ec511..262b4d50 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/WeakEventHandler.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/WeakEventHandler.cs
@@ -22,14 +22,15 @@
  * ************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.ComponentModel;
 using System.Reflection;
 
 namespace Xceed.Wpf.DataGrid.Utils
 {
-  public sealed class WeakEventHandler<TEventArgs> 
+  [Obsolete( "TODODOC: This class is inefficient.  You should derive from System.Windows.WeakEventManager instead." )]
+  [Browsable( false )]
+  [EditorBrowsable( EditorBrowsableState.Never )]
+  public sealed class WeakEventHandler<TEventArgs>
     where TEventArgs : class
   {
     #region Constructors
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversal.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversal.cs
new file mode 100644
index 00000000..ded4203d
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversal.cs
@@ -0,0 +1,73 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Windows;
+
+namespace Xceed.Utils.Wpf
+{
+  internal sealed class BreadthFirstSearchTreeTraversal : ITreeTraversal
+  {
+    #region Current Property
+
+    public DependencyObject Current
+    {
+      get
+      {
+        if( m_current == null )
+          throw new InvalidOperationException();
+
+        return m_current;
+      }
+    }
+
+    private DependencyObject m_current; //null
+
+    #endregion
+
+    public bool MoveNext()
+    {
+      if( m_collection.Count > 0 )
+      {
+        m_current = m_collection.Dequeue();
+        return true;
+      }
+      else
+      {
+        m_current = null;
+        return false;
+      }
+    }
+
+    public void VisitNodes( IEnumerable<DependencyObject> nodes )
+    {
+      if( nodes == null )
+        return;
+
+      foreach( var node in nodes )
+      {
+        m_collection.Enqueue( node );
+      }
+    }
+
+    #region Private Fields
+
+    private readonly Queue<DependencyObject> m_collection = new Queue<DependencyObject>();
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversalStrategy.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversalStrategy.cs
new file mode 100644
index 00000000..243e2761
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/BreadthFirstSearchTreeTraversalStrategy.cs
@@ -0,0 +1,27 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+
+namespace Xceed.Utils.Wpf
+{
+  internal sealed class BreadthFirstSearchTreeTraversalStrategy : ITreeTraversalStrategy
+  {
+    public ITreeTraversal Create()
+    {
+      return new BreadthFirstSearchTreeTraversal();
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversal.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversal.cs
new file mode 100644
index 00000000..275e161e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversal.cs
@@ -0,0 +1,73 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+
+namespace Xceed.Utils.Wpf
+{
+  internal sealed class DepthFirstSearchTreeTraversal : ITreeTraversal
+  {
+    #region Current Property
+
+    public DependencyObject Current
+    {
+      get
+      {
+        if( m_current == null )
+          throw new InvalidOperationException();
+
+        return m_current;
+      }
+    }
+
+    private DependencyObject m_current; //null
+
+    #endregion
+
+    public bool MoveNext()
+    {
+      var lastIndex = m_collection.Count - 1;
+      if( lastIndex >= 0 )
+      {
+        m_current = m_collection[ lastIndex ];
+        m_collection.RemoveAt( lastIndex );
+        return true;
+      }
+      else
+      {
+        m_current = null;
+        return false;
+      }
+    }
+
+    public void VisitNodes( IEnumerable<DependencyObject> nodes )
+    {
+      if( nodes == null )
+        return;
+
+      m_collection.AddRange( nodes.Reverse() );
+    }
+
+    #region Private Fields
+
+    private readonly List<DependencyObject> m_collection = new List<DependencyObject>();
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversalStrategy.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversalStrategy.cs
new file mode 100644
index 00000000..60e84389
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DepthFirstSearchTreeTraversalStrategy.cs
@@ -0,0 +1,27 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+
+namespace Xceed.Utils.Wpf
+{
+  internal sealed class DepthFirstSearchTreeTraversalStrategy : ITreeTraversalStrategy
+  {
+    public ITreeTraversal Create()
+    {
+      return new DepthFirstSearchTreeTraversal();
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DispatcherHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DispatcherHelper.cs
index e7529b4d..fa35b536 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DispatcherHelper.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DispatcherHelper.cs
@@ -22,7 +22,7 @@ namespace Xceed.Utils.Wpf
 {
   internal static class DispatcherHelper
   {
-    private static object ExitFrame( Object state )
+    private static object ExitFrame( object state )
     {
       DispatcherFrame frame = state as DispatcherFrame;
       frame.Continue = false;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/AutoScrollManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/AutoScrollManager.cs
new file mode 100644
index 00000000..73ff4283
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/AutoScrollManager.cs
@@ -0,0 +1,236 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+namespace Xceed.Utils.Wpf.DragDrop
+{
+  internal class AutoScrollManager : DependencyObject
+  {
+    public const int AutoScrollInterval_DefaultValue = 50;
+    public const int AutoScrollTreshold_DefaultValue = 5;
+
+    public AutoScrollManager(ScrollViewer scrollViewer)
+    {
+      if( scrollViewer == null )
+        throw new ArgumentNullException( "scrollViewer" );
+
+      m_scrollViewer = scrollViewer;
+      m_timer = new System.Windows.Threading.DispatcherTimer();
+      m_timer.Interval = new TimeSpan( 0, 0, 0, 0, 0 );
+      m_timer.Tick += new EventHandler( this.OnAutoScrollTimer_Tick );
+
+      this.AutoScrollInterval = AutoScrollInterval_DefaultValue;
+      this.AutoScrollTreshold = AutoScrollTreshold_DefaultValue;
+    }
+
+    #region AutoScrollInterval Property
+
+    public int AutoScrollInterval
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region AutoScrollTreshold Property
+
+    public int AutoScrollTreshold
+    {
+      get;
+      set;
+    }
+
+    #endregion
+
+    #region property ScrollViewer Property
+
+    public ScrollViewer ScrollViewer
+    {
+      get { return m_scrollViewer; }
+    }
+
+    #endregion
+
+    public event EventHandler AutoScrolled;
+
+    private void OnAutoScrollTimer_Tick( object sender, EventArgs e )
+    {
+      this.PerformAutoScroll();
+    }
+
+    public void StopAutoScroll()
+    {
+      m_timer.Stop();
+    }
+
+    internal void ProcessMouseMove( MouseEventArgs e )
+    {
+      Point clientMousePosition = e.GetPosition( m_scrollViewer );
+
+      Size scrollViewerRenderSize = m_scrollViewer.RenderSize;
+
+      m_autoScrollDirection = AutoScrollDirection.None;
+      if( m_scrollViewer.ScrollableWidth > 0 && scrollViewerRenderSize.Width > 0)
+      {
+        double mouseEdgeDistance = 0d;
+        if( ( clientMousePosition.X < AutoScrollTreshold ) && ( m_scrollViewer.HorizontalOffset > 0 ) )
+        {
+          m_autoScrollDirection |= AutoScrollDirection.Left;
+          mouseEdgeDistance = clientMousePosition.X - AutoScrollTreshold;
+        }
+        //Scrolling right
+        else if( ( clientMousePosition.X > scrollViewerRenderSize.Width - AutoScrollTreshold ) && ( m_scrollViewer.HorizontalOffset < m_scrollViewer.ScrollableWidth ) )
+        {
+          m_autoScrollDirection |= AutoScrollDirection.Right;
+          mouseEdgeDistance = ( clientMousePosition.X - ( scrollViewerRenderSize.Width - AutoScrollTreshold ) );
+        }
+
+        //We need a scroll value in units that can be pixels or units (eg. rows)
+        //Store a distance ratio based mouse edge distance in relation to the view width
+        m_horizontalPageScrollRatio = mouseEdgeDistance / scrollViewerRenderSize.Width;
+      }
+
+      if( m_scrollViewer.ScrollableHeight > 0 )
+      {
+        if( ( clientMousePosition.Y < AutoScrollTreshold ) && ( m_scrollViewer.VerticalOffset > 0 ) )
+        {
+          m_autoScrollDirection |= AutoScrollDirection.Up;
+        }
+        else if( ( clientMousePosition.Y > scrollViewerRenderSize.Height - AutoScrollTreshold )
+            && ( m_scrollViewer.VerticalOffset < m_scrollViewer.ScrollableHeight ) )
+        {
+          m_autoScrollDirection |= AutoScrollDirection.Down;
+        }
+      }
+
+      if( m_autoScrollDirection == AutoScrollDirection.None )
+      {
+        this.StopAutoScroll();
+      }
+      else
+      {
+        // The DispatcherTimer is not a priority event. The Tick event won't fire while  the user moves the mouse pointer. That's why we manually call the 
+        // PerformAutoScroll method (on each MouseMove, i.e. Drag). When the user doesn't move the mouse pointer, the timer will take over to do the AutoScroll.
+        if( !m_timer.IsEnabled )
+        {
+          m_timer.Start();
+        }
+
+        this.PerformAutoScroll();
+      }
+    }
+
+    private void PerformAutoScroll()
+    {
+      if(  m_timer.IsEnabled )
+      {
+        TimeSpan timeSpanSinceLastScroll = ( TimeSpan )( DateTime.UtcNow - m_lastAutoScrollTime );
+
+        // This method may be called before its time (on the MouseMove event). We make sure that the AutoScroll is not performed before the desired time span has elapsed.
+        if( timeSpanSinceLastScroll.Milliseconds >= AutoScrollInterval )
+        {
+          double scrollUnits = ( m_horizontalPageScrollRatio * m_scrollViewer.ViewportWidth );
+
+          if( ( m_autoScrollDirection & AutoScrollDirection.Left ) == AutoScrollDirection.Left )
+          {
+            //Minimum 1 unit
+            scrollUnits = System.Math.Min( -1d, scrollUnits );
+            double scrollOffset = m_scrollViewer.HorizontalOffset + scrollUnits;
+
+            //Maximum 1 page
+            if(m_horizontalPageScrollRatio <= -1d)
+            {
+              m_scrollViewer.PageLeft();
+            }
+            else
+            {
+              //Make sure the grid stops scrolling.
+              if( scrollOffset < 0 )
+              {
+                scrollOffset = 0;
+              }
+              m_scrollViewer.ScrollToHorizontalOffset( scrollOffset );
+            }
+          }
+          else if( ( m_autoScrollDirection & AutoScrollDirection.Right ) == AutoScrollDirection.Right )
+          {
+            //Minimum 1 unit
+            scrollUnits = System.Math.Max( 1d, scrollUnits );
+            double scrollOffset = m_scrollViewer.HorizontalOffset + scrollUnits;
+
+            //Maxium 1 page
+            if( m_horizontalPageScrollRatio >= 1d )
+            {
+              m_scrollViewer.PageRight();
+            }
+            else
+            {
+              //Make sure the grid does not scroll pass the last right column.
+              if( scrollOffset > m_scrollViewer.ScrollableWidth )
+              {
+                scrollOffset = m_scrollViewer.ScrollableWidth;
+              }
+              m_scrollViewer.ScrollToHorizontalOffset( scrollOffset );
+            }
+          }
+          else if( ( m_autoScrollDirection & AutoScrollDirection.Up ) == AutoScrollDirection.Up )
+          {
+            m_scrollViewer.LineUp();
+          }
+          else if( ( m_autoScrollDirection & AutoScrollDirection.Down ) == AutoScrollDirection.Down )
+          {
+            m_scrollViewer.LineDown();
+          }
+
+          m_lastAutoScrollTime = DateTime.UtcNow;
+
+          if( this.AutoScrolled != null )
+          {
+            this.AutoScrolled( this, EventArgs.Empty );
+          }
+
+        }
+      }
+    }
+
+    private AutoScrollDirection m_autoScrollDirection = AutoScrollDirection.None;
+    private ScrollViewer m_scrollViewer;
+    private DispatcherTimer m_timer = null;
+    private DateTime m_lastAutoScrollTime;
+    private double m_horizontalPageScrollRatio;
+
+    [Flags()]
+    private enum AutoScrollDirection
+    {
+      None = 0,
+      Left = 1,
+      Right = 2,
+      Up = 4,
+      Down = 8
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/DragSourceManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/DragSourceManager.cs
index c8b5da44..6ee40888 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/DragSourceManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/DragDrop/DragSourceManager.cs
@@ -15,55 +15,34 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Windows;
-using System.Windows.Input;
-using System.Diagnostics;
 using System.ComponentModel;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
 using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Interop;
 using System.Windows.Media;
-using System.Windows.Controls;
 using System.Windows.Shapes;
 using System.Windows.Threading;
 using Xceed.Wpf.DataGrid;
-using System.Windows.Navigation;
-using System.Windows.Controls.Primitives;
 
 namespace Xceed.Utils.Wpf.DragDrop
 {
   internal class DragSourceManager : DependencyObject, INotifyPropertyChanged
   {
-    public DragSourceManager(
-      UIElement draggedElement,
-      AdornerLayer adornerLayerInsideDragContainer,
-      UIElement dragContainer )
-      : this( draggedElement,
-              adornerLayerInsideDragContainer,
-              dragContainer,
-              true )
+    public DragSourceManager( UIElement draggedElement, AdornerLayer adornerLayerInsideDragContainer, UIElement dragContainer )
+      : this( draggedElement, adornerLayerInsideDragContainer, dragContainer, true )
     {
     }
 
-    public DragSourceManager(
-      UIElement draggedElement,
-      AdornerLayer adornerLayerInsideDragContainer,
-      UIElement dragContainer,
-      bool enableAutoScroll )
-      : this( draggedElement,
-              adornerLayerInsideDragContainer,
-              dragContainer,
-              enableAutoScroll,
-              true )
+    public DragSourceManager( UIElement draggedElement, AdornerLayer adornerLayerInsideDragContainer, UIElement dragContainer, bool enableAutoScroll )
+      : this( draggedElement, adornerLayerInsideDragContainer, dragContainer, enableAutoScroll, true )
     {
     }
 
-    public DragSourceManager(
-      UIElement draggedElement,
-      AdornerLayer adornerLayerInsideDragContainer,
-      UIElement dragContainer,
-      bool enableAutoScroll,
-      bool showDraggedElementGhost )
+    public DragSourceManager( UIElement draggedElement, AdornerLayer adornerLayerInsideDragContainer, UIElement dragContainer, bool enableAutoScroll, bool showDraggedElementGhost )
     {
       if( draggedElement == null )
         throw new ArgumentNullException( "draggedElement" );
@@ -100,10 +79,10 @@ namespace Xceed.Utils.Wpf.DragDrop
             break;
         }
 
-        m_parentScrollViewer = scrollViewer;
-        m_timer = new System.Windows.Threading.DispatcherTimer();
-        m_timer.Interval = new TimeSpan( 0, 0, 0, 0, this.TimerInterval );
-        m_timer.Tick += new EventHandler( this.OnAutoScrollTimer_Tick );
+        if( scrollViewer != null )
+        {
+          m_autoScrollManager = new AutoScrollManager( scrollViewer );
+        }
       }
     }
 
@@ -190,6 +169,24 @@ namespace Xceed.Utils.Wpf.DragDrop
 
     #endregion
 
+    #region MouseToScreenPositionFactor Read-Only Public Property
+
+    internal Vector MouseToScreenPositionFactor
+    {
+      get
+      {
+        return m_mouseToScreenPositionFactor;
+      }
+      private set
+      {
+        m_mouseToScreenPositionFactor = value;
+      }
+    }
+
+    private Vector m_mouseToScreenPositionFactor = new Vector( 1d, 1d );
+
+    #endregion
+
     #region ShowDraggedElementGhost Public Property
 
     public bool ShowDraggedElementGhost
@@ -226,7 +223,7 @@ namespace Xceed.Utils.Wpf.DragDrop
     {
       get
       {
-        return m_parentScrollViewer;
+        return ( m_autoScrollManager != null ) ? m_autoScrollManager.ScrollViewer : null;
       }
     }
 
@@ -238,7 +235,7 @@ namespace Xceed.Utils.Wpf.DragDrop
       "AutoScrollInterval",
       typeof( int ),
       typeof( DragSourceManager ),
-      new FrameworkPropertyMetadata( 50 ) );
+      new FrameworkPropertyMetadata( AutoScrollManager.AutoScrollInterval_DefaultValue, OnAutoScrollIntervalChanged ) );
 
     public int AutoScrollInterval
     {
@@ -252,6 +249,15 @@ namespace Xceed.Utils.Wpf.DragDrop
       }
     }
 
+    private static void OnAutoScrollIntervalChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
+    {
+      var autoScrollManager = ( ( DragSourceManager )sender ).m_autoScrollManager;
+      if( autoScrollManager != null )
+      {
+        autoScrollManager.AutoScrollInterval = ( int )args.NewValue;
+      }
+    }
+
     #endregion
 
     #region TimerInterval Property
@@ -270,7 +276,7 @@ namespace Xceed.Utils.Wpf.DragDrop
       "AutoScrollTreshold",
       typeof( int ),
       typeof( DragSourceManager ),
-      new FrameworkPropertyMetadata( 5 ) );
+      new FrameworkPropertyMetadata( AutoScrollManager.AutoScrollTreshold_DefaultValue, OnAutoScrollTresholdChanged ) );
 
     public int AutoScrollTreshold
     {
@@ -284,6 +290,15 @@ namespace Xceed.Utils.Wpf.DragDrop
       }
     }
 
+    private static void OnAutoScrollTresholdChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
+    {
+      var autoScrollManager = ( ( DragSourceManager )sender ).m_autoScrollManager;
+      if( autoScrollManager != null )
+      {
+        autoScrollManager.AutoScrollTreshold = ( int )args.NewValue;
+      }
+    }
+
     #endregion
 
     #region DropOutsideCursor Property
@@ -336,39 +351,22 @@ namespace Xceed.Utils.Wpf.DragDrop
       this.CheckMouseEventArgs( e );
 #endif
 
-      bool captured = this.DraggedElement.CaptureMouse();
-
-      if( captured )
+      if( !this.DraggedElement.CaptureMouse() )
       {
-        this.InitialMousePositionToDragContainerAdorner = e.GetPosition( this.AdornerLayerInsideDragContainer );
-
-        this.InitialMousePositionToDraggedElement = e.GetPosition( this.DraggedElement );
+        Debug.Fail( "The DragSourceManager was unable to capture the mouse on the dragged element." );
+        return;
+      }
 
-        //Get the current window (which can be a popup) on which the drag is happening
-        Visual parent = this.GetDraggedElementWindow();
+      //Get the current window (which can be a popup) on which the drag is happening
+      var parent = this.GetDraggedElementWindow();
 
-        //Set the flag because the dragged ghost in the case of a popup is different, and return because DraggedElementGhost will not be used.
-        if( parent is Popup )
-        {
-          this.ParentWindowIsPopup = true;
-          return;
-        }
+      this.InitialMousePositionToDragContainerAdorner = e.GetPosition( this.AdornerLayerInsideDragContainer );
+      this.InitialMousePositionToDraggedElement = e.GetPosition( this.DraggedElement );
+      this.MouseToScreenPositionFactor = DragSourceManager.CalculateMouseToScreenPositionFactor( parent );
+      this.ParentWindowIsPopup = ( parent is Popup );
 
-        //Get the starting position of the gost window, so it can be used to correct the mouse position while dragging it.  
-        Point ghostPostion = new Point( -this.InitialMousePositionToDraggedElement.Value.X, -this.InitialMousePositionToDraggedElement.Value.Y );
-        if( parent != null )
-        {
-          m_ghostInitialScreenPositon = parent.PointToScreen( ghostPostion );
-        }
-        else
-        {
-          m_ghostInitialScreenPositon = ghostPostion;
-        }
-      }
-      else
-      {
-        Debug.Fail( "The DragSourceManager was unable to capture the mouse on the dragged element." );
-      }
+      var draggedElementMousePosition = e.GetPosition( this.DraggedElement );
+      m_draggedElementMouseOffset = new Vector( draggedElementMousePosition.X, draggedElementMousePosition.Y );
     }
 
     public virtual void ProcessPreviewMouseRightButtonDown( MouseButtonEventArgs e )
@@ -384,8 +382,7 @@ namespace Xceed.Utils.Wpf.DragDrop
       this.CheckMouseEventArgs( e );
 #endif
 
-      if( ( this.InitialMousePositionToDragContainerAdorner.HasValue )
-          && ( e.LeftButton == MouseButtonState.Pressed ) )
+      if( ( this.InitialMousePositionToDragContainerAdorner.HasValue ) && ( e.LeftButton == MouseButtonState.Pressed ) )
       {
         if( !this.IsDragging )
         {
@@ -432,8 +429,7 @@ namespace Xceed.Utils.Wpf.DragDrop
       if( this.ParentWindowIsPopup )
         return;
 
-      Window ghost = this.DraggedElementGhost;
-
+      var ghost = this.DraggedElementGhost;
       if( ghost == null )
         return;
 
@@ -446,12 +442,22 @@ namespace Xceed.Utils.Wpf.DragDrop
         ghost.Hide();
       }
 
-      //Get the current position of the mouse
-      Point currentMousePosition = e.GetPosition( null );
+      //Find the new ghost position based on the current mouse position.
+      var mousePosition = e.GetPosition( this.DragContainer );
+      var draggedElementPosition = Point.Subtract( mousePosition, m_draggedElementMouseOffset );
+
+      if( FrameworkElement.GetFlowDirection( this.DragContainer ) != FlowDirection.LeftToRight )
+      {
+        draggedElementPosition.X += this.DraggedElement.RenderSize.Width;
+      }
+
+      var draggedElementPositionOnScreen = this.DragContainer.PointToScreen( draggedElementPosition );
+
+      var ghostPosition = new Point( draggedElementPositionOnScreen.X * m_mouseToScreenPositionFactor.X,
+                                     draggedElementPositionOnScreen.Y * m_mouseToScreenPositionFactor.Y );
 
-      //And set the ghost position by correcting the mouse position.
-      ghost.Left = currentMousePosition.X + m_ghostInitialScreenPositon.X;
-      ghost.Top = currentMousePosition.Y + m_ghostInitialScreenPositon.Y;
+      ghost.Left = ghostPosition.X;
+      ghost.Top = ghostPosition.Y;
     }
 
     protected virtual IDropTarget GetDropTargetOnDrag( MouseEventArgs e, out Nullable<Point> dropTargetPosition, out IDropTarget lastFoundDropTarget )
@@ -518,75 +524,15 @@ namespace Xceed.Utils.Wpf.DragDrop
 
     protected virtual void StopAutoScroll()
     {
-      if( m_timer != null )
+      if( m_autoScrollManager != null )
       {
-        m_timer.Stop();
-      }
-    }
-
-    protected virtual void PerformAutoScroll()
-    {
-      if( ( m_timer != null ) && ( m_timer.IsEnabled ) )
-      {
-        TimeSpan timeSpanSinceLastScroll = ( TimeSpan )( DateTime.Now - m_lastAutoScrollTime );
-
-        // This method may be called before its time (on the MouseMove event). We make
-        // sure that the AutoScroll is not performed before the desired time span has elapsed.
-        if( timeSpanSinceLastScroll.Milliseconds >= AutoScrollInterval )
-        {
-          double scrollOffset = m_parentScrollViewer.HorizontalOffset + m_scrollAmount;
-
-          if( ( m_autoScrollDirection & AutoScrollDirection.Left ) == AutoScrollDirection.Left )
-          {
-            if( m_scrollPage )
-            {
-              m_parentScrollViewer.PageLeft();
-            }
-            else
-            {
-              //Make sure the grid stops scrolling.
-              if( scrollOffset < 0 )
-              {
-                scrollOffset = 0;
-              }
-              m_parentScrollViewer.ScrollToHorizontalOffset( scrollOffset );
-            }
-          }
-          else if( ( m_autoScrollDirection & AutoScrollDirection.Right ) == AutoScrollDirection.Right )
-          {
-            if( m_scrollPage )
-            {
-              m_parentScrollViewer.PageRight();
-            }
-            else
-            {
-              //Make sure the grid does not scroll pass the last right column.
-              if( scrollOffset > m_maxHorizontalScrollOffset )
-              {
-                scrollOffset = m_maxHorizontalScrollOffset;
-              }
-              m_parentScrollViewer.ScrollToHorizontalOffset( scrollOffset );
-            }
-          }
-          else if( ( m_autoScrollDirection & AutoScrollDirection.Up ) == AutoScrollDirection.Up )
-          {
-            m_parentScrollViewer.LineUp();
-          }
-          else if( ( m_autoScrollDirection & AutoScrollDirection.Down ) == AutoScrollDirection.Down )
-          {
-            m_parentScrollViewer.LineDown();
-          }
-
-          m_lastAutoScrollTime = DateTime.Now;
-        }
+        m_autoScrollManager.StopAutoScroll();
       }
     }
 
     protected virtual void NotifyDragOutsideQueryCursor( object sender, QueryCursorEventArgs e )
     {
-      e.Cursor = ( this.DropOutsideCursor != null )
-        ? this.DropOutsideCursor
-        : Cursors.No;
+      e.Cursor = ( this.DropOutsideCursor != null ) ? this.DropOutsideCursor : Cursors.No;
 
       if( this.DragOutsideQueryCursor != null )
       {
@@ -660,13 +606,12 @@ namespace Xceed.Utils.Wpf.DragDrop
 
       this.ProcessDragOnCurrentDropTarget( dropTarget );
 
-      // Call this method after the drag is processed in case
-      // the ShowDraggedElementGhost property was modified by the GetDropTargetOnDrag
+      // Call this method after the drag is processed in case the ShowDraggedElementGhost property was modified by the GetDropTargetOnDrag
       this.UpdateDraggedElementGhostOnDrag( e );
 
-      if( m_parentScrollViewer != null )
+      if( m_autoScrollManager != null )
       {
-        this.CheckForAutoScroll( e.GetPosition( m_parentScrollViewer ) );
+        m_autoScrollManager.ProcessMouseMove( e );
       }
     }
 
@@ -691,127 +636,90 @@ namespace Xceed.Utils.Wpf.DragDrop
       }
     }
 
-    private Visual GetDraggedElementWindow()
-    {
-      DependencyObject current = this.DraggedElement;
-      while( current != null )
-      {
-        Popup popup = current as Popup;
-
-        //If the grid is in a popup, this becomes the owning window, so return it.
-        if( popup != null )
-          return popup;
-
-        Window window = current as Window;
-
-        if( window != null )
-          return window;
-
-        current = TreeHelper.GetParent( current );
-      }
-
-      // The dragged element's window was not found.
-      return null;
-    }
-
-    private void CheckForAutoScroll( Point clientMousePosition )
+    private static Vector CalculateMouseToScreenPositionFactor( FrameworkElement element )
     {
-      if( m_timer == null )
-        return; // AutoScroll is not active
-
-      Size scrollViewerRenderSize = m_parentScrollViewer.RenderSize;
+      if( element == null )
+        return new Vector( 1d, 1d );
 
-      m_autoScrollDirection = AutoScrollDirection.None;
-      if( m_parentScrollViewer.ScrollableWidth > 0 )
+      var source = PresentationSource.FromVisual( element );
+      if( source == null )
       {
-        //Calculate the right edge maximum scroll offset
-        m_maxHorizontalScrollOffset = m_parentScrollViewer.ExtentWidth - scrollViewerRenderSize.Width;
-
-        //Scrolling left
-        if( ( clientMousePosition.X < AutoScrollTreshold ) &&
-            ( m_parentScrollViewer.HorizontalOffset > 0 ) )
+        var parent = DragSourceManager.GetPopupParent( element );
+        while( parent != null )
         {
-          m_autoScrollDirection |= AutoScrollDirection.Left;
-          m_scrollAmount = -1;
-
-          if( clientMousePosition.X < -1 )
-          {
-            m_scrollAmount = clientMousePosition.X;
-          }
+          source = PresentationSource.FromDependencyObject( parent );
+          if( source != null )
+            break;
 
-          //Scroll to a maximum of one page at a time.
-          if( m_scrollAmount < -scrollViewerRenderSize.Width )
-          {
-            m_scrollPage = true;
-          }
-          else
-          {
-            m_scrollPage = false;
-          }
+          parent = DragSourceManager.GetPopupParent( parent );
         }
-        //Scrolling right
-        else if( ( clientMousePosition.X > scrollViewerRenderSize.Width - AutoScrollTreshold )
-                 && ( m_parentScrollViewer.HorizontalOffset < m_maxHorizontalScrollOffset ) )
-        {
-          m_autoScrollDirection |= AutoScrollDirection.Right;
-          double rightEdgeMouseDelta = clientMousePosition.X - scrollViewerRenderSize.Width;
-          m_scrollAmount = 1;
+      }
 
-          if( rightEdgeMouseDelta > 1 )
-          {
-            m_scrollAmount = rightEdgeMouseDelta;
-          }
+      double x, y;
 
-          //Scroll to a maximum of one page at a time.
-          if( m_scrollAmount > scrollViewerRenderSize.Width )
-          {
-            m_scrollPage = true;
-          }
-          else
-          {
-            m_scrollPage = false;
-          }
-        }
+      if( source != null )
+      {
+        var deviceUnits = source.CompositionTarget.TransformToDevice;
+        x = deviceUnits.M11;
+        y = deviceUnits.M22;
       }
-
-      if( m_parentScrollViewer.ScrollableHeight > 0 )
+      else
       {
-        if( ( clientMousePosition.Y < AutoScrollTreshold )
-            && ( m_parentScrollViewer.VerticalOffset > 0 ) )
+        using( var hwnd = new HwndSource( new HwndSourceParameters() ) )
         {
-          m_autoScrollDirection |= AutoScrollDirection.Up;
-        }
-        else if( ( clientMousePosition.Y > scrollViewerRenderSize.Height - AutoScrollTreshold )
-            && ( m_parentScrollViewer.VerticalOffset < m_parentScrollViewer.ExtentHeight - scrollViewerRenderSize.Height ) )
-        {
-          m_autoScrollDirection |= AutoScrollDirection.Down;
+          var deviceUnits = hwnd.CompositionTarget.TransformToDevice;
+          x = deviceUnits.M11;
+          y = deviceUnits.M22;
         }
       }
 
-      if( m_autoScrollDirection == AutoScrollDirection.None )
-      {
-        this.StopAutoScroll();
-      }
-      else
+      return new Vector( ( x == 0d ) ? 1d : 1d / x, ( y == 0d ) ? 1d : 1d / y );
+    }
+
+    private static DependencyObject GetPopupParent( DependencyObject element )
+    {
+      while( element != null )
       {
-        // The DispatcherTimer is not a priority event. The Tick event won't fire while 
-        // the user moves the mouse pointer. That's why we manually call the 
-        // PerformAutoScroll method (on each MouseMove, i.e. Drag). When the user doesn't 
-        // move the mouse pointer, the timer will take over to do the AutoScroll.
-        if( !m_timer.IsEnabled )
+        var popup = element as Popup;
+        if( popup != null )
         {
-          m_timer.Start();
+          var parent = popup.Parent;
+          if( parent != null )
+            return parent;
+
+          var target = popup.PlacementTarget;
+          if( target != null )
+            return target;
         }
 
-        this.PerformAutoScroll();
+        element = VisualTreeHelper.GetParent( element );
       }
+
+      return null;
     }
 
-    private void OnAutoScrollTimer_Tick( object sender, EventArgs e )
+    private FrameworkElement GetDraggedElementWindow()
     {
-      this.PerformAutoScroll();
+      DependencyObject current = this.DraggedElement;
+      while( current != null )
+      {
+        //If the grid is in a popup, this becomes the owning window, so return it.
+        var popup = current as Popup;
+        if( popup != null )
+          return popup;
+
+        var window = current as Window;
+        if( window != null )
+          return window;
+
+        current = TreeHelper.GetParent( current );
+      }
+
+      // The dragged element's window was not found.
+      return null;
     }
 
+
     private void OnDraggedElement_QueryCursor( object sender, QueryCursorEventArgs e )
     {
       if( this.IsDragging )
@@ -855,26 +763,9 @@ namespace Xceed.Utils.Wpf.DragDrop
 
     #endregion
 
-    private AutoScrollDirection m_autoScrollDirection = AutoScrollDirection.None;
-    private DispatcherTimer m_timer = null;
-    private DateTime m_lastAutoScrollTime;
-    private double m_scrollAmount;
-    private double m_maxHorizontalScrollOffset;
-    private bool m_scrollPage;
-
     //This is used to position the DraggedElementGhost as such.
-    private Point m_ghostInitialScreenPositon;
-
-    private ScrollViewer m_parentScrollViewer;
+    private Vector m_draggedElementMouseOffset;
 
-    [Flags()]
-    private enum AutoScrollDirection
-    {
-      None = 0,
-      Left = 1,
-      Right = 2,
-      Up = 4,
-      Down = 8
-    }
+    private AutoScrollManager m_autoScrollManager;
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Print/IPrintInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/ITreeTraversal.cs
similarity index 67%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Print/IPrintInfo.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/ITreeTraversal.cs
index cfc9dac3..ab1b021a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Print/IPrintInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/ITreeTraversal.cs
@@ -15,15 +15,18 @@
   ***********************************************************************************/
 
 using System.Collections.Generic;
+using System.Windows;
 
-namespace Xceed.Wpf.DataGrid.Print
+namespace Xceed.Utils.Wpf
 {
-  internal interface IPrintInfo
+  internal interface ITreeTraversal
   {
-    double GetPageRightOffset( double horizontalOffset, double viewportWidth );
+    DependencyObject Current
+    {
+      get;
+    }
 
-    void UpdateElementVisibility( double horizontalOffset, double viewportWidth, object state );
-
-    object CreateElementVisibilityState();
+    bool MoveNext();
+    void VisitNodes( IEnumerable<DependencyObject> nodes );
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/ITreeTraversalStrategy.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/ITreeTraversalStrategy.cs
new file mode 100644
index 00000000..fc0df99a
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/ITreeTraversalStrategy.cs
@@ -0,0 +1,24 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+
+namespace Xceed.Utils.Wpf
+{
+  internal interface ITreeTraversalStrategy
+  {
+    ITreeTraversal Create();
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/Markup/XceedResourceDictionary.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/Markup/XceedResourceDictionary.cs
index a32e436d..58174876 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/Markup/XceedResourceDictionary.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/Markup/XceedResourceDictionary.cs
@@ -20,32 +20,21 @@ using System.Windows;
 
 namespace Xceed.Utils.Wpf.Markup
 {
-  [ EditorBrowsable( EditorBrowsableState.Never ) ]
+  [Browsable( false )]
+  [EditorBrowsable( EditorBrowsableState.Never )]
   public sealed class XceedResourceDictionary : ResourceDictionary
   {
-    #region CONSTRUCTORS
-
-    public XceedResourceDictionary()
-      : base()
-    {
-      m_xceedSource = string.Empty;
-    }
-
-    #endregion CONSTRUCTORS
-
-    #region XceedSource PROPERTY
-
-    private string m_xceedSource;
+    #region XceedSource Property
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly" )]
     public string XceedSource
     {
 
-      get 
-      { 
+      get
+      {
         return m_xceedSource;
       }
-      set 
+      set
       {
         if( value == null )
           throw new ArgumentNullException( "XceedSource" );
@@ -60,12 +49,12 @@ namespace Xceed.Utils.Wpf.Markup
         string uriString =  parsedArguments[ 0 ] + 
           ";;;" + parsedArguments[ 1 ];
 
-        Uri uri = new Uri( uriString, UriKind.RelativeOrAbsolute );
-
-        this.Source = uri;
+        this.Source = new Uri( uriString, UriKind.RelativeOrAbsolute );
       }
     }
 
-    #endregion XceedSource PROPERTY
+    private string m_xceedSource = string.Empty;
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/TreeHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/TreeHelper.cs
index a9d39abb..3d3befd2 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/TreeHelper.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Utils/Wpf/TreeHelper.cs
@@ -15,9 +15,12 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
 using System.Windows;
-using System.Windows.Media;
 using System.Windows.Controls.Primitives;
+using System.Windows.Media;
 
 namespace Xceed.Utils.Wpf
 {
@@ -42,7 +45,6 @@ namespace Xceed.Utils.Wpf
     {
       if( recurseIntoPopup )
       {
-        // Case 126732 : To correctly detect parent of a popup we must do that exception case
         Popup popup = element as Popup;
 
         if( ( popup != null ) && ( popup.PlacementTarget != null ) )
@@ -119,6 +121,22 @@ namespace Xceed.Utils.Wpf
     /// <returns>Returns the found element. Null if nothing is found.</returns>
     /// <example>Button button = TreeHelper.FindParent&lt;Button&gt;( this, foundChild => foundChild.Focusable );</example>
     public static T FindParent<T>( DependencyObject startingObject, bool checkStartingObject, Func<T, bool> additionalCheck ) where T : DependencyObject
+    {
+      return TreeHelper.FindParent<T>( startingObject, checkStartingObject, additionalCheck, null );
+    }
+
+    /// <summary>
+    /// This will search for a parent of the specified type.
+    /// </summary>
+    /// <typeparam name="T">The type of the element to find</typeparam>
+    /// <param name="startingObject">The node where the search begins.</param>
+    /// <param name="checkStartingObject">Should the specified startingObject be checked first.</param>
+    /// <param name="additionalCheck">Provide a callback to check additional properties 
+    /// of the found elements. Can be left Null if no additional criteria are needed.</param>
+    /// <param name="scope">Should not search behond this parent. Scope value is excluded from the search</param>
+    /// <returns>Returns the found element. Null if nothing is found.</returns>
+    /// <example>Button button = TreeHelper.FindParent&lt;Button&gt;( this, foundChild => foundChild.Focusable );</example>
+    internal static T FindParent<T>( DependencyObject startingObject, bool checkStartingObject, Func<T, bool> additionalCheck, DependencyObject scope ) where T : DependencyObject
     {
       T foundElement;
       DependencyObject parent = ( checkStartingObject ? startingObject : TreeHelper.GetParent( startingObject, true ) );
@@ -141,6 +159,10 @@ namespace Xceed.Utils.Wpf
         }
 
         parent = TreeHelper.GetParent( parent, true );
+
+        if( object.ReferenceEquals( parent, scope ) )
+          break;
+
       }
 
       return null;
@@ -164,42 +186,13 @@ namespace Xceed.Utils.Wpf
     /// </summary>
     /// <typeparam name="T">The type of the element to find</typeparam>
     /// <param name="parent">The root of the tree to search for. This element itself is not checked.</param>
-    /// <param name="additionalCheck">Provide a callback to check additional properties 
+    /// <param name="predicate">Provide a callback to check additional properties 
     /// of the found elements. Can be left Null if no additional criteria are needed.</param>
     /// <returns>Returns the found element. Null if nothing is found.</returns>
     /// <example>Button button = TreeHelper.FindChild&lt;Button&gt;( this, foundChild => foundChild.Focusable );</example>
-    public static T FindChild<T>( DependencyObject parent, Func<T, bool> additionalCheck ) where T : DependencyObject
+    public static T FindChild<T>( DependencyObject parent, Func<T, bool> predicate ) where T : DependencyObject
     {
-      int childrenCount = VisualTreeHelper.GetChildrenCount( parent );
-      T child;
-
-      for( int index = 0; index < childrenCount; index++ )
-      {
-        child = VisualTreeHelper.GetChild( parent, index ) as T;
-
-        if( child != null )
-        {
-          if( additionalCheck == null )
-          {
-            return child;
-          }
-          else
-          {
-            if( additionalCheck( child ) )
-              return child;
-          }
-        }
-      }
-
-      for( int index = 0; index < childrenCount; index++ )
-      {
-        child = TreeHelper.FindChild<T>( VisualTreeHelper.GetChild( parent, index ), additionalCheck );
-
-        if( child != null )
-          return child;
-      }
-
-      return null;
+      return TreeHelper.GetDescendants<T>( new BreadthFirstSearchTreeTraversalStrategy(), parent, predicate, null ).FirstOrDefault();
     }
 
     /// <summary>
@@ -231,5 +224,61 @@ namespace Xceed.Utils.Wpf
 
       return false;
     }
+
+    public static IEnumerable<T> GetDescendants<T>( ITreeTraversalStrategy strategy, DependencyObject root ) where T : DependencyObject
+    {
+      return TreeHelper.GetDescendants<T>( strategy, root, null, null );
+    }
+
+    public static IEnumerable<T> GetDescendants<T>( ITreeTraversalStrategy strategy, DependencyObject root, Func<T, bool> predicate ) where T : class
+    {
+      return TreeHelper.GetDescendants<T>( strategy, root, predicate, null );
+    }
+
+    public static IEnumerable<T> GetDescendants<T>(
+      ITreeTraversalStrategy strategy,
+      DependencyObject root,
+      Func<T, bool> predicate,
+      Func<DependencyObject, bool> expand ) where T : class
+    {
+      if( strategy == null )
+        throw new ArgumentNullException( "strategy" );
+
+      if( root == null )
+        yield break;
+
+      var traversal = strategy.Create();
+      Debug.Assert( traversal != null );
+
+      traversal.VisitNodes( TreeHelper.GetChildren( root ) );
+
+      while( traversal.MoveNext() )
+      {
+        var current = traversal.Current;
+        var descendant = current as T;
+
+        if( ( descendant != null ) && ( ( predicate == null ) || predicate.Invoke( descendant ) ) )
+        {
+          yield return descendant;
+        }
+
+        if( ( expand == null ) || expand.Invoke( current ) )
+        {
+          traversal.VisitNodes( TreeHelper.GetChildren( current ) );
+        }
+      }
+    }
+
+    private static IEnumerable<DependencyObject> GetChildren( DependencyObject parent )
+    {
+      if( parent == null )
+        yield break;
+
+      var childrenCount = VisualTreeHelper.GetChildrenCount( parent );
+      for( int i = 0; i < childrenCount; i++ )
+      {
+        yield return VisualTreeHelper.GetChild( parent, i );
+      }
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ValueChangeDataItemPropertyDescriptor.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ValueChangeDataItemPropertyDescriptor.cs
new file mode 100644
index 00000000..38fc1bd6
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/ValueChangeDataItemPropertyDescriptor.cs
@@ -0,0 +1,241 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal sealed class ValueChangeDataItemPropertyDescriptor : DataItemPropertyDescriptor
+  {
+    #region Constructor
+
+    internal ValueChangeDataItemPropertyDescriptor(
+      DataItemTypeDescriptor owner,
+      PropertyDescriptor parent,
+      Type componentType,
+      Type propertyType,
+      Func<object, object> getter,
+      Action<object, object> setter,
+      Action<object> resetter,
+      EventDescriptor eventDescriptor )
+      : base( owner, parent, componentType, propertyType, getter, setter, resetter )
+    {
+      if( eventDescriptor == null )
+        throw new ArgumentNullException( "eventDescriptor" );
+
+      m_eventDescriptor = eventDescriptor;
+      m_eventProxy = new EventProxy( this, eventDescriptor );
+    }
+
+    #endregion
+
+    #region SupportsChangeEvents Property
+
+    public override bool SupportsChangeEvents
+    {
+      get
+      {
+        return true;
+      }
+    }
+
+    #endregion
+
+    public override int GetHashCode()
+    {
+      return base.GetHashCode();
+    }
+
+    public override bool Equals( object obj )
+    {
+      var descriptor = obj as ValueChangeDataItemPropertyDescriptor;
+      if( object.ReferenceEquals( descriptor, null ) )
+        return false;
+
+      return ( object.Equals( descriptor.m_eventDescriptor, m_eventDescriptor ) )
+          && ( base.Equals( descriptor ) );
+    }
+
+    protected override void AddValueChangedCore( object component )
+    {
+      if( component == null )
+        return;
+
+      m_eventProxy.AddValueChanged( component );
+    }
+
+    protected override void RemoveValueChangedCore( object component )
+    {
+      if( component == null )
+        return;
+
+      m_eventProxy.RemoveValueChanged( component );
+    }
+
+    protected override bool MustInhibitValueChanged( object component )
+    {
+      return ( ( m_inhibitValueChanged == null ) || !m_inhibitValueChanged.Contains( component ) )
+          && ( this.GetValueChangedHandler( component ) != null );
+    }
+
+    protected override bool IsValueChangedInhibited( object component )
+    {
+      return ( m_inhibitValueChanged != null )
+          && ( m_inhibitValueChanged.Contains( component ) );
+    }
+
+    protected override void InhibitValueChanged( object component )
+    {
+      if( m_inhibitValueChanged == null )
+      {
+        m_inhibitValueChanged = new HashSet<object>();
+      }
+
+      m_inhibitValueChanged.Add( component );
+    }
+
+    protected override void ResetInhibitValueChanged( object component )
+    {
+      Debug.Assert( m_inhibitValueChanged != null );
+
+      m_inhibitValueChanged.Remove( component );
+
+      if( m_inhibitValueChanged.Count == 0 )
+      {
+        m_inhibitValueChanged = null;
+      }
+    }
+
+    private void OnPropertyChanged( object sender, EventArgs e )
+    {
+      var propertyChangedEventArgs = e as PropertyChangedEventArgs;
+      if( propertyChangedEventArgs != null )
+      {
+        var propertyName = propertyChangedEventArgs.PropertyName;
+
+        if( !string.IsNullOrEmpty( propertyName ) && ( string.Compare( propertyName, this.Name, false, CultureInfo.InvariantCulture ) != 0 ) )
+          return;
+      }
+
+      this.OnValueChanged( sender, e );
+    }
+
+    #region Private Fields
+
+    private readonly EventProxy m_eventProxy;
+    private readonly EventDescriptor m_eventDescriptor;
+    private HashSet<object> m_inhibitValueChanged;
+
+    #endregion
+
+    #region EventProxy Private Class
+
+    private sealed class EventProxy
+    {
+      internal EventProxy( ValueChangeDataItemPropertyDescriptor propertyDescriptor, EventDescriptor eventDescriptor )
+      {
+        m_propertyDescriptor = new WeakReference( propertyDescriptor );
+        m_eventDescriptor = new WeakReference( eventDescriptor );
+      }
+
+      private ValueChangeDataItemPropertyDescriptor PropertyDescriptor
+      {
+        get
+        {
+          return m_propertyDescriptor.Target as ValueChangeDataItemPropertyDescriptor;
+        }
+      }
+
+      private EventDescriptor EventDescriptor
+      {
+        get
+        {
+          return m_eventDescriptor.Target as EventDescriptor;
+        }
+      }
+
+      internal void AddValueChanged( object component )
+      {
+        var descriptor = this.EventDescriptor;
+        if( descriptor == null )
+          return;
+
+        var handlerType = descriptor.EventType;
+
+        if( typeof( PropertyChangedEventHandler ).IsAssignableFrom( handlerType ) )
+        {
+          descriptor.AddEventHandler( component, new PropertyChangedEventHandler( this.OnPropertyChanged ) );
+        }
+        else if( typeof( EventHandler ).IsAssignableFrom( handlerType ) )
+        {
+          descriptor.AddEventHandler( component, new EventHandler( this.OnPropertyChanged ) );
+        }
+      }
+
+      internal void RemoveValueChanged( object component )
+      {
+        var descriptor = this.EventDescriptor;
+        if( descriptor == null )
+          return;
+
+        var handlerType = descriptor.EventType;
+
+        if( typeof( PropertyChangedEventHandler ).IsAssignableFrom( handlerType ) )
+        {
+          descriptor.RemoveEventHandler( component, new PropertyChangedEventHandler( this.OnPropertyChanged ) );
+        }
+        else if( typeof( EventHandler ).IsAssignableFrom( handlerType ) )
+        {
+          descriptor.RemoveEventHandler( component, new EventHandler( this.OnPropertyChanged ) );
+        }
+      }
+
+      private void HandlePropertyChanged( object sender, EventArgs e )
+      {
+        var propertyDescriptor = this.PropertyDescriptor;
+
+        if( propertyDescriptor != null )
+        {
+          propertyDescriptor.OnPropertyChanged( sender, e );
+        }
+        else
+        {
+          // Since the real listener is no longer available, try to unregister the handler.
+          this.RemoveValueChanged( sender );
+        }
+      }
+
+      private void OnPropertyChanged( object sender, EventArgs e )
+      {
+        this.HandlePropertyChanged( sender, e );
+      }
+
+      private void OnPropertyChanged( object sender, PropertyChangedEventArgs e )
+      {
+        this.HandlePropertyChanged( sender, e );
+      }
+
+      private readonly WeakReference m_propertyDescriptor;
+      private readonly WeakReference m_eventDescriptor;
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountChangedEventArgs.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountChangedEventArgs.cs
new file mode 100644
index 00000000..c5aed0f1
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountChangedEventArgs.cs
@@ -0,0 +1,60 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal class FixedColumnCountInfoEventArgs : EventArgs
+  {
+    internal FixedColumnCountInfoEventArgs( ColumnBase triggeringColumn, FixedColumnUpdateType updateType, int level = 0 )
+    {
+      this.TriggeringColumn = triggeringColumn;
+      this.UpdateType = updateType;
+      this.Level = level;
+    }
+
+    internal ColumnBase TriggeringColumn
+    {
+      get;
+      private set;
+    }
+
+    internal FixedColumnUpdateType UpdateType
+    {
+      get;
+      private set;
+    }
+
+    internal int Level
+    {
+      get;
+      private set;
+    }
+  }
+
+  internal enum FixedColumnUpdateType
+  {
+    Hide,  //Column.Visible is set to false
+    Remove, //The column is removed from a MergedColumnCollection
+    Show, //Column.Visible is set to true
+    Update //Simply update the FixedColumnCount property after a change in a ChildColumns collection.
+  }
+
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountEventManager.cs
new file mode 100644
index 00000000..e13d4114
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/FixedColumnCountEventManager.cs
@@ -0,0 +1,78 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Windows;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal class FixedColumnCountInfoEventManager : WeakEventManager
+  {
+    private FixedColumnCountInfoEventManager()
+    {
+    }
+
+    public static void AddListener( object source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedAddListener( source, listener );
+    }
+
+    public static void RemoveListener( object source, IWeakEventListener listener )
+    {
+      CurrentManager.ProtectedRemoveListener( source, listener );
+    }
+
+    protected override void StartListening( object source )
+    {
+      var detailConfiguration = source as DetailConfiguration;
+      if( detailConfiguration == null )
+        throw new InvalidOperationException( "An attempt was made to use a source other than a DetailConfiguration." );
+
+      detailConfiguration.FixedColumnCountChanged += this.OnFixedColumnCountChanged;
+    }
+
+    protected override void StopListening( object source )
+    {
+      var detailConfiguration = source as DetailConfiguration;
+      if( detailConfiguration == null )
+        throw new InvalidOperationException( "An attempt was made to use a source other than a DetailConfiguration." );
+
+      detailConfiguration.FixedColumnCountChanged -= this.OnFixedColumnCountChanged;
+    }
+
+    private static FixedColumnCountInfoEventManager CurrentManager
+    {
+      get
+      {
+        Type managerType = typeof( FixedColumnCountInfoEventManager );
+        FixedColumnCountInfoEventManager currentManager = ( FixedColumnCountInfoEventManager )WeakEventManager.GetCurrentManager( managerType );
+
+        if( currentManager == null )
+        {
+          currentManager = new FixedColumnCountInfoEventManager();
+          WeakEventManager.SetCurrentManager( managerType, currentManager );
+        }
+
+        return currentManager;
+      }
+    }
+
+    private void OnFixedColumnCountChanged( object sender, EventArgs args )
+    {
+      this.DeliverEvent( sender, args );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnInfoCollection.Generic.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnInfoCollection.Generic.cs
new file mode 100644
index 00000000..729da54d
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnInfoCollection.Generic.cs
@@ -0,0 +1,45 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal interface IColumnInfoCollection<T>
+  {
+    void Clear();
+
+    T this[ string fieldName ]
+    {
+      get;
+      set;
+    }
+
+    T this[ ColumnBase column ]
+    {
+      get;
+      set;
+    }
+
+    void Reset( string fieldName );
+    void Reset( ColumnBase column );
+
+    bool Contains( string fieldName );
+    bool Contains( ColumnBase column );
+
+    bool TryGetValue( string fieldName, out T value );
+    bool TryGetValue( ColumnBase column, out T value );
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnNameCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnNameCollection.cs
new file mode 100644
index 00000000..62062fa7
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/IColumnNameCollection.cs
@@ -0,0 +1,44 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System.Collections.Generic;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal interface IColumnNameCollection : IEnumerable<string>
+  {
+    int Count
+    {
+      get;
+    }
+
+    string this[ int index ]
+    {
+      get;
+    }
+
+    void Clear();
+
+    void Add( string fieldName );
+    void Add( ColumnBase column );
+
+    void Remove( string fieldName );
+    void Remove( ColumnBase column );
+
+    bool Contains( string fieldName );
+    bool Contains( ColumnBase column );
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManager.cs
index 4195e143..2a6f5678 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManager.cs
@@ -14,265 +14,119 @@
 
   ***********************************************************************************/
 
-using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Controls.Primitives;
-using Xceed.Utils.Math;
-using System.ComponentModel;
-using Xceed.Wpf.DataGrid.Markup;
-using System.Windows.Data;
-using System.Collections.Specialized;
-using System.Collections.ObjectModel;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
-  internal class TableViewColumnVirtualizationManager : ColumnVirtualizationManager
+  internal class TableViewColumnVirtualizationManager : TableViewColumnVirtualizationManagerBase
   {
-    static TableViewColumnVirtualizationManager()
-    {
-      // Register to ColumnManagerCell.ColumnReorderingEvent on FixedCellPanel type
-      // to be notified the corret DataGridContext level
-      EventManager.RegisterClassHandler(
-          typeof( FixedCellPanel ),
-          ColumnManagerCell.ColumnReorderingEvent,
-          new ColumnReorderingEventHandler( TableViewColumnVirtualizationManager.OnColumnReordering ) );
-    }
-
     public TableViewColumnVirtualizationManager( DataGridContext dataGridContext )
       : base( dataGridContext )
     {
     }
 
-    #region UpdateMeasureRequired Public Event
-
-    // This event will be use to notify every listener that the DataGridControl's layout
-    // has changed and they must at least call MeasureOverride
-    public event EventHandler UpdateMeasureRequired;
-
-    public void NotifyUpdateMeasureRequired( UpdateMeasureRequiredEventArgs args )
-    {
-      if( this.UpdateMeasureRequired != null )
-      {
-        this.UpdateMeasureRequired( this, args );
-      }
-    }
-
-    #endregion
-
-    #region FieldNameToOffset Property
+    #region FixedColumnsWidth Internal Property
 
-    public Dictionary<string, double> FieldNameToOffset
+    internal override double FixedColumnsWidth
     {
       get
       {
-        return m_fieldNameToOffset;
+        return m_fixedColumnsWidth;
       }
     }
 
-    private readonly Dictionary<string, double> m_fieldNameToOffset = new Dictionary<string, double>();
-
-    #endregion
-
-    #region FieldNameToWidth Property
-
-    public Dictionary<string, double> FieldNameToWidth
+    protected override void SetFixedColumnsWidth( double value )
     {
-      get
-      {
-        return m_fieldNameToWidth;
-      }
+      m_fixedColumnsWidth = value;
     }
 
-    private readonly Dictionary<string, double> m_fieldNameToWidth = new Dictionary<string, double>();
+    private double m_fixedColumnsWidth;
 
     #endregion
 
-    #region FieldNameToPosition Property
+    #region ScrollingColumnsWidth Internal Property
 
-    public Dictionary<string, int> FieldNameToPosition
+    internal override double ScrollingColumnsWidth
     {
       get
       {
-        return m_fieldNameToPosition;
+        return m_scrollingColumnsWidth;
       }
     }
 
-    private readonly Dictionary<string, int> m_fieldNameToPosition = new Dictionary<string, int>();
-
-    #endregion
-
-    #region FixedColumnsWidth Property
-
-    public double FixedColumnsWidth
+    protected override void SetScrollingColumnsWidth( double value )
     {
-      get;
-      private set;
-    }
-
-    #endregion
-
-    #region ScrollingColumnsWidth Property
-
-    // The width of all visible columns in 
-    public double ScrollingColumnsWidth
-    {
-      get;
-      private set;
+      m_scrollingColumnsWidth = value;
     }
 
+    private double m_scrollingColumnsWidth;
 
     #endregion
 
-    #region FixedColumnCount DependencyProperty
-
-    public static readonly DependencyProperty FixedColumnCountProperty =
-    DependencyProperty.Register( "FixedColumnCount", typeof( int ), typeof( TableViewColumnVirtualizationManager ), new UIPropertyMetadata( 0, new PropertyChangedCallback( TableViewColumnVirtualizationManager.OnFixedColumnCountChanged ) ) );
+    #region VisibleColumnsWidth Internal Property
 
-    private static void OnFixedColumnCountChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    internal override double VisibleColumnsWidth
     {
-      TableViewColumnVirtualizationManager columnVirtualizationManager = o as TableViewColumnVirtualizationManager;
-
-      if( columnVirtualizationManager == null )
-        return;
-
-      if( e.NewValue != null )
+      get
       {
-        columnVirtualizationManager.m_fixedColumnCount = ( int )e.NewValue;
-
-        // We want to be sure the cells won't be inserted in ScrollingPanel, but added to it
-        columnVirtualizationManager.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnReordering ) );
+        return m_visibleColumnsWidth;
       }
     }
 
-    public int FixedColumnCount
+    protected override void SetVisibleColumnsWidth( double value )
     {
-      get
-      {
-        return m_fixedColumnCount;
-      }
-      set
-      {
-        this.SetValue( FixedColumnCountProperty, value );
-      }
+      m_visibleColumnsWidth = value;
     }
 
-    #endregion
+    private double m_visibleColumnsWidth;
 
-    #region FirstColumnCompensationOffset Property
+    #endregion
 
-    // This field is set by the FixedCellPanel in OnCompensationOffsetChanged when the AttachedPropertyChanges
-    public static readonly DependencyProperty FirstColumnCompensationOffsetProperty = DependencyProperty.Register(
-      "FirstColumnCompensationOffset",
-      typeof( double ),
-      typeof( TableViewColumnVirtualizationManager ),
-      new FrameworkPropertyMetadata(
-        0d,
-        new PropertyChangedCallback( TableViewColumnVirtualizationManager.OnFirstColumnCompensationOffsetChanged ) ) );
+    #region FieldNameToOffset Internal Property
 
-    public double FirstColumnCompensationOffset
+    internal override IColumnInfoCollection<double> FieldNameToOffset
     {
       get
       {
-        return m_firstColumnCompensationOffset;
-      }
-      set
-      {
-        this.SetValue( TableViewColumnVirtualizationManager.FirstColumnCompensationOffsetProperty, value );
+        return m_fieldNameToOffset;
       }
     }
 
-    private static void OnFirstColumnCompensationOffsetChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      TableViewColumnVirtualizationManager manager = sender as TableViewColumnVirtualizationManager;
-
-      if( manager == null )
-        return;
-
-      manager.m_firstColumnCompensationOffset = ( double )e.NewValue;
-      manager.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
-    }
-
-    private double m_firstColumnCompensationOffset;
+    private readonly IColumnInfoCollection<double> m_fieldNameToOffset = new TableViewColumnVirtualizationManagerBase.ColumnInfoCollection<double>();
 
     #endregion
 
-    #region IsVirtualizing DependencyProperty
-
-    public static readonly DependencyProperty IsVirtualizingProperty =
-    DependencyProperty.Register( "IsVirtualizing", typeof( bool ), typeof( TableViewColumnVirtualizationManager ), new UIPropertyMetadata( true, new PropertyChangedCallback( TableViewColumnVirtualizationManager.OnIsVirtualizingChanged ) ) );
+    #region FieldNameToWidth Internal Property
 
-    private static void OnIsVirtualizingChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      TableViewColumnVirtualizationManager columnVirtualizationManager = o as TableViewColumnVirtualizationManager;
-
-      if( columnVirtualizationManager == null )
-        return;
-
-      if( e.NewValue != null )
-      {
-        columnVirtualizationManager.m_flags[ ( int )TableViewColumnVirtualizationManagerFlags.IsVirtualizing ] = ( bool )e.NewValue;
-        columnVirtualizationManager.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.VirtualizationStateChanged ) );
-      }
-    }
-
-    private bool IsVirtualizingCache
+    internal override IColumnInfoCollection<double> FieldNameToWidth
     {
       get
       {
-        return m_flags[ ( int )TableViewColumnVirtualizationManagerFlags.IsVirtualizing ];
-      }
-      set
-      {
-        m_flags[ ( int )TableViewColumnVirtualizationManagerFlags.IsVirtualizing ] = value;
+        return m_fieldNameToWidth;
       }
     }
 
-    public bool IsVirtualizing
-    {
-      get
-      {
-        return this.IsVirtualizingCache;
-      }
-      set
-      {
-        this.SetValue( IsVirtualizingProperty, value );
-      }
-    }
+    private readonly IColumnInfoCollection<double> m_fieldNameToWidth = new TableViewColumnVirtualizationManagerBase.ColumnInfoCollection<double>();
 
     #endregion
 
-    #region IsCurrentColumnInViewPort Property
+    #region FieldNameToPosition Internal Property
 
-    public bool IsCurrentColumnInScrollingViewPort
+    internal override IColumnInfoCollection<int> FieldNameToPosition
     {
       get
       {
-        return m_flags[ ( int )TableViewColumnVirtualizationManagerFlags.IsCurrentColumnInScrollingViewPort ];
-      }
-      private set
-      {
-        m_flags[ ( int )TableViewColumnVirtualizationManagerFlags.IsCurrentColumnInScrollingViewPort ] = value;
+        return m_fieldNameToPosition;
       }
     }
 
-    #endregion
-
-    #region FirstViewPortColumnFieldNameIndex Property
-
-    public int FirstViewportColumnFieldNameIndex
-    {
-      get;
-      private set;
-    }
+    private readonly IColumnInfoCollection<int> m_fieldNameToPosition = new TableViewColumnVirtualizationManagerBase.ColumnInfoCollection<int>();
 
     #endregion
 
-    #region FixedFieldNames Property
+    #region FixedFieldNames Internal Property
 
-    public List<string> FixedFieldNames
+    internal override IColumnNameCollection FixedFieldNames
     {
       get
       {
@@ -280,13 +134,13 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private readonly List<string> m_fixedFieldNames = new List<string>();
+    private readonly IColumnNameCollection m_fixedFieldNames = new TableViewColumnVirtualizationManagerBase.ColumnNameCollection();
 
     #endregion
 
-    #region ScrollingFieldNames Property
+    #region ScrollingFieldNames Internal Property
 
-    public List<string> ScrollingFieldNames
+    internal override IColumnNameCollection ScrollingFieldNames
     {
       get
       {
@@ -294,641 +148,28 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private readonly List<string> m_scrollingFieldNames = new List<string>();
+    private readonly IColumnNameCollection m_scrollingFieldNames = new TableViewColumnVirtualizationManagerBase.ColumnNameCollection();
 
     #endregion
 
-    #region FixedAndScrollingFieldNamesLookupDictionary
+    #region FirstViewportColumnFieldNameIndex Internal Property
 
-    // Contains all the FixedFieldNames and ScrollingFieldNames
-    // but in a Dictionary to increase lookup speed
-    public Dictionary<string, object> FixedAndScrollingFieldNamesLookupDictionary
+    internal override int FirstViewportColumnFieldNameIndex
     {
       get
       {
-        return m_requiredFieldNames;
+        return m_firstViewportColumnFieldNameIndex;
       }
     }
 
-    private Dictionary<string, object> m_requiredFieldNames = new Dictionary<string, object>();
-
-    #endregion
-
-    #region VisibleColumnsTotalWidth Property
-
-    // The width of all visible columns (fixed and scrolling ones)
-    public double VisibleColumnsTotalWidth
+    protected override void SetFirstViewportColumnFieldNameIndex( int value )
     {
-      get;
-      private set;
+      m_firstViewportColumnFieldNameIndex = value;
     }
 
-    #endregion
-
-    protected override void Initialize()
-    {
-      base.Initialize();
-
-      CollectionChangedEventManager.AddListener( this.DataGridContext.Items.SortDescriptions, this );
-      CollectionChangedEventManager.AddListener( this.DataGridContext.Items.GroupDescriptions, this );
-
-      ColumnActualWidthEventManager.AddListener( this.DataGridContext.Columns, this );
-      DataGridControlTemplateChangedEventManager.AddListener( this.DataGridContext.DataGridControl, this );
-
-      this.UpdateScrollViewer();
-
-      m_fixedColumnCount = TableView.GetFixedColumnCount( this.DataGridContext );
-
-      Binding fixedColumnCountBindingBase = new Binding( "FixedColumnCount" );
-      fixedColumnCountBindingBase.Source = this.DataGridContext;
-      fixedColumnCountBindingBase.Mode = BindingMode.OneWay;
-
-      BindingOperations.SetBinding( this,
-        TableViewColumnVirtualizationManager.FixedColumnCountProperty,
-        fixedColumnCountBindingBase );
-
-      // We must get the value first since it is a bound property
-      m_fixedColumnCount = ( int )this.GetValue( TableViewColumnVirtualizationManager.FixedColumnCountProperty );
-
-      Binding isColumnVirtualizingEnabledBindingBase = new Binding();
-      isColumnVirtualizingEnabledBindingBase.Source = this.DataGridContext;
-      isColumnVirtualizingEnabledBindingBase.Path =
-        new PropertyPath( TableView.IsColumnVirtualizationEnabledProperty );
-      isColumnVirtualizingEnabledBindingBase.Mode = BindingMode.OneWay;
-
-      BindingOperations.SetBinding( this,
-        TableViewColumnVirtualizationManager.IsVirtualizingProperty,
-        isColumnVirtualizingEnabledBindingBase );
-
-      Binding compensationOffsetBinding = new Binding();
-      compensationOffsetBinding.Path =
-        new PropertyPath( TableView.CompensationOffsetProperty );
-      compensationOffsetBinding.Source = this.DataGridContext;
-      compensationOffsetBinding.Mode = BindingMode.OneWay;
-
-      BindingOperations.SetBinding( this,
-        TableViewColumnVirtualizationManager.FirstColumnCompensationOffsetProperty,
-        compensationOffsetBinding );
-
-
-      // We must get the value first since it is a bound property
-      this.IsVirtualizingCache = ( bool )this.GetValue( TableViewColumnVirtualizationManager.IsVirtualizingProperty );
-    }
-
-    protected override void Uninitialize()
-    {
-      BindingOperations.ClearBinding( this,
-        TableViewColumnVirtualizationManager.FixedColumnCountProperty );
-
-      BindingOperations.ClearBinding( this,
-        TableViewColumnVirtualizationManager.IsVirtualizingProperty );
-
-      BindingOperations.ClearBinding( this,
-       TableViewColumnVirtualizationManager.FirstColumnCompensationOffsetProperty );
-
-
-      if( m_scrollViewer != null )
-        m_scrollViewer.ScrollChanged -= new ScrollChangedEventHandler( this.ScrollViewer_ScrollChanged );
-
-      ColumnActualWidthEventManager.RemoveListener( this.DataGridContext.Columns, this );
-      DataGridControlTemplateChangedEventManager.RemoveListener( this.DataGridContext.DataGridControl, this );
-
-      CollectionChangedEventManager.RemoveListener( this.DataGridContext.Items.SortDescriptions, this );
-      CollectionChangedEventManager.RemoveListener( this.DataGridContext.Items.GroupDescriptions, this );
-
-
-      base.Uninitialize();
-    }
-
-    protected override void PreUpdate()
-    {
-      base.PreUpdate();
-    }
-
-    protected override void ResetInternalState()
-    {
-      // Clear all references to columns
-      this.FixedColumnsWidth = 0;
-      this.VisibleColumnsTotalWidth = 0;
-      this.ScrollingColumnsWidth = 0;
-
-      this.FieldNameToOffset.Clear();
-      this.FieldNameToWidth.Clear();
-      this.FieldNameToPosition.Clear();
-
-      this.FixedFieldNames.Clear();
-      this.ScrollingFieldNames.Clear();
-      this.FirstViewportColumnFieldNameIndex = -1;
-      this.FixedAndScrollingFieldNamesLookupDictionary.Clear();
-    }
-
-    protected override void DoUpdate()
-    {
-      // We can't compute any values if Colums are not yet added to DataGrid
-      if( this.DataGridContext.ColumnsByVisiblePosition.Count == 0 )
-        return;
-
-      LinkedListNode<ColumnBase> currentColumnNode = this.DataGridContext.ColumnsByVisiblePosition.First;
-      int currentColumnIndex = 0;
-      double currentTotalWidth = 0d;
-      double currentColumnActualWidth = 0d;
-
-      int currentFixedColumnCount = 0;
-      ColumnBase dataGridContextCurrentColumn = this.DataGridContext.CurrentColumn;
-
-      double horizontalOffset = this.GetHorizontalOffset();
-      double viewPortWidth = this.GetViewPortWidth();
-
-      double fixedFieldNamesWidth = 0;
-
-      if( this.FixedColumnCount > 0 )
-      {
-        while( currentColumnNode != null )
-        {
-          if( this.FixedColumnCount == currentFixedColumnCount )
-          {
-            // All Fixed Columns were found
-            break;
-          }
-
-          ColumnBase column = currentColumnNode.Value;
-
-          if( column != null )
-          {
-            string fieldName = column.FieldName;
-
-            // Ensure we keep the correct visible offset for every columns even if they are Collpased
-            this.FieldNameToOffset.Add( fieldName, currentTotalWidth );
-
-            // The Column is not visible
-            if( !column.Visible )
-            {
-              // Move next
-              currentColumnNode = currentColumnNode.Next;
-              currentColumnIndex++;
-              continue;
-            }
-
-            this.FieldNameToPosition.Add( fieldName, currentColumnIndex );
-            currentColumnActualWidth = column.ActualWidth;
-
-            fixedFieldNamesWidth += currentColumnActualWidth;
-            currentTotalWidth += currentColumnActualWidth;
-            this.FieldNameToWidth.Add( fieldName, currentColumnActualWidth );
-
-            // We found a FixedCell
-            if( this.FixedColumnCount > currentFixedColumnCount )
-            {
-              // The DataGridContext.CurrentColumn is fixed, so in Viewport
-              if( dataGridContextCurrentColumn == column )
-              {
-                this.IsCurrentColumnInScrollingViewPort = true;
-              }
-
-              this.FixedColumnsWidth += currentColumnActualWidth;
-
-              this.FixedFieldNames.Add( fieldName );
-
-              currentColumnNode = currentColumnNode.Next;
-              currentColumnIndex++;
-              currentFixedColumnCount++;
-              continue;
-            }
-          }
-        }
-      }
-
-      if( this.IsVirtualizing )
-      {
-        // We must reduce the possible viewPortWidth only when virtualizing since
-        viewPortWidth = Math.Max( 0d, viewPortWidth - fixedFieldNamesWidth );
-
-        // We increment the horizontalOffset to take the fixed Columns width into consideration
-        horizontalOffset += fixedFieldNamesWidth;
-      }
-
-      // We must consider the fixedFieldNamesWidth width when calculating visible indexes in ViewPort
-      double viewPortMinimalOffset = horizontalOffset;
-      double viewPortMaximumOffset = horizontalOffset + viewPortWidth;
-
-      bool visibleColumnFieldNameMustBeAdded = false;
-      bool firstVisibleScrollingColumn = true;
-
-      while( currentColumnNode != null )
-      {
-        ColumnBase column = currentColumnNode.Value;
-        string fieldName = column.FieldName;
-
-        // Ensure we keep the correct visible offset for every columns even if they are Collpased
-        this.FieldNameToOffset.Add( fieldName, currentTotalWidth );
-
-        if( column.Visible )
-        {
-          visibleColumnFieldNameMustBeAdded = false;
-          this.FieldNameToPosition.Add( fieldName, currentColumnIndex );
-          currentColumnActualWidth = column.ActualWidth;
-
-          double columnLeftEdgeOffset = currentTotalWidth;
-          double columnRightEdgeOffset = columnLeftEdgeOffset + currentColumnActualWidth;
-
-          currentTotalWidth += currentColumnActualWidth;
-
-          this.ScrollingColumnsWidth += currentColumnActualWidth;
-
-          this.FieldNameToWidth.Add( fieldName, currentColumnActualWidth );
-
-          if( this.IsVirtualizing )
-          {
-            // The cell is before the ViewPort
-            // Cell .... | --- ViewPort --- |
-            bool beforeViewPort = ( horizontalOffset > columnRightEdgeOffset );
-
-            // The cell is after the ViewPort
-            // | --- ViewPort --- | .... Cell
-            bool afterViewPort = ( viewPortMaximumOffset < columnLeftEdgeOffset );
-
-            // Columns are in the ViewPort
-            if( !beforeViewPort && !afterViewPort )
-            {
-              // The DataGridContext.CurrentColumn is scrolling and in Viewport
-              if( dataGridContextCurrentColumn == column )
-              {
-                this.IsCurrentColumnInScrollingViewPort = true;
-              }
-
-              // We keep the index of the first viewport column index to ease the FixedColumn splitter change
-              if( this.FirstViewportColumnFieldNameIndex == -1 )
-              {
-                this.FirstViewportColumnFieldNameIndex = this.ScrollingFieldNames.Count;
-              }
-
-              visibleColumnFieldNameMustBeAdded = true;
-            }
-
-            // If the current is the first visible scrolling Column, force the insertion to the list
-            // We need it to be there for the case we are tabbing from the Last column of the row.
-            visibleColumnFieldNameMustBeAdded |= firstVisibleScrollingColumn;
-            firstVisibleScrollingColumn = false;
-          }
-          else
-          {
-            visibleColumnFieldNameMustBeAdded = true;
-          }
-
-          if( ( visibleColumnFieldNameMustBeAdded ) && ( !this.FixedFieldNames.Contains( fieldName ) ) && ( !this.ScrollingFieldNames.Contains( fieldName ) ) )
-          {
-            this.ScrollingFieldNames.Add( fieldName );
-          }
-        }
-
-        currentColumnNode = currentColumnNode.Next;
-        currentColumnIndex++;
-      }
-
-      string firstColumnFieldName = this.GetFirstVisibleFocusableColumnFieldName();
-      if( ( !string.IsNullOrEmpty( firstColumnFieldName ) ) && ( !this.ScrollingFieldNames.Contains( firstColumnFieldName ) ) )
-      {
-        this.ScrollingFieldNames.Add( firstColumnFieldName );
-      }
-
-      string lastColumnFieldName = this.GetLastVisibleFocusableColumnFieldName();
-      if( ( !string.IsNullOrEmpty( lastColumnFieldName ) ) && ( !this.ScrollingFieldNames.Contains( lastColumnFieldName ) ) )
-      {
-        this.ScrollingFieldNames.Add( lastColumnFieldName );
-      }
-
-      this.VisibleColumnsTotalWidth = currentTotalWidth;
-    }
-
-    protected override void PostUpdate()
-    {
-      base.PostUpdate();
-
-      foreach( string fieldName in this.FixedFieldNames )
-      {
-        this.FixedAndScrollingFieldNamesLookupDictionary.Add( fieldName, null );
-      }
-
-      foreach( string fieldName in this.ScrollingFieldNames )
-      {
-        this.FixedAndScrollingFieldNamesLookupDictionary.Add( fieldName, null );
-      }
-    }
-
-    protected override void IncrementVersion( object parameters )
-    {
-      base.IncrementVersion( parameters );
-
-      this.NotifyUpdateMeasureRequired( parameters as UpdateMeasureRequiredEventArgs );
-    }
-
-    protected override void DataGridContext_PropertyChanged( object sender, PropertyChangedEventArgs e )
-    {
-      base.DataGridContext_PropertyChanged( sender, e );
-
-      Debug.Assert( string.IsNullOrEmpty( e.PropertyName ) == false );
-
-      if( string.IsNullOrEmpty( e.PropertyName ) == true )
-        return;
-
-      switch( e.PropertyName )
-      {
-        case "FixedHeaderFooterViewPortSize":
-          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ViewPortWidthChanged ) );
-          break;
-
-        case "CurrentItem":
-          // No need to increment version, only notify the current item to invalidate measure
-          this.NotifyUpdateMeasureRequired( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.CurrentItemChanged ) );
-          break;
-      }
-    }
-
-    private string GetPreviousVisibleFocusableColumnFieldName( LinkedListNode<ColumnBase> currentColumnNode )
-    {
-      ColumnBase currentColumn = currentColumnNode.Value;
-
-      while( ( currentColumn != null )
-        && ( ( currentColumn.ReadOnly )
-        && ( !currentColumn.CanBeCurrentWhenReadOnly )
-        || ( this.FixedFieldNames.Contains( currentColumn.FieldName ) )
-        || ( !currentColumn.Visible ) ) )
-      {
-        currentColumnNode = currentColumnNode.Previous;
-        currentColumn = ( currentColumnNode != null ) ? currentColumnNode.Value : null;
-      }
-
-      string nextFocusableFieldName = ( currentColumn != null ) ? currentColumn.FieldName : string.Empty;
-      return nextFocusableFieldName;
-    }
-
-    private string GetNextVisibleFocusableColumnFieldName( LinkedListNode<ColumnBase> currentColumnNode )
-    {
-      ColumnBase currentColumn = currentColumnNode.Value;
-
-      while( ( currentColumn != null )
-        && ( ( currentColumn.ReadOnly )
-        && ( !currentColumn.CanBeCurrentWhenReadOnly )
-        || ( this.FixedFieldNames.Contains( currentColumn.FieldName ) )
-        || ( !currentColumn.Visible ) ) )
-      {
-        currentColumnNode = currentColumnNode.Next;
-        currentColumn = ( currentColumnNode != null ) ? currentColumnNode.Value : null;
-      }
-
-      string nextFocusableFieldName = ( currentColumn != null ) ? currentColumn.FieldName : string.Empty;
-      return nextFocusableFieldName;
-    }
-
-    private string GetFirstVisibleFocusableColumnFieldName()
-    {
-      string fieldName;
-
-      if( this.DataGridContext != null )
-      {
-        fieldName = this.GetNextVisibleFocusableColumnFieldName( this.DataGridContext.ColumnsByVisiblePosition.First );
-      }
-      else
-      {
-        fieldName = string.Empty;
-      }
-
-      return fieldName;
-    }
-
-    private string GetLastVisibleFocusableColumnFieldName()
-    {
-      string fieldName;
-
-      if( this.DataGridContext != null )
-      {
-        fieldName = this.GetPreviousVisibleFocusableColumnFieldName( this.DataGridContext.ColumnsByVisiblePosition.Last );
-      }
-      else
-      {
-        fieldName = string.Empty;
-      }
-
-      return fieldName;
-    }
-
-    private double GetHorizontalOffset()
-    {
-      double horizontalOffset = 0;
-
-      ScrollViewer parentScrollViewer = this.DataGridContext.DataGridControl.ScrollViewer;
-
-      if( parentScrollViewer != null )
-        horizontalOffset = parentScrollViewer.HorizontalOffset - this.FirstColumnCompensationOffset;
-
-      return horizontalOffset;
-    }
-
-    private double GetViewPortWidth()
-    {
-      double viewPortWidth = 0;
-
-      IScrollInfo vStackPanel = null;
-
-      // Viewport is only required when UI Virtualization is on
-      if( this.IsVirtualizing )
-      {
-        try
-        {
-          vStackPanel = this.DataGridContext.DataGridControl.ItemsHost as IScrollInfo;
-        }
-        catch( Exception )
-        {
-          // Ignore exceptions since it may be called before the ItemsHost Template is applied
-        }
-
-        if( vStackPanel != null )
-        {
-          // Get the ViewPortWidth
-          viewPortWidth = vStackPanel.ViewportWidth;
-        }
-
-        // We use the HeaderFooterItem width when greater than the viewport width
-        if( ( viewPortWidth == 0 ) || ( this.DataGridContext.FixedHeaderFooterViewPortSize.Width > viewPortWidth ) )
-        {
-          viewPortWidth = this.DataGridContext.FixedHeaderFooterViewPortSize.Width;
-        }
-      }
-
-      return viewPortWidth;
-    }
-
-    private void UpdateScrollViewer()
-    {
-      if( this.DataGridContext == null )
-        return;
-
-      ScrollViewer newScrollViewer = this.DataGridContext.DataGridControl.ScrollViewer;
-
-      Debug.Assert( ( newScrollViewer != null ) || ( DesignerProperties.GetIsInDesignMode( this ) ) );
-
-      if( newScrollViewer != m_scrollViewer )
-      {
-        if( m_scrollViewer != null )
-          m_scrollViewer.ScrollChanged -= new ScrollChangedEventHandler( this.ScrollViewer_ScrollChanged );
-
-        m_scrollViewer = newScrollViewer;
-
-        if( m_scrollViewer != null )
-          m_scrollViewer.ScrollChanged += new ScrollChangedEventHandler( this.ScrollViewer_ScrollChanged );
-      }
-    }
-
-    private static void OnColumnReordering( object sender, ColumnReorderingEventArgs e )
-    {
-      FixedCellPanel panel = sender as FixedCellPanel;
-
-      if( panel == null )
-        return;
-
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( panel );
-
-      if( dataGridContext == null )
-        return;
-
-      TableViewColumnVirtualizationManager columnVirtualizationManager =
-          dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-      if( columnVirtualizationManager == null )
-        return;
-
-      int currentFixedColumnCount = columnVirtualizationManager.FixedColumnCount;
-
-      // We must be sure the VisiblePosition is converted to visible index since some Columns can be Visible = false
-      int oldVisiblePosition = FixedCellPanel.CalculateVisibleIndex( e.OldVisiblePosition, dataGridContext );
-      int newVisiblePosition = FixedCellPanel.CalculateVisibleIndex( e.NewVisiblePosition, dataGridContext );
-
-      if( ( oldVisiblePosition < columnVirtualizationManager.FixedColumnCount ) && ( newVisiblePosition >= columnVirtualizationManager.FixedColumnCount ) )
-      {
-        // A column was moved from the fixedPanel to the scrollingPanel
-
-        // Do not increment version, it will be done by the FixedColumnCount changed
-        TableView.SetFixedColumnCount( columnVirtualizationManager.DataGridContext, columnVirtualizationManager.FixedColumnCount - 1 );
-      }
-      else if( ( oldVisiblePosition >= columnVirtualizationManager.FixedColumnCount ) && ( newVisiblePosition < columnVirtualizationManager.FixedColumnCount ) )
-      {
-        // A column was moved from the scrollingPanel to the fixedPanel
-
-        // Do not increment version, it will be done by the FixedColumnCount changed
-        TableView.SetFixedColumnCount( columnVirtualizationManager.DataGridContext, columnVirtualizationManager.FixedColumnCount + 1 );
-      }
-      else
-      {
-        columnVirtualizationManager.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnReordering ) );
-      }
-
-      // This must be done to stop progation of the event even
-      // if only 1 ColumnManagerCell will raise it.
-      e.Handled = true;
-    }
-
-    private void ScrollViewer_ScrollChanged( object sender, System.Windows.Controls.ScrollChangedEventArgs e )
-    {
-      if( e.OriginalSource != this.DataGridContext.DataGridControl.ScrollViewer )
-        return;
-
-      this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ScrollViewerChanged ) );
-    }
-
-    #region IWeakEventListener Members
-
-    protected override bool OnReceivedWeakEvent( Type managerType, object sender, EventArgs e )
-    {
-      bool handled = false;
-      bool detachFromDataGridContext = false;
-
-      if( managerType == typeof( VisibleColumnsUpdatedEventManager ) )
-      {
-        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnReordering ) );
-
-        handled = true;
-      }
-      else if( managerType == typeof( CollectionChangedEventManager ) )
-      {
-        if( sender == this.DataGridContext.Items.SortDescriptions )
-          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.SortingChanged ) );
-
-        if( sender == this.DataGridContext.Items.GroupDescriptions )
-          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.GroupingChanged ) );
-
-        handled = true;
-      }
-      else if( managerType == typeof( ColumnActualWidthEventManager ) )
-      {
-        ColumnActualWidthChangedEventArgs args = e as ColumnActualWidthChangedEventArgs;
-
-        // We pass the delta between the old and new value to tell the Panel to reduce the
-        // horizontal offset when a column is auto-resized to a smaller value
-        if( args != null )
-        {
-          double delta = args.OldValue - args.NewValue;
-          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnActualWidthChanged, delta ) );
-        }
-        else
-        {
-          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnActualWidthChanged ) );
-        }
-
-        handled = true;
-      }
-      else if( managerType == typeof( ViewChangedEventManager ) )
-      {
-        detachFromDataGridContext = true;
-        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
-
-        handled = true;
-      }
-      else if( managerType == typeof( ThemeChangedEventManager ) )
-      {
-        detachFromDataGridContext = true;
-        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
-
-        handled = true;
-      }
-      else if( managerType == typeof( DataGridControlTemplateChangedEventManager ) )
-      {
-        this.UpdateScrollViewer();
-        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
-
-        handled = true;
-      }
-      else if( managerType == typeof( ItemsSourceChangeCompletedEventManager ) )
-      {
-        detachFromDataGridContext = true;
-        handled = true;
-      }
-
-      if( detachFromDataGridContext == true )
-      {
-        if( this.DataGridContext != null )
-        {
-          // Detach the ColumnVirtualizationManager from the DataGridContext and detach from the DataGridContext
-          ColumnVirtualizationManager.SetColumnVirtualizationManager( this.DataGridContext, null );
-
-          this.Uninitialize();
-        }
-      }
-
-      return handled;
-    }
+    private int m_firstViewportColumnFieldNameIndex;
 
     #endregion
-
-    private BitVector32 m_flags = new BitVector32();
-    private int m_fixedColumnCount; // = 0;
-    private ScrollViewer m_scrollViewer; // = null;
-
-    [Flags]
-    private enum TableViewColumnVirtualizationManagerFlags
-    {
-      IsVirtualizing = 1,
-      IsCurrentColumnInScrollingViewPort = 2,
-    }
   }
 }
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManagerBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManagerBase.cs
new file mode 100644
index 00000000..136e8e3e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/TableViewColumnVirtualizationManagerBase.cs
@@ -0,0 +1,1440 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
+using System.Windows.Threading;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal abstract class TableViewColumnVirtualizationManagerBase : ColumnVirtualizationManager
+  {
+    protected TableViewColumnVirtualizationManagerBase( DataGridContext dataGridContext )
+      : base( dataGridContext )
+    {
+      RoutedEventManager.Instance.Register();
+    }
+
+    #region IsVirtualizing Property
+
+    protected static readonly DependencyProperty IsVirtualizingProperty = DependencyProperty.Register(
+      "IsVirtualizing",
+      typeof( bool ),
+      typeof( TableViewColumnVirtualizationManagerBase ),
+      new UIPropertyMetadata(
+        true,
+        new PropertyChangedCallback( TableViewColumnVirtualizationManagerBase.OnIsVirtualizingChanged ) ) );
+
+    public bool IsVirtualizing
+    {
+      get
+      {
+        return ( bool )this.GetValue( TableViewColumnVirtualizationManagerBase.IsVirtualizingProperty );
+      }
+      set
+      {
+        this.SetValue( TableViewColumnVirtualizationManagerBase.IsVirtualizingProperty, value );
+      }
+    }
+
+    protected virtual void OnIsVirtualizingChanged( bool oldValue, bool newValue )
+    {
+      this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.VirtualizationStateChanged ) );
+    }
+
+    private static void OnIsVirtualizingChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var manager = sender as TableViewColumnVirtualizationManagerBase;
+      if( manager == null )
+        return;
+
+      manager.OnIsVirtualizingChanged( ( bool )e.OldValue, ( bool )e.NewValue );
+    }
+
+    #endregion
+
+    #region FirstColumnCompensationOffset Property
+
+    // This field is set by the FixedCellPanel in OnCompensationOffsetChanged when the AttachedPropertyChanges
+    protected static readonly DependencyProperty FirstColumnCompensationOffsetProperty = DependencyProperty.Register(
+      "FirstColumnCompensationOffset",
+      typeof( double ),
+      typeof( TableViewColumnVirtualizationManagerBase ),
+      new FrameworkPropertyMetadata(
+        0d,
+        new PropertyChangedCallback( TableViewColumnVirtualizationManagerBase.OnFirstColumnCompensationOffsetChanged ) ) );
+
+    public double FirstColumnCompensationOffset
+    {
+      get
+      {
+        return ( double )this.GetValue( TableViewColumnVirtualizationManagerBase.FirstColumnCompensationOffsetProperty );
+      }
+      set
+      {
+        this.SetValue( TableViewColumnVirtualizationManagerBase.FirstColumnCompensationOffsetProperty, value );
+      }
+    }
+
+    protected virtual void OnFirstColumnCompensationOffsetChanged( double oldValue, double newValue )
+    {
+      this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
+    }
+
+    private static void OnFirstColumnCompensationOffsetChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var manager = sender as TableViewColumnVirtualizationManagerBase;
+      if( manager == null )
+        return;
+
+      manager.OnFirstColumnCompensationOffsetChanged( ( double )e.OldValue, ( double )e.NewValue );
+    }
+
+    #endregion
+
+    #region FixedColumnCount Protected Property
+
+    protected static readonly DependencyProperty FixedColumnCountProperty = DependencyProperty.Register(
+      "FixedColumnCount",
+      typeof( int ),
+      typeof( TableViewColumnVirtualizationManagerBase ),
+      new UIPropertyMetadata( 0, new PropertyChangedCallback( TableViewColumnVirtualizationManagerBase.OnFixedColumnCountChanged ),
+                                 new CoerceValueCallback( TableViewColumnVirtualizationManagerBase.FixedColumnCountCoerceCallback ) ) );
+
+    // Only used to back the dp.  The dp itself is used as the API for the user to change the fixed column count (through TableView binding),
+    // and the PropertyChangedCallback redirect the value to the top most manager row.  FixedColumnCountInternal reflects the value for the regular CMR (-1 level).
+    protected int FixedColumnCount
+    {
+      get
+      {
+        return ( int )this.GetValue( TableViewColumnVirtualizationManagerBase.FixedColumnCountProperty );
+      }
+      set
+      {
+        this.SetValue( TableViewColumnVirtualizationManagerBase.FixedColumnCountProperty, value );
+      }
+    }
+
+    private void OnFixedColumnCountChanged( int oldValue, int newValue )
+    {
+      // To prevent reentrance
+      if( !m_updatingFixedColumnCount.IsSet )
+      {
+        using( m_updatingFixedColumnCount.Set() )
+        {
+          int level = -1;
+          int correctionValue = ( newValue > 0 ) ? 1 : 0;
+
+          this.SetFixedColumnCount( level, newValue, correctionValue );
+        }
+      }
+
+      // We want to be sure the cells won't be inserted in ScrollingPanel, but added to it
+      if( m_incrementVersionDispatcherOperation == null )
+      {
+        m_incrementVersionDispatcherOperation = this.Dispatcher.BeginInvoke(
+                                                  DispatcherPriority.Render,
+                                                  new Action<UpdateMeasureRequiredEventArgs>( this.IncrementVersion ),
+                                                  new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnReordering ) );
+      }
+    }
+
+    private static void OnFixedColumnCountChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    {
+      var manager = ( TableViewColumnVirtualizationManagerBase )sender;
+
+      manager.OnFixedColumnCountChanged( ( int )e.OldValue, ( int )e.NewValue );
+    }
+
+    private static object FixedColumnCountCoerceCallback( DependencyObject sender, object value )
+    {
+      var fixedColumnCount = ( int )value;
+      if( fixedColumnCount == 0 )
+        return value;
+
+      if( fixedColumnCount < 0 )
+        return 0;
+
+      var manager = ( TableViewColumnVirtualizationManagerBase )sender;
+      var dataGridContext = manager.DataGridContext;
+      int maxValue = 0;
+
+      if( dataGridContext != null )
+      {
+        var columns = dataGridContext.VisibleColumns;
+        if( columns.Any() )
+        {
+          maxValue = columns.Count;
+        }
+      }
+
+      if( fixedColumnCount > maxValue )
+        return maxValue;
+
+      return value;
+    }
+
+    private int FixedColumnCountInternal
+    {
+      get;
+      set;
+    }
+
+    private void UpdateFixedColumnCount()
+    {
+      this.CoerceValue( TableViewColumnVirtualizationManagerBase.FixedColumnCountProperty );
+    }
+
+    private readonly AutoResetFlag m_updatingFixedColumnCount = AutoResetFlagFactory.Create();
+    private DispatcherOperation m_incrementVersionDispatcherOperation;
+
+    #endregion
+
+    #region FixedColumnsWidth Internal Property
+
+    internal abstract double FixedColumnsWidth
+    {
+      get;
+    }
+
+    protected abstract void SetFixedColumnsWidth( double value );
+
+    #endregion
+
+    #region ScrollingColumnsWidth Internal Property
+
+    // The width of all visible columns in 
+    internal abstract double ScrollingColumnsWidth
+    {
+      get;
+    }
+
+    protected abstract void SetScrollingColumnsWidth( double value );
+
+    #endregion
+
+    #region VisibleColumnsWidth Internal Property
+
+    // The width of all visible columns (fixed and scrolling ones)
+    internal abstract double VisibleColumnsWidth
+    {
+      get;
+    }
+
+    protected abstract void SetVisibleColumnsWidth( double value );
+
+    #endregion
+
+    #region FieldNameToOffset Internal Property
+
+    internal abstract IColumnInfoCollection<double> FieldNameToOffset
+    {
+      get;
+    }
+
+    #endregion
+
+    #region FieldNameToWidth Internal Property
+
+    internal abstract IColumnInfoCollection<double> FieldNameToWidth
+    {
+      get;
+    }
+
+    #endregion
+
+    #region FieldNameToPosition Internal Property
+
+    internal abstract IColumnInfoCollection<int> FieldNameToPosition
+    {
+      get;
+    }
+
+    #endregion
+
+    #region FixedFieldNames Internal Property
+
+    internal abstract IColumnNameCollection FixedFieldNames
+    {
+      get;
+    }
+
+    #endregion
+
+    #region ScrollingFieldNames Internal Property
+
+    internal abstract IColumnNameCollection ScrollingFieldNames
+    {
+      get;
+    }
+
+    #endregion
+
+    #region VisibleFieldNames Internal Property
+
+    internal IColumnNameCollection VisibleFieldNames
+    {
+      get
+      {
+        return new ColumnNameLookup( new IColumnNameCollection[] { this.FixedFieldNames, this.ScrollingFieldNames } );
+      }
+    }
+
+    #endregion
+
+    #region FirstViewportColumnFieldNameIndex Internal Property
+
+    internal abstract int FirstViewportColumnFieldNameIndex
+    {
+      get;
+    }
+
+    protected abstract void SetFirstViewportColumnFieldNameIndex( int value );
+
+    #endregion
+
+    #region ScrollViewer Private Property
+
+    private ScrollViewer ScrollViewer
+    {
+      get
+      {
+        return m_scrollViewer;
+      }
+      set
+      {
+        if( value == m_scrollViewer )
+          return;
+
+        if( m_scrollViewer != null )
+        {
+          m_scrollViewer.ScrollChanged -= new ScrollChangedEventHandler( this.ScrollViewer_ScrollChanged );
+        }
+
+        m_scrollViewer = value;
+
+        if( m_scrollViewer != null )
+        {
+          m_scrollViewer.ScrollChanged += new ScrollChangedEventHandler( this.ScrollViewer_ScrollChanged );
+        }
+      }
+    }
+
+    private void ScrollViewer_ScrollChanged( object sender, ScrollChangedEventArgs e )
+    {
+      var dataGridContext = this.DataGridContext;
+      if( dataGridContext == null )
+        return;
+
+      var dataGridControl = dataGridContext.DataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      if( e.OriginalSource != dataGridControl.ScrollViewer )
+        return;
+
+      this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ScrollViewerChanged ) );
+    }
+
+    private void UpdateScrollViewer()
+    {
+      DataGridContext dataGridContext = this.DataGridContext;
+
+      if( dataGridContext == null )
+      {
+        this.ScrollViewer = null;
+      }
+      else
+      {
+        var scrollViewer = dataGridContext.DataGridControl.ScrollViewer;
+
+        Debug.Assert( ( scrollViewer != null ) || ( DesignerProperties.GetIsInDesignMode( this ) ) );
+
+        this.ScrollViewer = scrollViewer;
+      }
+    }
+
+    private ScrollViewer m_scrollViewer; //null;
+
+    #endregion
+
+    #region UpdateMeasureRequired Public Event
+
+    // This event will be use to notify every listener that the DataGridControl's layout has changed and they must at least call MeasureOverride
+    public event EventHandler UpdateMeasureRequired;
+
+    protected void RaiseUpdateMeasureRequired( UpdateMeasureRequiredEventArgs args )
+    {
+      if( this.UpdateMeasureRequired != null )
+      {
+        this.UpdateMeasureRequired( this, args );
+      }
+    }
+
+    #endregion
+
+    protected override void Initialize()
+    {
+      base.Initialize();
+
+      CollectionChangedEventManager.AddListener( this.DataGridContext.Items.SortDescriptions, this );
+      CollectionChangedEventManager.AddListener( this.DataGridContext.Items.GroupDescriptions, this );
+      ColumnActualWidthEventManager.AddListener( this.DataGridContext.Columns, this );
+      DataGridControlTemplateChangedEventManager.AddListener( this.DataGridContext.DataGridControl, this );
+      if( this.DataGridContext.SourceDetailConfiguration != null )
+      {
+        FixedColumnCountInfoEventManager.AddListener( this.DataGridContext.SourceDetailConfiguration, this );
+      }
+
+      this.UpdateScrollViewer();
+
+      Binding fixedColumnCountBindingBase = new Binding( "FixedColumnCount" );
+      fixedColumnCountBindingBase.Source = this.DataGridContext;
+      fixedColumnCountBindingBase.Mode = BindingMode.TwoWay;
+      BindingOperations.SetBinding( this, TableViewColumnVirtualizationManagerBase.FixedColumnCountProperty, fixedColumnCountBindingBase );
+
+      Binding isColumnVirtualizingEnabledBindingBase = new Binding();
+      isColumnVirtualizingEnabledBindingBase.Source = this.DataGridContext;
+      isColumnVirtualizingEnabledBindingBase.Path = new PropertyPath( TableView.IsColumnVirtualizationEnabledProperty );
+      isColumnVirtualizingEnabledBindingBase.Mode = BindingMode.OneWay;
+      BindingOperations.SetBinding( this, TableViewColumnVirtualizationManagerBase.IsVirtualizingProperty, isColumnVirtualizingEnabledBindingBase );
+
+      Binding compensationOffsetBinding = new Binding();
+      compensationOffsetBinding.Path = new PropertyPath( TableView.CompensationOffsetProperty );
+      compensationOffsetBinding.Source = this.DataGridContext;
+      compensationOffsetBinding.Mode = BindingMode.OneWay;
+      BindingOperations.SetBinding( this, TableViewColumnVirtualizationManagerBase.FirstColumnCompensationOffsetProperty, compensationOffsetBinding );
+    }
+
+    protected override void Uninitialize()
+    {
+      BindingOperations.ClearBinding( this, TableViewColumnVirtualizationManagerBase.FixedColumnCountProperty );
+
+      BindingOperations.ClearBinding( this, TableViewColumnVirtualizationManagerBase.IsVirtualizingProperty );
+      BindingOperations.ClearBinding( this, TableViewColumnVirtualizationManagerBase.FirstColumnCompensationOffsetProperty );
+
+      this.ScrollViewer = null;
+
+      CollectionChangedEventManager.RemoveListener( this.DataGridContext.Items.SortDescriptions, this );
+      CollectionChangedEventManager.RemoveListener( this.DataGridContext.Items.GroupDescriptions, this );
+      ColumnActualWidthEventManager.RemoveListener( this.DataGridContext.Columns, this );
+      DataGridControlTemplateChangedEventManager.RemoveListener( this.DataGridContext.DataGridControl, this );
+
+      if( this.DataGridContext.SourceDetailConfiguration != null )
+      {
+        FixedColumnCountInfoEventManager.RemoveListener( this.DataGridContext.SourceDetailConfiguration, this );
+      }
+
+      base.Uninitialize();
+    }
+
+    protected override void ResetInternalState()
+    {
+      this.SetFixedColumnsWidth( 0d );
+      this.SetScrollingColumnsWidth( 0d );
+      this.SetVisibleColumnsWidth( 0d );
+      this.SetFirstViewportColumnFieldNameIndex( -1 );
+
+      this.FieldNameToOffset.Clear();
+      this.FieldNameToWidth.Clear();
+      this.FieldNameToPosition.Clear();
+
+      this.FixedFieldNames.Clear();
+      this.ScrollingFieldNames.Clear();
+    }
+
+    protected override void DoUpdate()
+    {
+      this.UpdateFixedColumnCount();
+
+      var dataGridContext = this.DataGridContext;
+      var columnsByVisiblePosition = dataGridContext.ColumnsByVisiblePosition;
+
+      // We can't compute any values if Colums are not yet added to DataGrid
+      if( columnsByVisiblePosition.Count == 0 )
+        return;
+
+      LinkedListNode<ColumnBase> currentColumnNode = columnsByVisiblePosition.First;
+      int currentColumnIndex = 0;
+      double currentTotalWidth = 0d;
+      double currentColumnActualWidth = 0d;
+
+      int currentFixedColumnCount = 0;
+      ColumnBase currentColumnDataGridContext = dataGridContext.CurrentColumn;
+
+      double fixedFieldNamesWidth = 0d;
+      double fixedColumnsWidth = 0d;
+
+      if( this.FixedColumnCountInternal > 0 )
+      {
+        while( currentColumnNode != null )
+        {
+          // If all Fixed Columns were found
+          if( this.FixedColumnCountInternal == currentFixedColumnCount )
+            break;
+
+          ColumnBase column = currentColumnNode.Value;
+
+          // Ensure we keep the correct visible offset for every columns even if they are Collpased
+          this.FieldNameToOffset[ column ] = currentTotalWidth;
+
+          // The Column is not visible
+          if( !column.Visible )
+          {
+            // Move next
+            currentColumnNode = currentColumnNode.Next;
+            currentColumnIndex++;
+          }
+          else
+          {
+            this.FieldNameToPosition[ column ] = currentColumnIndex;
+
+            currentColumnActualWidth = column.ActualWidth;
+
+            fixedFieldNamesWidth += currentColumnActualWidth;
+            currentTotalWidth += currentColumnActualWidth;
+
+            this.FieldNameToWidth[ column ] = currentColumnActualWidth;
+
+            // We found a FixedCell
+            if( this.FixedColumnCountInternal > currentFixedColumnCount )
+            {
+              fixedColumnsWidth += currentColumnActualWidth;
+
+              this.FixedFieldNames.Add( column );
+
+              currentColumnNode = currentColumnNode.Next;
+              currentColumnIndex++;
+              currentFixedColumnCount++;
+            }
+            else
+            {
+              Debug.Assert( this.FixedColumnCount == currentFixedColumnCount );
+            }
+          }
+        }
+      }
+
+      this.SetFixedColumnsWidth( fixedColumnsWidth );
+
+      double horizontalOffset = this.GetHorizontalOffset();
+      double viewportWidth = this.GetViewportWidth();
+
+      if( this.IsVirtualizing )
+      {
+        // We increment the horizontalOffset to take the fixed columns width into consideration.
+        horizontalOffset += fixedFieldNamesWidth;
+        viewportWidth = Math.Max( 0d, viewportWidth - fixedFieldNamesWidth );
+      }
+
+      // We must consider the fixedFieldNamesWidth width when calculating visible indexes in Viewport
+      double viewportMaximumOffset = horizontalOffset + viewportWidth;
+      double scrollingColumnsWidth = 0d;
+
+      while( currentColumnNode != null )
+      {
+        ColumnBase column = currentColumnNode.Value;
+
+        // Ensure we keep the correct visible offset for every columns even if they are collapsed
+        this.FieldNameToOffset[ column ] = currentTotalWidth;
+
+        if( column.Visible )
+        {
+          bool visibleColumnFieldNameMustBeAdded = false;
+
+          this.FieldNameToPosition[ column ] = currentColumnIndex;
+          currentColumnActualWidth = column.ActualWidth;
+
+          double columnLeftEdgeOffset = currentTotalWidth;
+          double columnRightEdgeOffset = columnLeftEdgeOffset + currentColumnActualWidth;
+
+          currentTotalWidth += currentColumnActualWidth;
+          scrollingColumnsWidth += currentColumnActualWidth;
+
+          this.FieldNameToWidth[ column ] = currentColumnActualWidth;
+
+          if( this.IsVirtualizing )
+          {
+            // The cell is before the ViewPort
+            // Cell .... | --- ViewPort --- |
+            bool beforeViewPort = ( horizontalOffset >= columnRightEdgeOffset );
+
+            // The cell is after the ViewPort
+            // | --- ViewPort --- | .... Cell
+            bool afterViewPort = ( viewportMaximumOffset <= columnLeftEdgeOffset );
+
+            // Columns are in the ViewPort
+            if( !beforeViewPort && !afterViewPort )
+            {
+              // We keep the index of the first viewport column index to ease the FixedColumn splitter change
+              if( this.FirstViewportColumnFieldNameIndex == -1 )
+              {
+                this.SetFirstViewportColumnFieldNameIndex( this.ScrollingFieldNames.Count );
+              }
+
+              visibleColumnFieldNameMustBeAdded = true;
+            }
+          }
+          else
+          {
+            visibleColumnFieldNameMustBeAdded = true;
+          }
+
+          if( visibleColumnFieldNameMustBeAdded && ( !this.FixedFieldNames.Contains( column ) ) && ( !this.ScrollingFieldNames.Contains( column ) ) )
+          {
+            this.ScrollingFieldNames.Add( column );
+          }
+        }
+
+        currentColumnNode = currentColumnNode.Next;
+        currentColumnIndex++;
+      }
+
+      this.SetScrollingColumnsWidth( scrollingColumnsWidth );
+      this.SetVisibleColumnsWidth( currentTotalWidth );
+    }
+
+    protected override void IncrementVersion( object parameters )
+    {
+      // If the manager is detached, it means it will be soon collected, thus don't send update notifications to FixedCellPanels that can still be hook to it (but being recycled).
+      if( !m_detached )
+      {
+        base.IncrementVersion( parameters );
+        this.RaiseUpdateMeasureRequired( parameters as UpdateMeasureRequiredEventArgs );
+      }
+
+      m_incrementVersionDispatcherOperation = null;
+    }
+
+    protected override void DataGridContext_PropertyChanged( object sender, PropertyChangedEventArgs e )
+    {
+      base.DataGridContext_PropertyChanged( sender, e );
+
+      Debug.Assert( !string.IsNullOrEmpty( e.PropertyName ) );
+
+      if( string.IsNullOrEmpty( e.PropertyName ) )
+        return;
+
+      switch( e.PropertyName )
+      {
+        case "FixedHeaderFooterViewPortSize":
+          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ViewPortWidthChanged ) );
+          break;
+
+        case "CurrentItem":
+          // No need to increment version, only notify the current item to invalidate measure
+          this.RaiseUpdateMeasureRequired( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.CurrentItemChanged ) );
+          break;
+      }
+    }
+
+    internal int GetFixedColumnCount()
+    {
+      return this.GetFixedColumnCount( -1 );
+    }
+
+    internal int GetFixedColumnCount( int level )
+    {
+      if( level < 0 )
+        return this.FixedColumnCountInternal;
+
+      //If the list is empty, it means there is no column in the grid right now, so return 0.
+      return 0;
+    }
+
+    internal IColumnInfoCollection<double> GetFieldNameToOffset()
+    {
+      return this.GetFieldNameToOffset( -1 );
+    }
+
+    internal IColumnInfoCollection<double> GetFieldNameToOffset( int level )
+    {
+      if( level < 0 )
+        return this.FieldNameToOffset;
+
+      //If the list is empty, it means there is no column in the grid right now, so return an empty collection, as does the FieldNameToOffset property.
+      return new ColumnInfoCollection<double>();
+    }
+
+    internal IColumnInfoCollection<double> GetFieldNameToWidth()
+    {
+      return this.GetFieldNameToWidth( -1 );
+    }
+
+    internal IColumnInfoCollection<double> GetFieldNameToWidth( int level )
+    {
+      if( level < 0 )
+        return this.FieldNameToWidth;
+
+      //If the list is empty, it means there is no column in the grid right now, so return an empty collection, as does the FieldNameToWidth property.
+      return new ColumnInfoCollection<double>();
+    }
+
+    internal IColumnInfoCollection<int> GetFieldNameToPosition()
+    {
+      return this.GetFieldNameToPosition( -1 );
+    }
+
+    internal IColumnInfoCollection<int> GetFieldNameToPosition( int level )
+    {
+      if( level < 0 )
+        return this.FieldNameToPosition;
+
+      //If the list is empty, it means there is no column in the grid right now, so return an empty collection, as does the FieldNameToPosition property.
+      return new ColumnInfoCollection<int>();
+    }
+
+    internal IColumnNameCollection GetFixedFieldNames()
+    {
+      return this.GetFixedFieldNames( -1 );
+    }
+
+    internal IColumnNameCollection GetFixedFieldNames( int level )
+    {
+      if( level < 0 )
+        return this.FixedFieldNames;
+
+      //If the list is empty, it means there is no column in the grid right now, so return an empty collection, as does the FixedFieldNames property.
+      return new ColumnNameCollection();
+    }
+
+    internal IColumnNameCollection GetScrollingFieldNames()
+    {
+      return this.GetScrollingFieldNames( -1 );
+    }
+
+    internal IColumnNameCollection GetScrollingFieldNames( int level )
+    {
+      if( level < 0 )
+        return this.ScrollingFieldNames;
+
+      //If the list is empty, it means there is no column in the grid right now, so return an empty collection, as does the ScrollingFieldNames property.
+      return new ColumnNameCollection();
+    }
+
+    internal IColumnNameCollection GetVisibleFieldNames()
+    {
+      return this.GetVisibleFieldNames( -1 );
+    }
+
+    internal IColumnNameCollection GetVisibleFieldNames( int level )
+    {
+      if( level < 0 )
+        return this.VisibleFieldNames;
+
+      //If the list is empty, it means there is no column in the grid right now, so return an empty collection, as does the VisibleFieldNames property.
+      return new ColumnNameCollection();
+    }
+
+    internal void SetFixedColumnCount( int level, int fixedColumnCount, int correctionValue )
+    {
+      var dataGridContext = this.DataGridContext;
+
+      // When details are flatten, the detail DataGridContext's FixedColumnCount property is bound to the 
+      // DataGridControl's FixedColumnCount property.  Allowing the value to be changed here would destroy the binding.
+      if( dataGridContext.IsAFlattenDetail )
+        return;
+
+      if( level == -1 )
+      {
+        this.FixedColumnCountInternal = fixedColumnCount;
+      }
+
+      //Set the top level FixedColumnCount property (at this point, either there is no MergedHeaders so level = -1, or fixedColumnCount has been calculated for level 0).
+      if( !m_updatingFixedColumnCount.IsSet )
+      {
+        using( m_updatingFixedColumnCount.Set() )
+        {
+          this.FixedColumnCount = fixedColumnCount;
+        }
+      }
+    }
+
+    internal int GetFirstViewportColumnFieldNameIndex()
+    {
+      return this.GetFirstViewportColumnFieldNameIndex( -1 );
+    }
+
+    internal int GetFirstViewportColumnFieldNameIndex( int level )
+    {
+      if( level < 0 )
+        return this.FirstViewportColumnFieldNameIndex;
+
+      //If the list is empty, it means there is no merged column in the grid right now, so return 0.
+      return 0;
+    }
+
+    internal void UpdateFixedColumnCountInfo( FixedColumnCountInfoEventArgs e )
+    {
+      this.DataGridContext.IsSettingFixedColumnCount = true;
+
+      //Gather the necessary info to update the FixedColumnCount at each MergedHeader level.
+      m_fixedColumnCountInfo = new FixedColumnCountInfo();
+
+      ColumnBase triggeringColumn = e.TriggeringColumn;
+      if( triggeringColumn == null )
+      {
+        m_fixedColumnCountInfo.Level = e.Level;
+      }
+      else
+      {
+        m_fixedColumnCountInfo.Level = -1;
+      }
+
+      switch( e.UpdateType )
+      {
+        case FixedColumnUpdateType.Hide:
+        case FixedColumnUpdateType.Remove:
+          {
+            m_fixedColumnCountInfo.FixedColumnCount = this.GetFixedColumnCount( m_fixedColumnCountInfo.Level ) - 1;
+            m_fixedColumnCountInfo.CorrectionValue = m_fixedColumnCountInfo.FixedColumnCount >= ( this.GetVisibleColumns( m_fixedColumnCountInfo.Level ).Count - 1 ) ? 1 : 0;
+            break;
+          }
+
+        case FixedColumnUpdateType.Show:
+          {
+            m_fixedColumnCountInfo.FixedColumnCount = this.GetFixedColumnCount( m_fixedColumnCountInfo.Level ) + 1;
+            m_fixedColumnCountInfo.CorrectionValue = m_fixedColumnCountInfo.FixedColumnCount > 0 ? 1 : 0;
+            break;
+          }
+
+        case FixedColumnUpdateType.Update:
+          {
+            m_fixedColumnCountInfo.FixedColumnCount = this.GetFixedColumnCount( m_fixedColumnCountInfo.Level );
+            m_fixedColumnCountInfo.CorrectionValue = m_fixedColumnCountInfo.FixedColumnCount >= ( this.GetVisibleColumns( m_fixedColumnCountInfo.Level ).Count - 1 ) ? 1 : 0;
+            break;
+          }
+      }
+    }
+
+    private string FindFirstVisibleFocusableColumnFieldName( LinkedListNode<ColumnBase> startNode, Func<LinkedListNode<ColumnBase>, LinkedListNode<ColumnBase>> getNextNodeHandler )
+    {
+      if( getNextNodeHandler == null )
+        throw new ArgumentNullException( "getNextNodeHandler" );
+
+      if( startNode == null )
+        return null;
+
+      ColumnBase currentColumn = startNode.Value;
+
+      while( ( currentColumn != null )
+        && ( ( currentColumn.ReadOnly )
+          && ( !currentColumn.CanBeCurrentWhenReadOnly )
+          || ( this.FixedFieldNames.Contains( currentColumn.FieldName ) )
+          || ( !currentColumn.Visible ) ) )
+      {
+        startNode = getNextNodeHandler.Invoke( startNode );
+        currentColumn = ( startNode != null ) ? startNode.Value : null;
+      }
+
+      return ( currentColumn != null ) ? currentColumn.FieldName : null;
+    }
+
+    private string GetFirstVisibleFocusableColumnFieldName()
+    {
+      var dataGridContext = this.DataGridContext;
+      if( dataGridContext == null )
+        return null;
+
+      return this.FindFirstVisibleFocusableColumnFieldName(
+               dataGridContext.ColumnsByVisiblePosition.First,
+               ( node ) => node.Next );
+    }
+
+    private string GetLastVisibleFocusableColumnFieldName()
+    {
+      var dataGridContext = this.DataGridContext;
+      if( dataGridContext == null )
+        return null;
+
+      return this.FindFirstVisibleFocusableColumnFieldName(
+               dataGridContext.ColumnsByVisiblePosition.Last,
+               ( node ) => node.Previous );
+    }
+
+    private double GetHorizontalOffset()
+    {
+      var scrollViewer = this.ScrollViewer;
+      if( scrollViewer == null )
+        return 0d;
+
+      return scrollViewer.HorizontalOffset - this.FirstColumnCompensationOffset;
+    }
+
+    private double GetViewportWidth()
+    {
+      // Viewport is only required when UI Virtualization is on.
+      if( !this.IsVirtualizing )
+        return 0d;
+
+      IScrollInfo scrollInfo = null;
+
+      try
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext != null )
+        {
+          scrollInfo = this.DataGridContext.DataGridControl.ItemsHost as IScrollInfo;
+        }
+      }
+      catch( Exception )
+      {
+        // Ignore exceptions since it may be called before the ItemsHost Template is applied
+      }
+
+      double width = ( scrollInfo != null ) ? scrollInfo.ViewportWidth : 0d;
+
+      // We use the HeaderFooterItem width when greater than the viewport width.
+      return Math.Max( width, this.DataGridContext.FixedHeaderFooterViewPortSize.Width );
+    }
+
+    private IList<ColumnBase> GetVisibleColumns( int level )
+    {
+
+      if( level != -1 )
+        throw new ArgumentException( "Not expecting merged headers in this version of the datagrid" );
+
+      return this.DataGridContext.VisibleColumns;
+    }
+
+    private void OnColumnReordering( FixedCellPanel panel, ColumnReorderingEventArgs e )
+    {
+      // We must be sure the VisiblePosition is converted to visible index since some Columns can be Visible = false
+      int oldVisiblePosition = FixedCellPanel.CalculateVisibleIndex( e.OldVisiblePosition, panel.ColumnsByVisiblePosition );
+      int newVisiblePosition = FixedCellPanel.CalculateVisibleIndex( e.NewVisiblePosition, panel.ColumnsByVisiblePosition );
+
+      int correctionValue = 0;
+      int level = panel.ParentRow.LevelCache;
+      int columnCount = this.GetFixedColumnCount( level );
+
+      if( ( oldVisiblePosition < columnCount ) && ( newVisiblePosition >= columnCount ) )
+      {
+        // A column has moved from the fixedPanel to the scrollingPanel.  Do not increment version, it will be done by the FixedColumnCount changed
+        columnCount--;
+        if( columnCount > 0 )
+        {
+          correctionValue = 1;
+        }
+
+        //Set fixed column count at all merged header levels.
+        this.SetFixedColumnCount( level, columnCount, correctionValue );
+
+      }
+      else if( ( oldVisiblePosition >= columnCount ) && ( newVisiblePosition < columnCount ) )
+      {
+        // A column has moved from the scrollingPanel to the fixedPanel.  Do not increment version, it will be done by the FixedColumnCount changed
+        columnCount++;
+        if( columnCount == this.GetVisibleColumns( level ).Count )
+        {
+          correctionValue = 1;
+        }
+
+        //Set fixed column count at all merged header levels.
+        this.SetFixedColumnCount( level, columnCount, correctionValue );
+      }
+      else
+      {
+        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnReordering ) );
+      }
+
+      // This must be done to stop progation of the event even if only one ColumnManagerCell will raise it.
+      e.Handled = true;
+    }
+
+    #region IWeakEventListener Members
+
+    protected override bool OnReceivedWeakEvent( Type managerType, object sender, EventArgs e )
+    {
+      bool handled = true;
+      bool detach = false;
+      DataGridContext dataGridContext = this.DataGridContext;
+
+      if( managerType == typeof( VisibleColumnsUpdatedEventManager ) )
+      {
+        var eventArgs = e as VisibleColumnsUpdatedEventArgs;
+
+        //If flag is true, no need to update all the FixedCellPanel's at this time, but make sure it will be update before it is used again.
+        if( eventArgs != null && eventArgs.OnlyIncrementFlag )
+        {
+          base.IncrementVersion( null );
+        }
+        else
+        {
+          var detailConfig = this.DataGridContext.SourceDetailConfiguration;
+
+          //Make sure the FixedColumnCount is valid at each MergedHeader level
+          if( this.FixedColumnCount != 0 && ( this.DataGridContext.IsSettingFixedColumnCount || ( detailConfig != null && detailConfig.IsSettingFixedColumnCount ) ) )
+          {
+            if( m_fixedColumnCountInfo != null )
+            {
+              this.SetFixedColumnCount( m_fixedColumnCountInfo.Level, m_fixedColumnCountInfo.FixedColumnCount, m_fixedColumnCountInfo.CorrectionValue );
+              m_fixedColumnCountInfo = null;
+            }
+
+            this.DataGridContext.IsSettingFixedColumnCount = false;
+            if( detailConfig != null )
+            {
+              detailConfig.IsSettingFixedColumnCount = false;
+            }
+          }
+
+          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnReordering ) );
+        }
+      }
+      else if( managerType == typeof( CollectionChangedEventManager ) )
+      {
+        if( sender == dataGridContext.Items.SortDescriptions )
+        {
+          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.SortingChanged ) );
+        }
+        else if( sender == dataGridContext.Items.GroupDescriptions )
+        {
+          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.GroupingChanged ) );
+        }
+      }
+      else if( managerType == typeof( ColumnActualWidthEventManager ) )
+      {
+        var args = e as ColumnActualWidthChangedEventArgs;
+
+        // We pass the delta between the old and new value to tell the Panel to reduce the horizontal offset when a column is auto-resized to a smaller value
+        if( args != null )
+        {
+          double delta = args.OldValue - args.NewValue;
+          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnActualWidthChanged, delta ) );
+        }
+        else
+        {
+          this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.ColumnActualWidthChanged ) );
+        }
+      }
+      else if( managerType == typeof( FixedColumnCountInfoEventManager ) )
+      {
+        var infoEventArgs = e as FixedColumnCountInfoEventArgs;
+        this.UpdateFixedColumnCountInfo( infoEventArgs );
+      }
+      else if( managerType == typeof( ViewChangedEventManager ) )
+      {
+        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
+
+        detach = true;
+      }
+      else if( managerType == typeof( ThemeChangedEventManager ) )
+      {
+        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
+
+        detach = true;
+      }
+      else if( managerType == typeof( DataGridControlTemplateChangedEventManager ) )
+      {
+        this.UpdateScrollViewer();
+        this.IncrementVersion( new UpdateMeasureRequiredEventArgs( UpdateMeasureTriggeredAction.Unspecified ) );
+      }
+      else if( managerType == typeof( ItemsSourceChangeCompletedEventManager ) )
+      {
+        detach = true;
+      }
+      else
+      {
+        handled = false;
+      }
+
+      if( detach && ( dataGridContext != null ) )
+      {
+        // Detach the ColumnVirtualizationManager from the DataGridContext.
+        ColumnVirtualizationManager.SetColumnVirtualizationManager( dataGridContext, null );
+        m_detached = true;
+
+        this.Uninitialize();
+      }
+
+      return handled;
+    }
+
+    #endregion
+
+    private FixedColumnCountInfo m_fixedColumnCountInfo;
+    private bool m_detached;
+
+    internal sealed class ColumnNameCollection : IColumnNameCollection
+    {
+      public int Count
+      {
+        get
+        {
+          return m_list.Count;
+        }
+      }
+
+      public string this[ int index ]
+      {
+        get
+        {
+          return m_list[ index ];
+        }
+      }
+
+      public void Clear()
+      {
+        m_list.Clear();
+        m_list.TrimExcess();
+
+        m_lookup.Clear();
+        m_lookup.TrimExcess();
+      }
+
+      public void Add( string fieldName )
+      {
+        if( fieldName == null )
+          return;
+
+        if( m_lookup.Contains( fieldName ) )
+          return;
+
+        m_lookup.Add( fieldName );
+        m_list.Add( fieldName );
+      }
+
+      public void Add( ColumnBase column )
+      {
+        if( column == null )
+          return;
+
+        this.Add( column.FieldName );
+      }
+
+      public void Remove( string fieldName )
+      {
+        if( fieldName == null )
+          return;
+
+        if( !m_lookup.Contains( fieldName ) )
+          return;
+
+        m_lookup.Remove( fieldName );
+        m_list.Remove( fieldName );
+      }
+
+      public void Remove( ColumnBase column )
+      {
+        if( column == null )
+          return;
+
+        this.Remove( column.FieldName );
+      }
+
+      public bool Contains( string fieldName )
+      {
+        if( fieldName == null )
+          return false;
+
+        return m_lookup.Contains( fieldName );
+      }
+
+      public bool Contains( ColumnBase column )
+      {
+        if( column == null )
+          return false;
+
+        return this.Contains( column.FieldName );
+      }
+
+      public IEnumerator<string> GetEnumerator()
+      {
+        return m_list.GetEnumerator();
+      }
+
+      IEnumerator IEnumerable.GetEnumerator()
+      {
+        return this.GetEnumerator();
+      }
+
+      private readonly List<string> m_list = new List<string>();
+      private readonly HashSet<string> m_lookup = new HashSet<string>();
+    }
+
+    internal sealed class ColumnInfoCollection<T> : IColumnInfoCollection<T>
+    {
+      public void Clear()
+      {
+        m_data.Clear();
+      }
+
+      public T this[ string fieldName ]
+      {
+        get
+        {
+          return m_data[ fieldName ];
+        }
+        set
+        {
+          if( fieldName == null )
+            return;
+
+          m_data[ fieldName ] = value;
+        }
+      }
+
+      public T this[ ColumnBase column ]
+      {
+        get
+        {
+          return this[ column.FieldName ];
+        }
+        set
+        {
+          if( column == null )
+            return;
+
+          this[ column.FieldName ] = value;
+        }
+      }
+
+      public void Reset( string fieldName )
+      {
+        if( fieldName == null )
+          return;
+
+        m_data.Remove( fieldName );
+      }
+
+      public void Reset( ColumnBase column )
+      {
+        if( column == null )
+          return;
+
+        this.Reset( column.FieldName );
+      }
+
+      public bool Contains( string fieldName )
+      {
+        if( fieldName == null )
+          return false;
+
+        return m_data.ContainsKey( fieldName );
+      }
+
+      public bool Contains( ColumnBase column )
+      {
+        if( column == null )
+          return false;
+
+        return this.Contains( column.FieldName );
+      }
+
+      public bool TryGetValue( string fieldName, out T value )
+      {
+        if( fieldName != null )
+          return m_data.TryGetValue( fieldName, out value );
+
+        value = default( T );
+        return false;
+      }
+
+      public bool TryGetValue( ColumnBase column, out T value )
+      {
+        if( column != null )
+          return this.TryGetValue( column.FieldName, out value );
+
+        value = default( T );
+        return false;
+      }
+
+      private readonly Dictionary<string, T> m_data = new Dictionary<string, T>();
+    }
+
+    private sealed class ColumnNameLookup : IColumnNameCollection
+    {
+      internal ColumnNameLookup( IEnumerable<IColumnNameCollection> collection )
+      {
+        m_collection = ( collection != null ) ? collection.ToList() : new List<IColumnNameCollection>( 0 );
+      }
+
+      public int Count
+      {
+        get
+        {
+          return m_collection.Sum( item => item.Count );
+        }
+      }
+
+      public string this[ int index ]
+      {
+        get
+        {
+          foreach( var collection in m_collection )
+          {
+            int count = collection.Count;
+
+            if( index < count )
+              return collection[ index ];
+
+            index -= count;
+          }
+
+          throw new ArgumentOutOfRangeException( "index" );
+        }
+      }
+
+      public void Clear()
+      {
+        throw new NotSupportedException();
+      }
+
+      public void Add( string fieldName )
+      {
+        throw new NotSupportedException();
+      }
+
+      public void Add( ColumnBase column )
+      {
+        throw new NotSupportedException();
+      }
+
+      public void Remove( string fieldName )
+      {
+        throw new NotSupportedException();
+      }
+
+      public void Remove( ColumnBase column )
+      {
+        throw new NotSupportedException();
+      }
+
+      public bool Contains( string fieldName )
+      {
+        if( fieldName == null )
+          return false;
+
+        return ( from list in m_collection
+                 where list.Contains( fieldName )
+                 select true ).Any();
+      }
+
+      public bool Contains( ColumnBase column )
+      {
+        if( column == null )
+          return false;
+
+        return this.Contains( column.FieldName );
+      }
+
+      public IEnumerator<string> GetEnumerator()
+      {
+        if( m_collection.Count == 0 )
+          return Enumerable.Empty<string>().GetEnumerator();
+
+        IEnumerable<string> result = m_collection[ 0 ];
+        foreach( var more in m_collection.Skip( 1 ) )
+        {
+          result = result.Concat( more );
+        }
+
+        return result.GetEnumerator();
+      }
+
+      IEnumerator IEnumerable.GetEnumerator()
+      {
+        return this.GetEnumerator();
+      }
+
+      private readonly List<IColumnNameCollection> m_collection;
+    }
+
+    private sealed class RoutedEventManager
+    {
+      private static RoutedEventManager Singleton;
+      private static int Registered; //0
+
+      private RoutedEventManager()
+      {
+      }
+
+      internal static RoutedEventManager Instance
+      {
+        get
+        {
+          if( RoutedEventManager.Singleton == null )
+          {
+            Interlocked.CompareExchange<RoutedEventManager>( ref RoutedEventManager.Singleton, new RoutedEventManager(), null );
+          }
+
+          return RoutedEventManager.Singleton;
+        }
+      }
+
+      internal void Register()
+      {
+        if( Interlocked.CompareExchange( ref RoutedEventManager.Registered, 1, 0 ) == 1 )
+          return;
+
+        // Register to ColumnManagerCell.ColumnReorderingEvent on FixedCellPanel type
+        // to be notified the corret DataGridContext level
+        EventManager.RegisterClassHandler(
+          typeof( FixedCellPanel ),
+          ColumnManagerCell.ColumnReorderingEvent,
+          new ColumnReorderingEventHandler( RoutedEventManager.OnColumnReordering ) );
+      }
+
+      private static void OnColumnReordering( object sender, ColumnReorderingEventArgs e )
+      {
+        var panel = sender as FixedCellPanel;
+        if( panel == null )
+          return;
+
+        var dataGridContext = DataGridControl.GetDataGridContext( panel );
+        if( dataGridContext == null )
+          return;
+
+        var manager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManagerBase;
+        if( manager == null )
+          return;
+
+        manager.OnColumnReordering( panel, e );
+      }
+    }
+
+    private class FixedColumnCountInfo
+    {
+      internal int Level
+      {
+        get;
+        set;
+      }
+
+      internal int FixedColumnCount
+      {
+        get;
+        set;
+      }
+
+      internal int CorrectionValue
+      {
+        get;
+        set;
+      }
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/UpdateMeasureRequiredEventManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/UpdateMeasureRequiredEventManager.cs
index d9d04a65..bc27eca2 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/UpdateMeasureRequiredEventManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/UpdateMeasureRequiredEventManager.cs
@@ -15,9 +15,6 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Windows;
 
 namespace Xceed.Wpf.DataGrid.Views
@@ -40,26 +37,20 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected override void StartListening( object source )
     {
-      TableViewColumnVirtualizationManager columnVirtualizationManager = source as TableViewColumnVirtualizationManager;
-      if( columnVirtualizationManager != null )
-      {
-        columnVirtualizationManager.UpdateMeasureRequired += this.OnUpdateMeasureRequired;
-        return;
-      }
+      var columnVirtualizationManager = source as TableViewColumnVirtualizationManagerBase;
+      if( columnVirtualizationManager == null )
+        throw new InvalidOperationException( "An attempt was made to use a source other than a ColumnVirtualizationManager." );
 
-      throw new InvalidOperationException( "An attempt was made to use a source other than a ColumnVirtualizationManager." );
+      columnVirtualizationManager.UpdateMeasureRequired += this.OnUpdateMeasureRequired;
     }
 
     protected override void StopListening( object source )
     {
-      TableViewColumnVirtualizationManager columnVirtualizationManager = source as TableViewColumnVirtualizationManager;
-      if( columnVirtualizationManager != null )
-      {
-        columnVirtualizationManager.UpdateMeasureRequired -= this.OnUpdateMeasureRequired;
-        return;
-      }
+      var columnVirtualizationManager = source as TableViewColumnVirtualizationManagerBase;
+      if( columnVirtualizationManager == null )
+        throw new InvalidOperationException( "An attempt was made to use a source other than a ColumnVirtualizationManager." );
 
-      throw new InvalidOperationException( "An attempt was made to use a source other than a ColumnVirtualizationManager." );
+      columnVirtualizationManager.UpdateMeasureRequired -= this.OnUpdateMeasureRequired;
     }
 
     private static UpdateMeasureRequiredEventManager CurrentManager
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/VirtualizingFixedCellSubPanel.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/VirtualizingFixedCellSubPanel.cs
index 1ca2b714..7afa1935 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/VirtualizingFixedCellSubPanel.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(ColumnVirtualization)/VirtualizingFixedCellSubPanel.cs
@@ -16,13 +16,14 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
-using Xceed.Wpf.DataGrid.Print;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
-  internal class VirtualizingFixedCellSubPanel : FixedCellSubPanel, IPrintInfo
+  internal class VirtualizingFixedCellSubPanel : FixedCellSubPanel
   {
     public VirtualizingFixedCellSubPanel( FixedCellPanel parentPanel )
       : base( parentPanel )
@@ -32,18 +33,15 @@ namespace Xceed.Wpf.DataGrid.Views
     // Measure horizontally.
     protected override Size MeasureOverride( Size constraint )
     {
-      Size desiredSize = new Size();
-
-      DataGridContext dataGridContext = this.DataGridContext;
-
-      // DataGridContext can be null when a the parent Row was not prepared
-      if( dataGridContext == null )
+      // This can be null when the parent Row is not prepared yet.
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
+      if( columnVirtualizationManager == null )
         return this.DesiredSize;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-      Dictionary<string, double> columnToVisibleWidth = columnVirtualizationManager.FieldNameToWidth;
+      var desiredSize = new Size();
+      var columnToVisibleWidth = columnVirtualizationManager.GetFieldNameToWidth( this.ParentPanel.ParentRow.LevelCache );
 
-      foreach( Cell cell in this.GetCellsToLayout() )
+      foreach( var cell in this.GetCellsToLayout() )
       {
         double width;
 
@@ -54,7 +52,7 @@ namespace Xceed.Wpf.DataGrid.Views
         else
         {
           // The cell will be hidden.
-          cell.Measure( Size.Empty );
+          cell.Measure( new Size() );
         }
 
         if( cell.DesiredSize.Height > desiredSize.Height )
@@ -71,22 +69,20 @@ namespace Xceed.Wpf.DataGrid.Views
     // Arrange horizontally.
     protected override Size ArrangeOverride( Size arrangeSize )
     {
-      DataGridContext dataGridContext = this.DataGridContext;
-
-      // DataGridContext can be null when the parent Row was not prepared
-      if( dataGridContext == null )
+      // This can be null when the parent Row is not prepared yet.
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
+      if( columnVirtualizationManager == null )
         return this.DesiredSize;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-      Dictionary<string, double> columnToVisibleOffset = columnVirtualizationManager.FieldNameToOffset;
+      var columnToVisibleOffset = columnVirtualizationManager.GetFieldNameToOffset( this.ParentPanel.ParentRow.LevelCache );
 
-      ScrollViewer parentScrollViewer = dataGridContext.DataGridControl.ScrollViewer;
+      ScrollViewer parentScrollViewer = this.DataGridContext.DataGridControl.ScrollViewer;
       double horizontalOffset = parentScrollViewer.HorizontalOffset;
       double fixedColumnVisibleWidth = columnVirtualizationManager.FixedColumnsWidth;
       double firstColumnCompensationOffset = columnVirtualizationManager.FirstColumnCompensationOffset;
       Rect finalRect = new Rect( arrangeSize );
 
-      foreach( Cell cell in this.GetCellsToLayout() )
+      foreach( var cell in this.GetCellsToLayout() )
       {
         // Calculate the offset of the Cell:
         //    The original offset of the Column
@@ -94,10 +90,7 @@ namespace Xceed.Wpf.DataGrid.Views
         //    - the width of the fixed columns since we are in the Scrolling FixedCellSubPanel
         //    + the compensation offset used in master detail to avoid scrolling when not required 
 
-        double cellOffset = columnToVisibleOffset[ cell.FieldName ]
-          - horizontalOffset
-          - fixedColumnVisibleWidth
-          + firstColumnCompensationOffset;
+        double cellOffset = columnToVisibleOffset[ cell.FieldName ] - horizontalOffset - fixedColumnVisibleWidth + firstColumnCompensationOffset;
 
         finalRect.X = cellOffset;
         finalRect.Width = cell.DesiredSize.Width;
@@ -111,39 +104,49 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected override IEnumerable<string> GetVisibleFieldsName()
     {
-      DataGridContext dataGridContext = this.DataGridContext;
-      if( dataGridContext == null )
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
+      if( columnVirtualizationManager == null )
         return new string[ 0 ];
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager =
-        dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-      return columnVirtualizationManager.ScrollingFieldNames;
+      return columnVirtualizationManager.GetScrollingFieldNames( this.ParentPanel.ParentRow.LevelCache );
     }
 
     private IEnumerable<Cell> GetCellsToLayout()
     {
-      HashSet<Cell> layoutedCells = new HashSet<Cell>( this.GetVisibleCells() );
-      CellCollection collection = this.ParentPanel.ParentRowCells;
+      var visibleCells = this.GetVisibleCells();
+
+      // Check out if there are any out of view cells that needs to be layouted for different purpose.  In case of a BringIntoView, the cell
+      // must be layouted in order to find out the target location.  In case of a non recyclable cell, the cell must be arranged out of view.
+      var permanentScrollingFieldNames = this.ParentPanel.PermanentScrollingFieldNames;
+      if( !permanentScrollingFieldNames.Any() )
+        return visibleCells;
+
+      // Make sure we have access to the collection containing the additional cells to be layouted.
+      var cellsCollection = this.ParentPanel.ParentRowCells;
+      if( cellsCollection == null )
+        return visibleCells;
+
+      return this.GetCellsToLayout( visibleCells, permanentScrollingFieldNames, cellsCollection );
+    }
 
-      if( collection != null )
+    private IEnumerable<Cell> GetCellsToLayout( IEnumerable<Cell> visibleCells, IEnumerable<string> permanentScrollingFieldNames, VirtualizingCellCollection cellsCollection )
+    {
+      List<string> unhandledCells = permanentScrollingFieldNames.ToList();
+
+      foreach( var cell in visibleCells )
       {
-        // Retrieve the cells that aren't in view anymore but needs to be measured
-        // and arranged for different purpose.  In case of a BringIntoView, the cell
-        // must be layouted in order to find out the target location.  In case of a
-        // non recyclable cell, the cell must be arranged out of view.
-        foreach( string fieldName in this.ParentPanel.PermanentScrollingFieldNames )
-        {
-          Cell cell = collection[ fieldName ];
+        unhandledCells.Remove( cell.FieldName );
 
-          if( ( cell != null ) && ( !layoutedCells.Contains( cell ) ) )
-          {
-            layoutedCells.Add( cell );
-          }
-        }
+        yield return cell;
       }
 
-      return layoutedCells;
+      foreach( var fieldName in unhandledCells )
+      {
+        var cell = cellsCollection.GetCell( fieldName, false );
+        Debug.Assert( cell != null );
+
+        yield return cell;
+      }
     }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/FlattenDetailBindingModeEnum.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/FlattenDetailBindingModeEnum.cs
new file mode 100644
index 00000000..4aa68000
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/FlattenDetailBindingModeEnum.cs
@@ -0,0 +1,27 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal enum FlattenDetailBindingMode
+  {
+    Default,
+    None,
+    MasterOneWay,
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/MasterDetailLayoutModeEnum.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/MasterDetailLayoutModeEnum.cs
new file mode 100644
index 00000000..1bdd1701
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(Enums)/MasterDetailLayoutModeEnum.cs
@@ -0,0 +1,26 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal enum MasterDetailLayoutMode
+  {
+    Default,
+    Flatten,
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/ColumnReorderingDragSourceManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/ColumnReorderingDragSourceManager.cs
index b2f32435..3c1f85fc 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/ColumnReorderingDragSourceManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/ColumnReorderingDragSourceManager.cs
@@ -16,44 +16,34 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq;
-using System.Text;
-using Xceed.Utils.Wpf.DragDrop;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Documents;
-using System.Diagnostics;
+using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Animation;
-using System.Windows.Input;
-using System.Windows.Controls;
-using Xceed.Utils.Math;
-using System.Collections.ObjectModel;
+using Xceed.Utils.Wpf.DragDrop;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
   internal class ColumnReorderingDragSourceManager : DragSourceManager
   {
-    public ColumnReorderingDragSourceManager( UIElement draggedElement,
-                              AdornerLayer adornerLayerInsideDragContainer,
-                              UIElement dragContainer )
+    public ColumnReorderingDragSourceManager( UIElement draggedElement, AdornerLayer adornerLayerInsideDragContainer, UIElement dragContainer, int level )
       : this( draggedElement, adornerLayerInsideDragContainer, dragContainer, true )
     {
+      m_level = level;
     }
 
-    public ColumnReorderingDragSourceManager( UIElement draggedElement,
-                              AdornerLayer adornerLayerInsideDragContainer,
-                              UIElement dragContainer,
-                              bool enableAutoScroll )
+    public ColumnReorderingDragSourceManager( UIElement draggedElement, AdornerLayer adornerLayerInsideDragContainer, UIElement dragContainer, bool enableAutoScroll )
       : this( draggedElement, adornerLayerInsideDragContainer, dragContainer, enableAutoScroll, true )
     {
-
     }
 
-    public ColumnReorderingDragSourceManager( UIElement draggedElement,
-                                                      AdornerLayer adornerLayerInsideDragContainer,
-                                                      UIElement dragContainer,
-                                                      bool enableAutoScroll,
-                                                      bool showDraggedElementGhost )
+    public ColumnReorderingDragSourceManager( UIElement draggedElement, AdornerLayer adornerLayerInsideDragContainer, UIElement dragContainer, bool enableAutoScroll,
+                                              bool showDraggedElementGhost )
       : base( draggedElement, adornerLayerInsideDragContainer, dragContainer, enableAutoScroll, showDraggedElementGhost )
     {
     }
@@ -70,25 +60,55 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region AnimatedColumnReorderingTranslation Attached Property
 
-    // This translation will be used by the AnimatedColumnReorderingManager to apply
-    // a TranslateTransform to Columns that require it in order to give a preview
-    // of the reordering in an animated or live way
+    // This translation will be used by the AnimatedColumnReorderingManager to apply a TranslateTransform
+    // to Columns that require it in order to give a preview of the reordering in an animated or live way
     internal static readonly DependencyProperty AnimatedColumnReorderingTranslationProperty = DependencyProperty.RegisterAttached(
       "AnimatedColumnReorderingTranslation",
-      typeof( TranslateTransform ),
+      typeof( TransformGroup ),
       typeof( ColumnReorderingDragSourceManager ),
       new FrameworkPropertyMetadata( null ) );
 
-    internal static TranslateTransform GetAnimatedColumnReorderingTranslation( DependencyObject obj )
+    internal static TransformGroup GetAnimatedColumnReorderingTranslation( DependencyObject obj )
     {
-      return ( TranslateTransform )obj.GetValue( ColumnReorderingDragSourceManager.AnimatedColumnReorderingTranslationProperty );
+      return ( TransformGroup )obj.GetValue( ColumnReorderingDragSourceManager.AnimatedColumnReorderingTranslationProperty );
     }
 
-    internal static void SetAnimatedColumnReorderingTranslation( DependencyObject obj, TranslateTransform value )
+    internal static void SetAnimatedColumnReorderingTranslation( DependencyObject obj, TransformGroup value )
     {
       obj.SetValue( ColumnReorderingDragSourceManager.AnimatedColumnReorderingTranslationProperty, value );
     }
 
+    private static TranslateTransform GetAnimatedColumnReorderingPositionTransform( DependencyObject obj )
+    {
+      TransformGroup transformGroup = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingTranslation( obj );
+      if( transformGroup == null )
+      {
+        transformGroup = ColumnReorderingDragSourceManager.CreateTransformGroup( obj );
+      }
+      return transformGroup.Children[ 0 ] as TranslateTransform;
+    }
+
+    private static TransformGroup GetAnimatedColumnReorderingTransformGroup( DependencyObject obj )
+    {
+      TransformGroup transformGroup = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingTranslation( obj );
+      if( transformGroup == null )
+      {
+        transformGroup = ColumnReorderingDragSourceManager.CreateTransformGroup( obj );
+      }
+
+      return transformGroup;
+    }
+
+    private static TransformGroup CreateTransformGroup( DependencyObject obj )
+    {
+      TransformGroup transformGroup = new TransformGroup();
+      transformGroup.Children.Add( new TranslateTransform() );
+      transformGroup.Children.Add( new ScaleTransform() );
+      ColumnReorderingDragSourceManager.SetAnimatedColumnReorderingTranslation( obj, transformGroup );
+
+      return transformGroup;
+    }
+
     #endregion
 
     #region ColumnAnimationDuration Public Property
@@ -105,8 +125,7 @@ namespace Xceed.Wpf.DataGrid.Views
         {
           m_columnAnimationDurationCache = value;
           // Keep a cache of the duration as a Duration struct for performance
-          m_columnAnimationDuration
-            = new Duration( TimeSpan.FromMilliseconds( m_columnAnimationDurationCache ) );
+          m_columnAnimationDuration = new Duration( TimeSpan.FromMilliseconds( m_columnAnimationDurationCache ) );
         }
       }
     }
@@ -143,6 +162,18 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #endregion
 
+    #region VisibleColumns Property
+
+    private ReadOnlyObservableCollection<ColumnBase> VisibleColumns
+    {
+      get
+      {
+        return this.DraggedDataGridContext.VisibleColumns;
+      }
+    }
+
+    #endregion
+
     #region FixedColumnSplitterTranslation Private Property
 
     private TranslateTransform FixedColumnSplitterTranslation
@@ -155,7 +186,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region ColumnVirtualizationManager Private Property
 
-    private TableViewColumnVirtualizationManager ColumnVirtualizationManager
+    private TableViewColumnVirtualizationManagerBase ColumnVirtualizationManager
     {
       get;
       set;
@@ -171,7 +202,7 @@ namespace Xceed.Wpf.DataGrid.Views
       {
         if( m_reorderingInfoManager == null )
         {
-          m_reorderingInfoManager = new ReorderingInfoManager();
+          m_reorderingInfoManager = new ReorderingInfoManager( m_level );
         }
 
         return m_reorderingInfoManager;
@@ -182,34 +213,24 @@ namespace Xceed.Wpf.DataGrid.Views
 
     public void AddDraggedColumnGhost( UIElement element )
     {
-      if( element == null )
+      if( ( element == null ) || m_elementToDraggedElementAdorner.ContainsKey( element ) )
         return;
 
       // Get the Rect for the DataGridControl
       DataGridControl dataGridControl = this.DraggedDataGridContext.DataGridControl;
 
-      Rect dataGridControlRect = new Rect( 0,
-        0,
-        dataGridControl.ActualWidth,
-        dataGridControl.ActualHeight );
+      Rect dataGridControlRect = new Rect( 0, 0, dataGridControl.ActualWidth, dataGridControl.ActualHeight );
 
-      Point elementToDataGridControl
-        = element.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, dataGridControl );
+      Point elementToDataGridControl = element.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, dataGridControl );
 
       // Get the Rect for the element that request a ghost
       Rect elementRect = new Rect( elementToDataGridControl, element.RenderSize );
 
-      // This is a special case with the current Element that is 
-      // always be layouted, but can be out of view
+      // This is a special case with the current Element that is always layouted, but can be out of view
       if( !elementRect.IntersectsWith( dataGridControlRect ) )
         return;
 
-      // We already have a DraggedElementAdorner for this Cell
-      if( m_elementToDraggedElementAdorner.ContainsKey( element ) )
-        return;
-
-      AnimatedDraggedElementAdorner adorner
-        = new AnimatedDraggedElementAdorner( element, this.AdornerLayerInsideDragContainer, true );
+      AnimatedDraggedElementAdorner adorner = new AnimatedDraggedElementAdorner( element, this.AdornerLayerInsideDragContainer, true );
 
       this.ApplyContainerClip( adorner );
 
@@ -223,17 +244,23 @@ namespace Xceed.Wpf.DataGrid.Views
       if( m_elementToDraggedElementAdorner.Count == 0 )
         return;
 
-      DraggedElementAdorner adorner = null;
-
+      DraggedElementAdorner adorner;
       if( !m_elementToDraggedElementAdorner.TryGetValue( element, out adorner ) )
         return;
 
-      adorner = m_elementToDraggedElementAdorner[ element ];
       Debug.Assert( adorner != null );
       this.AdornerLayerInsideDragContainer.Remove( adorner );
       m_elementToDraggedElementAdorner.Remove( element );
     }
 
+    public bool ContainsDraggedColumnGhost( UIElement element )
+    {
+      if( ( element == null ) || ( m_elementToDraggedElementAdorner.Count == 0 ) )
+        return false;
+
+      return m_elementToDraggedElementAdorner.ContainsKey( element );
+    }
+
     public override void SetDraggedElement( UIElement newDraggedElement )
     {
       // Ensure to remove all ghost previously
@@ -262,8 +289,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     public override void ProcessMouseLeftButtonDown( MouseButtonEventArgs e )
     {
-      // Must re-initialize the manager before processing the MouseLeftButtonDown
-      // to ensure the internal state is up to date
+      // Must re-initialize the manager before processing the MouseLeftButtonDown to ensure the internal state is up to date
       this.InitializeManager();
 
       this.UpdateIsAnimatedColumnReorderingEnabled();
@@ -292,25 +318,23 @@ namespace Xceed.Wpf.DataGrid.Views
       DataGridContext dataGridContext = this.DraggedDataGridContext;
 
       Cell draggedCell = draggedElement as Cell;
-
       if( draggedCell != null )
       {
-        reorderingInfoManager.BeginReordering( dataGridContext, draggedCell.ParentColumn.VisiblePosition );
+        int initialFixedColumnCount = this.ColumnVirtualizationManager.GetFixedColumnCount( m_level );
+        reorderingInfoManager.BeginReordering( dataGridContext, draggedCell.ParentColumn.VisiblePosition, initialFixedColumnCount );
       }
 
       // Get initial mouse positions
       Point draggedElementToMouse = e.GetPosition( draggedElement );
 
-      m_lastDraggedElementOffset = draggedElement.TranslatePoint(
-        draggedElementToMouse,
-        this.DragContainer ).X;
+      m_lastDraggedElementOffset = draggedElement.TranslatePoint( draggedElementToMouse, this.DragContainer ).X;
 
       // Affect the manager on the DataGridContext and DraggedColumn
       TableflowView.SetAreColumnsBeingReordered( dataGridContext, true );
 
       if( draggedCell != null )
       {
-        TableflowView.SetColumnReorderingDragSourceManager( draggedCell.ParentColumn, this );
+        draggedCell.ParentColumn.SetColumnReorderingDragSourceManager( this );
       }
 
       TableflowView.SetColumnReorderingDragSourceManager( dataGridContext, this );
@@ -385,7 +409,6 @@ namespace Xceed.Wpf.DataGrid.Views
 
       Cell draggedCell = this.DraggedElement as Cell;
       Debug.Assert( draggedCell != null );
-      Debug.Assert( draggedCell == this.DraggedElement );
 
       Point parentRowToDragContainer = parentRow.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, dragContainer );
 
@@ -396,7 +419,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
       Point draggedElementToDragContainer = draggedCell.TranslatePoint( draggedElementToMouse, dragContainer );
 
-      double draggedelementWidth = draggedCell.RenderSize.Width;
+      double draggedElementWidth = draggedCell.RenderSize.Width;
 
       // Get the Rect for the DragContainer
       Rect dragContainerRect = new Rect( ColumnReorderingDragSourceManager.EmptyPoint, dragContainer.RenderSize );
@@ -417,7 +440,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
         if( m_horizontalMouseDragDirection == HorizontalMouseDragDirection.Left )
         {
-          double rightEdge = draggedElementToDragContainer.X + draggedelementWidth;
+          double rightEdge = draggedElementToDragContainer.X + draggedElementWidth;
 
           // When scrolling left, try to find the first IDropTarget from the left edge of the dragged element to the mouse cursor to the mouse cursor over the dragged element
           while( ( returnedDropTarget == null ) && ( correctedPoint.X < rightEdge ) )
@@ -514,7 +537,7 @@ namespace Xceed.Wpf.DataGrid.Views
         draggedElementToMouse.Y -= this.InitialMousePositionToDraggedElement.GetValueOrDefault().Y;
 
         this.ApplyContainerClip( m_popupDraggedElementAdorner );
-        m_popupDraggedElementAdorner.AdornedElementImage.Opacity = 1;
+        m_popupDraggedElementAdorner.AdornedElementImage.Opacity = 1d;
         m_popupDraggedElementAdorner.SetOffset( draggedElementToMouse );
       }
       //If no animation, or if the dragged object is beyond the edge of the grid, no need to do anything in this override, simply call base.
@@ -524,9 +547,7 @@ namespace Xceed.Wpf.DataGrid.Views
         // We are reverting every animation before detaching from the manager
         // so do not update the ghost position
         if( m_ghostToTargetAndDetachAnimationClock != null )
-        {
           return;
-        }
 
         bool dragOverRowOrCell = ( this.CurrentDropTarget as ColumnManagerRow ) != null || ( this.CurrentDropTarget as ColumnManagerCell ) != null;
 
@@ -560,7 +581,7 @@ namespace Xceed.Wpf.DataGrid.Views
           draggedElementToMouse.Y -= this.InitialMousePositionToDraggedElement.GetValueOrDefault().Y;
 
           this.ApplyContainerClip( m_popupDraggedElementAdorner );
-          m_popupDraggedElementAdorner.AdornedElementImage.Opacity = 1;
+          m_popupDraggedElementAdorner.AdornedElementImage.Opacity = 1d;
           m_popupDraggedElementAdorner.SetOffset( draggedElementToMouse );
         }
         //If animations are required.
@@ -569,7 +590,7 @@ namespace Xceed.Wpf.DataGrid.Views
           //If in a popup, hide the dragged element adorner.
           if( this.ParentWindowIsPopup )
           {
-            m_popupDraggedElementAdorner.AdornedElementImage.Opacity = 0;
+            m_popupDraggedElementAdorner.AdornedElementImage.Opacity = 0d;
             m_popupDraggedElementAdorner.SetOffset( ColumnReorderingDragSourceManager.EmptyPoint );
           }
 
@@ -586,17 +607,12 @@ namespace Xceed.Wpf.DataGrid.Views
           draggedElementToMouse.X -= this.InitialMousePositionToDraggedElement.GetValueOrDefault().X;
           draggedElementToMouse.Y -= this.InitialMousePositionToDraggedElement.GetValueOrDefault().Y;
 
-          // Wait for the animation to complete before explicitly setting the 
-          // X and Y offsets on the ghost adorners
-          // OR if reordering was canceled
-          if( ( m_ghostToMousePositionAnimationClock == null )
-            && ( m_ghostToTargetColumnAnimationClock == null )
-            && !m_reorderCancelled )
+          // Wait for the animation to complete before explicitly setting the X and Y offsets on the ghost adorners OR if reordering was canceled
+          if( ( m_ghostToMousePositionAnimationClock == null ) && ( m_ghostToTargetColumnAnimationClock == null ) && !m_reorderCancelled )
           {
             // Update the position of ghosts for each rows
-            foreach( UIElement element in m_elementToDraggedElementAdorner.Keys )
+            foreach( var adorner in this.GetElementAdorners() )
             {
-              DraggedElementAdorner adorner = m_elementToDraggedElementAdorner[ element ];
               adorner.ApplyAnimationClock( DraggedElementAdorner.OffsetProperty, null );
               adorner.SetOffset( draggedElementToMouse );
             }
@@ -634,8 +650,8 @@ namespace Xceed.Wpf.DataGrid.Views
 
       if( draggedCell != null )
       {
-        // Affect the IsBeingDraggedAnimated in the ParentColumn to ensure every prepared container calls AddDraggedColumnGhost to this manager
-        TableflowView.SetIsBeingDraggedAnimated( draggedCell.ParentColumn, true );
+        // Affect the IsBeingDraggedAnimated of the ParentColumn to ensure every prepared container calls AddDraggedColumnGhost to this manager
+        draggedCell.ParentColumn.SetIsBeingDraggedAnimated( true );
       }
 
       this.HideDraggedElements();
@@ -646,15 +662,11 @@ namespace Xceed.Wpf.DataGrid.Views
       ReorderingInfoManager reorderingInfoManager = this.ReorderingInfoManagerInstance;
       RequiredAnimationsInfo animationState = reorderingInfoManager.RequiredAnimations;
 
-      // Commiting the reordering will set the new VisiblePosition
-      // of the dragged Column. We need to preserve the old values
-      // before commiting to correctly commit the new fixed column 
-      // count
-      this.CommitColumnReordering();
+      // Commiting the reordering will set the new VisiblePosition of the dragged Column.
+      // We need to preserve the old values before commiting to correctly commit the new fixed column count
+      this.CommitColumnReordering( animationState );
 
-      this.CommitSplitterReordering( reorderingInfoManager.InitialColumnVisiblePosition,
-        animationState.DraggedColumnNewVisiblePosition,
-        reorderingInfoManager.InitialFixedColumnCount );
+      this.CommitSplitterReordering( animationState );
     }
 
     private void SetPopupDragAdorner( ColumnManagerCell columnManagerCell )
@@ -671,7 +683,7 @@ namespace Xceed.Wpf.DataGrid.Views
       // Get the Rect for the DataGridControl
       DataGridControl dataGridControl = this.DraggedDataGridContext.DataGridControl;
 
-      Rect dataGridControlRect = new Rect( 0, 0, dataGridControl.ActualWidth, dataGridControl.ActualHeight );
+      Rect dataGridControlRect = new Rect( 0d, 0d, dataGridControl.ActualWidth, dataGridControl.ActualHeight );
 
       Point elementToDataGridControl = columnManagerCell.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, dataGridControl );
 
@@ -684,7 +696,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
       AnimatedDraggedElementAdorner adorner = new AnimatedDraggedElementAdorner( columnManagerCell, this.AdornerLayerInsideDragContainer, true );
 
-      adorner.AdornedElementImage.Opacity = 0;
+      adorner.AdornedElementImage.Opacity = 0d;
 
       this.ApplyContainerClip( adorner );
 
@@ -711,14 +723,11 @@ namespace Xceed.Wpf.DataGrid.Views
 
         if( cell != null )
         {
-          // The Cell could be partially or completely under the fixed region
-          // of the FixedCellPanel, so not "really" HitTestible
+          // The Cell could be partially or completely under the fixed region of the FixedCellPanel, so not "really" HitTestible
           isCellHitTestible = ColumnReorderingDragSourceManager.TryHitTestCell( cell, point, dragContainer );
         }
 
-        if( ( isCellHitTestible )
-            && ( dropTarget != null )
-            && ( dropTarget.CanDropElement( draggedElement ) ) )
+        if( ( isCellHitTestible ) && ( dropTarget != null ) && ( dropTarget.CanDropElement( draggedElement ) ) )
         {
           return dropTarget;
         }
@@ -749,19 +758,11 @@ namespace Xceed.Wpf.DataGrid.Views
 
       Point cellPoint = cell.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, dragContainer );
 
-      Rect cellRect = new Rect( cellPoint.X,
-                                cellPoint.Y,
-                                cell.ActualWidth,
-                                cell.ActualHeight );
+      Rect cellRect = new Rect( cellPoint.X, cellPoint.Y, cell.ActualWidth, cell.ActualHeight );
 
-      Point scrollingCellsDecoratorPoint = scrollingCellsDecorator.TranslatePoint(
-        ColumnReorderingDragSourceManager.EmptyPoint,
-        dragContainer );
+      Point scrollingCellsDecoratorPoint = scrollingCellsDecorator.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, dragContainer );
 
-      Rect scrollingCellsDecoratorRect = new Rect( scrollingCellsDecoratorPoint.X,
-                                                   scrollingCellsDecoratorPoint.Y,
-                                                   scrollingCellsDecorator.ActualWidth,
-                                                   scrollingCellsDecorator.ActualHeight );
+      Rect scrollingCellsDecoratorRect = new Rect( scrollingCellsDecoratorPoint.X, scrollingCellsDecoratorPoint.Y, scrollingCellsDecorator.ActualWidth, scrollingCellsDecorator.ActualHeight );
 
       if( !cellRect.IntersectsWith( scrollingCellsDecoratorRect ) )
       {
@@ -780,16 +781,23 @@ namespace Xceed.Wpf.DataGrid.Views
       if( transform == null )
         return;
 
-      // Force a local value before removing the potential animation clock
-      // of this transform to avoid leaving the current animated value after
-      // animation is removed
-      transform.X = 0;
+      // Force a local value before removing the potential animation clock of this transform to avoid leaving the current animated value after animation is removed
+      transform.X = 0d;
       transform.ApplyAnimationClock( TranslateTransform.XProperty, null );
     }
 
-    // Gets the index of a Column present in the 
-    // DataGridContext.ColumnsByVisiblePosition from its 
-    // index in the DataGridContext.VisibleColumns
+    private static void ClearScaleTransformAnimation( ScaleTransform transform )
+    {
+      if( transform == null )
+        return;
+
+      // Force a local value before removing the potential animation clock of this transform to avoid leaving the current animated value after animation is removed
+      transform.CenterX = 0d;
+      transform.ScaleX = 1d;
+      transform.ApplyAnimationClock( ScaleTransform.ScaleXProperty, null );
+    }
+
+    // Gets the index of a Column present in the DataGridContext.ColumnsByVisiblePosition from its index in the DataGridContext.VisibleColumns
     private static int GetColumnByVisiblePositionIndexFromVisibleColumnIndex( int visibleColumnIndex, List<ColumnBase> columnsByVisiblePosition )
     {
       if( columnsByVisiblePosition == null )
@@ -829,12 +837,11 @@ namespace Xceed.Wpf.DataGrid.Views
       if( draggedElement == null )
         return;
 
-      DataGridContext dataGridContext
-        = DataGridControl.GetDataGridContext( draggedElement );
+      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( draggedElement );
 
       this.DraggedDataGridContext = dataGridContext;
 
-      this.ColumnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
+      this.ColumnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManagerBase;
 
       this.ColumnAnimationDuration = 500;
       this.DraggedElementFadeInDuration = 250;
@@ -856,7 +863,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
       this.ReorderingInfoManagerInstance.RollbackReorderedColumnsAndFixedColumnCount();
 
-      this.RemoveColumnsPreviousAnimations( dataGridContext.VisibleColumns );
+      this.RemoveColumnsPreviousAnimations();
       this.RemoveFixedColumnSplitterPreviousAnimation( dataGridContext );
     }
 
@@ -869,11 +876,7 @@ namespace Xceed.Wpf.DataGrid.Views
       double currentDraggedElementOffset = draggedElement.TranslatePoint( draggedElementToMouse, this.DragContainer ).X;
 
       // Verify if there is an horizontal change according to the lastchange      
-      Rect dragRect = new Rect(
-        m_lastDraggedElementOffset - SystemParameters.MinimumHorizontalDragDistance,
-        0,
-        SystemParameters.MinimumVerticalDragDistance * 2,
-        0 );
+      Rect dragRect = new Rect( m_lastDraggedElementOffset - SystemParameters.MinimumHorizontalDragDistance, 0d, SystemParameters.MinimumVerticalDragDistance * 2, 0d );
 
       if( dragRect.Contains( new Point( currentDraggedElementOffset, 0 ) ) )
         return;
@@ -892,31 +895,46 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void UpdateIsAnimatedColumnReorderingEnabled()
     {
-      bool isAnimatedColumnReorderingEnabled = false;
+      bool isAnimatedColumnReorderingEnabled;
 
-      if( this.DraggedDataGridContext != null )
+      var dataGridContext = this.DraggedDataGridContext;
+      if( dataGridContext != null )
       {
-        TableflowView tableflowView = this.DraggedDataGridContext.DataGridControl.GetView() as TableflowView;
+        var tableflowView = dataGridContext.DataGridControl.GetView() as TableflowView;
 
-        if( ( tableflowView != null ) && ( tableflowView.IsAnimatedColumnReorderingEnabled ) )
-        {
-          isAnimatedColumnReorderingEnabled = true;
-        }
+        // Column reordering is not allowed in a detail when details are flatten.
+        isAnimatedColumnReorderingEnabled = ( tableflowView != null )
+                                         && ( tableflowView.IsAnimatedColumnReorderingEnabled )
+                                         && ( !dataGridContext.IsAFlattenDetail );
       }
-
-      Cell draggedCell = this.DraggedElement as Cell;
-
-      // We must ensure the draggedCell's ParentRow allows the Column Reordering
-      if( draggedCell != null )
+      else
       {
-        // We don't want any ghost to be displayed when Column Reordering
-        // is not allowed by the ParentRow. Setting the IsAnimatedColumnReorderingEnabled
-        // property will prevent this and will display the Cursor.No when dragging.
-        ColumnManagerRow parentRow = draggedCell.ParentRow as ColumnManagerRow;
+        isAnimatedColumnReorderingEnabled = false;
+      }
 
-        if( parentRow != null )
+      // Make sure the dragged cell's parent row allows column reordering.
+      if( isAnimatedColumnReorderingEnabled )
+      {
+        var draggedCell = this.DraggedElement as Cell;
+        if( draggedCell != null )
         {
-          isAnimatedColumnReorderingEnabled &= parentRow.AllowColumnReorder;
+          // We don't want any ghost to be displayed when column reordering is not allowed by the parent row.
+          // Setting the IsAnimatedColumnReorderingEnabled property will prevent this and will display the Cursor.No when dragging.
+          var parentRow = draggedCell.ParentRow as ColumnManagerRow;
+          if( parentRow != null )
+          {
+            isAnimatedColumnReorderingEnabled = parentRow.AllowColumnReorder;
+          }
+
+          // The main column is not allowed to be reorder when details are flatten.
+          if( isAnimatedColumnReorderingEnabled && dataGridContext.AreDetailsFlatten )
+          {
+            ColumnBase parentColumn = draggedCell.ParentColumn;
+            if( parentColumn != null )
+            {
+              isAnimatedColumnReorderingEnabled = parentColumn != null && !parentColumn.IsMainColumn;
+            }
+          }
         }
       }
 
@@ -969,10 +987,8 @@ namespace Xceed.Wpf.DataGrid.Views
       m_ghostToMousePositionAnimationClock = animation.CreateClock( true ) as AnimationClock;
       m_ghostToMousePositionAnimationClock.Completed += this.GhostToMousePosition_Completed;
 
-      foreach( UIElement element in m_elementToDraggedElementAdorner.Keys )
+      foreach( var adorner in this.GetElementAdorners() )
       {
-        DraggedElementAdorner adorner = m_elementToDraggedElementAdorner[ element ];
-
         adorner.ApplyAnimationClock( DraggedElementAdorner.OffsetProperty, m_ghostToMousePositionAnimationClock, HandoffBehavior.SnapshotAndReplace );
       }
 
@@ -986,8 +1002,7 @@ namespace Xceed.Wpf.DataGrid.Views
         this.PauseGhostToMousePositionAnimation();
       }
 
-      // Ghosts are returned to their original position
-      // reordering was successfully cancelled
+      // Ghosts are returned to their original position reordering was successfully cancelled
       m_reorderCancelled = false;
     }
 
@@ -1038,10 +1053,8 @@ namespace Xceed.Wpf.DataGrid.Views
       m_ghostToTargetColumnAnimationClock = animation.CreateClock( true ) as AnimationClock;
       m_ghostToTargetColumnAnimationClock.Completed += this.GhostToTargetAnimation_Completed;
 
-      foreach( UIElement element in m_elementToDraggedElementAdorner.Keys )
+      foreach( var adorner in this.GetElementAdorners() )
       {
-        DraggedElementAdorner adorner = m_elementToDraggedElementAdorner[ element ];
-
         adorner.ApplyAnimationClock( DraggedElementAdorner.OffsetProperty, m_ghostToTargetColumnAnimationClock, HandoffBehavior.SnapshotAndReplace );
       }
     }
@@ -1059,10 +1072,8 @@ namespace Xceed.Wpf.DataGrid.Views
 
       if( ( m_ghostToTargetColumnAnimationClock == null ) && ( m_draggedElementFadeInAnimationClock == null ) )
       {
-        // The ghosts were successfully moved to the target position
-        // so we hide the ghosts and display the Cells in order
-        // for the DraggedElementGhost, which is a VisulalBrush of
-        // the DraggedElement that is transparent during the drag
+        // The ghosts were successfully moved to the target position so we hide the ghosts and display the Cells in order
+        // for the DraggedElementGhost, which is a VisulalBrush of the DraggedElement that is transparent during the drag
         this.HideDraggedColumnGhosts();
         this.ShowDraggedElements();
         m_reorderCancelled = false;
@@ -1090,90 +1101,57 @@ namespace Xceed.Wpf.DataGrid.Views
 
       this.PauseMoveGhostToTargetAndDetachAnimation();
 
-      Cell draggedCell = this.DraggedElement as Cell;
-
+      var draggedCell = this.DraggedElement as Cell;
       if( draggedCell == null )
         return;
 
-      bool animationInitialized = false;
-
-      DraggedElementAdorner draggedAdorner = m_elementToDraggedElementAdorner[ draggedCell ];
+      var parentRow = draggedCell.ParentRow;
+      if( ( parentRow == null ) || ( parentRow.CellsHostPanel == null ) )
+        return;
 
-      Nullable<Point> currentDraggedAdornerPosition = null;
+      var draggedAdorner = m_elementToDraggedElementAdorner[ draggedCell ];
+      var currentDraggedAdornerPosition = ( draggedAdorner != null ) ? draggedAdorner.Offset : default( Point );
+      var fromPoint = currentDraggedAdornerPosition;
 
       if( draggedAdorner != null )
       {
-        currentDraggedAdornerPosition = draggedAdorner.Offset;
-      }
-
-      foreach( UIElement element in m_elementToDraggedElementAdorner.Keys )
-      {
-        Cell cell = element as Cell;
-
-        if( cell == null )
+        // Calculate the animation from the current ColumnManagerCell, since it could be a MergedColumnMangerCell dragging any number of columns.
+        // If calculating the animation from a different cell, the animation could be starting from a wrong position and give a bad visual effect.
+        var animations = this.ReorderingInfoManagerInstance.RequiredAnimations;
+        if( animations.AnimateToLeft.Count > 0 )
         {
-          Debug.Assert( false, "Only Cells should be dragged by this manager" );
-          continue;
-        }
-
-        DraggedElementAdorner adorner = m_elementToDraggedElementAdorner[ element ];
+          var siblingCell = parentRow.Cells[ draggedCell.ParentColumn.PreviousVisibleColumn ];
+          var targetPosition = siblingCell.PointToScreen( new Point( siblingCell.ActualWidth, 0d ) );
+          var relativePosition = draggedAdorner.PointFromScreen( targetPosition );
 
-        if( !animationInitialized )
+          fromPoint = new Point( -relativePosition.X, -relativePosition.Y );
+        }
+        else if( animations.AnimateToRight.Count > 0 )
         {
-          TableViewColumnVirtualizationManager columnVirtualizationManager = this.DraggedDataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-          if( columnVirtualizationManager == null )
-            return;
+          var siblingCell = parentRow.Cells[ draggedCell.ParentColumn.NextVisibleColumn ];
+          var targetPosition = siblingCell.PointToScreen( new Point( -draggedCell.ActualWidth, 0d ) );
+          var relativePosition = draggedAdorner.PointFromScreen( targetPosition );
 
-          double offset = columnVirtualizationManager.FieldNameToOffset[ draggedCell.FieldName ];
-
-          if( ( draggedCell.ParentRow == null ) || ( draggedCell.ParentRow.CellsHostPanel == null ) )
-            return;
-
-          // Get the position of the Mouse according to the DragContainer
-          Point mouseToDragContainer = Mouse.GetPosition( this.DragContainer );
-
-          // Get the position of the Mouse according to the DraggedElementAdorner
-          Point adornerToMouse = Mouse.GetPosition( adorner );
-
-          // Get the position of the Cell according to the ParentRow.CellsHostPanel for the dragged Cell
-          Panel cellsHost = cell.ParentRow.CellsHostPanel;
-          Point newCellInCellsHostToDragContainer = cellsHost.TranslatePoint( new Point( offset, 0 ), this.DragContainer );
-
-          // Get the position of the Cell according to its CellsHost in order to know
-          // if it was dragged from the Fixed to the Scrolling Cells.
-          Point cellToCellsHost = cell.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, cell.ParentRow.CellsHostPanel );
-
-          double initialX = mouseToDragContainer.X - newCellInCellsHostToDragContainer.X - adornerToMouse.X;
-
-          // The DraggedCell is a FixedCell and it offset is greater than  the FixedColumnWidth
-          if( columnVirtualizationManager.FixedFieldNames.Contains( cell.FieldName ) && ( cellToCellsHost.X > columnVirtualizationManager.FixedColumnsWidth ) )
-          {
-            // In this case, we must take the HorizontalOffset into consideration
-            initialX -= this.DraggedDataGridContext.DataGridControl.ScrollViewer.HorizontalOffset;
-          }
-          else
-          {
-            // The offset of the Cell according the CellsHost is less than 0 and
-            // there is a Compensation offset to ensure all the ScrollingCells are
-            // in view even if the HorizontalOffset would have scrolled them
-            // outside the ViewPort
-            if( ( ( newCellInCellsHostToDragContainer.X - columnVirtualizationManager.FixedColumnsWidth ) < 0 ) && ( columnVirtualizationManager.FirstColumnCompensationOffset > 0 ) )
-            {
-              initialX -= columnVirtualizationManager.FirstColumnCompensationOffset;
-            }
-          }
-
-          Point fromPoint = new Point( initialX, currentDraggedAdornerPosition.GetValueOrDefault().Y );
+          fromPoint = new Point( -relativePosition.X, -relativePosition.Y );
+        }
+      }
 
-          PointAnimation animation = new PointAnimation( fromPoint, ColumnReorderingDragSourceManager.EmptyPoint, m_columnAnimationDuration );
+      PointAnimation animation = new PointAnimation( fromPoint, ColumnReorderingDragSourceManager.EmptyPoint, m_columnAnimationDuration );
 
-          m_ghostToTargetAndDetachAnimationClock = animation.CreateClock( true ) as AnimationClock;
-          m_ghostToTargetAndDetachAnimationClock.Completed += this.MoveGhostToTargetAndDetach_Completed;
+      m_ghostToTargetAndDetachAnimationClock = animation.CreateClock( true ) as AnimationClock;
+      m_ghostToTargetAndDetachAnimationClock.Completed += this.MoveGhostToTargetAndDetach_Completed;
 
-          animationInitialized = true;
+      //Animate all cells of all columns.
+      foreach( var entry in this.GetElementAdornerEntries() )
+      {
+        var cell = entry.Key as Cell;
+        if( cell == null )
+        {
+          Debug.Assert( false, "Only Cells should be dragged by this manager" );
+          continue;
         }
 
+        var adorner = entry.Value;
         adorner.ApplyAnimationClock( DraggedElementAdorner.OffsetProperty, m_ghostToTargetAndDetachAnimationClock, HandoffBehavior.SnapshotAndReplace );
       }
 
@@ -1202,48 +1180,36 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       this.ShowDraggedElements();
 
-      Cell draggedCell = this.DraggedElement as Cell;
-
-      if( draggedCell != null )
+      var draggedCell = this.DraggedElement as Cell;
+      if( ( draggedCell != null ) && this.OwnElement( draggedCell ) )
       {
-        TableflowView.SetIsBeingDraggedAnimated( draggedCell.ParentColumn, false );
+        draggedCell.ParentColumn.SetIsBeingDraggedAnimated( false );
       }
 
-      // Get the manager currently in use on the DataGridContext
-      ColumnReorderingDragSourceManager currentManager = TableflowView.GetColumnReorderingDragSourceManager( this.DraggedDataGridContext );
-
-      // Clear properties on the manager if it is the one currently in
-      // use on for this Detail level. This avoids problem with the FixedColumnSplitter
+      // Clear properties on the manager if it is the one currently in use on for this Detail level. This avoids problem with the FixedColumnSplitter
       // when multiple Cells are moved rapidly:
-      // The FixedColumnSplitter listens to TableflowView.AreColumnsBeingReordered internal 
-      // ViewProperty to bind to the TableflowView.FixedColumnSplitterTranslation internal 
-      // ViewProperty. The internal ViewProeprty ColumnReorderingDragSourceManager is
-      // affected when a new Drag begins. The old DragSourceManager is not stopped to allow 
-      // any pending animations to complete smoothly. If the first manager clears the
-      // TableflowView.AreColumnBeingReordered property, the FixedColumnSplitters
+      // The FixedColumnSplitter listens to TableflowView.AreColumnsBeingReordered internal ViewProperty to bind to the TableflowView.FixedColumnSplitterTranslation internal 
+      // ViewProperty. The internal ViewProeprty ColumnReorderingDragSourceManager is affected when a new Drag begins. The old DragSourceManager is not stopped to allow 
+      // any pending animations to complete smoothly. If the first manager clears the TableflowView.AreColumnBeingReordered property, the FixedColumnSplitters
       // just clears its binding to the FixedColumnSplitterTranslation and is no more animated.
       //
-      // Ensuring that the current manager for this Detail level ensure that no other
-      // drag was initialized since this manager started animations.
+      // Ensuring that the current manager for this Detail level ensure that no other drag was initialized since this manager started animations.
 
-      if( currentManager == this )
+      if( this.OwnElement( this.DraggedDataGridContext ) )
       {
         TableflowView.SetAreColumnsBeingReordered( this.DraggedDataGridContext, false );
 
-        if( draggedCell != null )
+        if( ( draggedCell != null ) && this.OwnElement( draggedCell ) )
         {
-          TableflowView.ClearColumnReorderingDragSourceManager( draggedCell.ParentColumn );
+          draggedCell.ParentColumn.ClearColumnReorderingDragSourceManager();
         }
 
         TableflowView.ClearColumnReorderingDragSourceManager( this.DraggedDataGridContext );
       }
     }
 
-    private void CommitColumnReordering()
+    private void CommitColumnReordering( RequiredAnimationsInfo animationState )
     {
-      ReorderingInfoManager reorderingInfoManager = this.ReorderingInfoManagerInstance;
-      RequiredAnimationsInfo animationState = reorderingInfoManager.RequiredAnimations;
-
       int newVisiblePosition = ( animationState != null ) ? animationState.DraggedColumnNewVisiblePosition : -1;
 
       // Affect the new VisiblePosition to the DraggedColumn to allow the Grid to reflect the change
@@ -1256,51 +1222,22 @@ namespace Xceed.Wpf.DataGrid.Views
         {
           ColumnBase draggedColumn = draggedCell.ParentColumn;
 
-          // Affect the new VisiblePosition of the DraggedColumn
+          // Affect the new VisiblePosition of the DraggedColumn - this will automatically update all child columns when dealing with merged columns
           draggedColumn.VisiblePosition = newVisiblePosition;
         }
       }
 
-      DataGridContext dataGridContext = this.DraggedDataGridContext;
-      ReadOnlyObservableCollection<ColumnBase> visibleColumns = dataGridContext.VisibleColumns;
-
-      for( int i = 0; i < visibleColumns.Count; i++ )
-      {
-        ColumnBase column = visibleColumns[ i ];
-
-        TranslateTransform transform = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingTranslation( column );
-
-        AnimationClock animationClock = null;
-
-        // Get the AnimationClock for this Column
-        if( m_fieldNameToClock.TryGetValue( column.FieldName, out animationClock ) )
-        {
-          m_fieldNameToClock.Remove( column.FieldName );
-          m_clockToFieldName.Remove( animationClock );
-        }
-
-        if( animationClock != null )
-        {
-          animationClock.Controller.Remove();
-        }
-
-        if( transform != null )
-        {
-          transform.X = 0;
-        }
-      }
+      this.CleanUpColumnAnimations();
     }
 
-    private void CommitSplitterReordering( int oldVisiblePosition, int newVisiblePosition, int oldFixedColumnCount )
+    private void CommitSplitterReordering( RequiredAnimationsInfo animationState )
     {
       if( m_splitterAnimationClock == null )
         return;
 
       double fixedColumnTranslation = this.FixedColumnSplitterTranslation.X;
 
-      // Try to get the TargetOffset of the FixedColumnSplitter
-      // AnimationClock if available to ensure to commit the
-      // correct fixed column count
+      // Try to get the TargetOffset of the FixedColumnSplitter AnimationClock if available to ensure to commit the correct fixed column count
       if( m_splitterAnimationClock != null )
       {
         OffsetAnimation animation = m_splitterAnimationClock.Timeline as OffsetAnimation;
@@ -1316,23 +1253,22 @@ namespace Xceed.Wpf.DataGrid.Views
 
       if( fixedColumnTranslation != 0 )
       {
-        ReorderingInfoManager reorderingInfoManager = this.ReorderingInfoManagerInstance;
-        int fixedColumnCount = reorderingInfoManager.RequiredAnimations.NewFixedColumnCount;
+        int fixedColumnCount = animationState.NewFixedColumnCount;
+        int correctionValue = animationState.CorrectionValue;
 
-        // Update the FixedColumnCount on the DataGridContext in order to 
-        // correctly represent the value modified during animated reordering
+        // Update the FixedColumnCount on the DataGridContext in order to correctly represent the value modified during animated reordering
         DataGridContext dataGridContext = this.DraggedDataGridContext;
 
-        if( ( dataGridContext != null ) && ( dataGridContext.ParentDataGridContext != null ) )
+        if( dataGridContext.ParentDataGridContext != null )
         {
           foreach( DataGridContext childDataGridContext in dataGridContext.ParentDataGridContext.GetChildContexts() )
           {
-            TableView.SetFixedColumnCount( childDataGridContext, fixedColumnCount );
+            this.ColumnVirtualizationManager.SetFixedColumnCount( m_level, fixedColumnCount, correctionValue );
           }
         }
         else
         {
-          TableView.SetFixedColumnCount( dataGridContext, fixedColumnCount );
+          this.ColumnVirtualizationManager.SetFixedColumnCount( m_level, fixedColumnCount, correctionValue );
         }
       }
 
@@ -1349,83 +1285,66 @@ namespace Xceed.Wpf.DataGrid.Views
       ColumnManagerCell draggedCell = this.DraggedElement as ColumnManagerCell;
       Debug.Assert( draggedCell != null );
 
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( draggedOverCell );
-      Debug.Assert( dataGridContext != null );
-
-      Point draggedOverCellToDragContainer = draggedOverCell.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, this.DragContainer );
-
-      Rect hitTestRect = new Rect( draggedOverCellToDragContainer.X,
-        draggedOverCellToDragContainer.Y,
-        draggedOverCell.RenderSize.Width / 2,
-        draggedOverCell.RenderSize.Height );
-
       int initialVisiblePosition = draggedCell.ParentColumn.VisiblePosition;
-      int initialFixedColumnCount = this.ColumnVirtualizationManager.FixedColumnCount;
-      int newFixedColumnCount = initialFixedColumnCount;
-      int newTargetVisiblePosition = -1;
-
-      DraggedOverCellRegion draggedOverCellRegion = DraggedOverCellRegion.Unknown;
-
       int draggedOverCellVisiblePosition = draggedOverCell.ParentColumn.VisiblePosition;
+      int newTargetVisiblePosition = -1;
+      int newFixedColumnCount;
+      int correctionValue;
 
-      Dictionary<string, double> fieldNameToOffset = this.ColumnVirtualizationManager.FieldNameToOffset;
+      Point draggedOverCellToDragContainer = draggedOverCell.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, this.DragContainer );
+      Rect hitTestRect = new Rect( draggedOverCellToDragContainer.X, draggedOverCellToDragContainer.Y, draggedOverCell.RenderSize.Width / 2, draggedOverCell.RenderSize.Height );
 
       if( mousePosition.HasValue && ( mousePosition.Value.X < ( hitTestRect.X + hitTestRect.Width ) ) )
       {
-        draggedOverCellRegion = DraggedOverCellRegion.Left;
-
         newTargetVisiblePosition = ( initialVisiblePosition >= draggedOverCellVisiblePosition ) ? draggedOverCellVisiblePosition : draggedOverCellVisiblePosition - 1;
       }
       else
       {
-        draggedOverCellRegion = DraggedOverCellRegion.Right;
-
         newTargetVisiblePosition = ( initialVisiblePosition <= draggedOverCellVisiblePosition ) ? draggedOverCellVisiblePosition : draggedOverCellVisiblePosition + 1;
       }
 
-      ReadOnlyObservableCollection<ColumnBase> visibleColumn = this.DraggedDataGridContext.VisibleColumns;
+      this.CalculateAnimatedFixedColumnCount( initialVisiblePosition, newTargetVisiblePosition, out newFixedColumnCount, out correctionValue );
+
+      // Update the VisiblePositions, DraggedOverCellRegion and FixedColumnCount of the ReorderingInfoManager
+      ReorderingInfoManager reorderingInfoManager = this.ReorderingInfoManagerInstance;
+
+      reorderingInfoManager.InitializeInfoManager( newFixedColumnCount, correctionValue );
+      reorderingInfoManager.UpdateDraggedColumnVisiblePosition( newTargetVisiblePosition );
+      reorderingInfoManager.UpdateReorderingInfo( this.ColumnVirtualizationManager );
+    }
 
-      int lastFixedColumnVisiblePosition = visibleColumn[ Math.Max( 0, Math.Min( initialFixedColumnCount, visibleColumn.Count ) - 1 ) ].VisiblePosition;
+    private void CalculateAnimatedFixedColumnCount( int initialVisiblePosition, int newTargetVisiblePosition, out int newFixedColumnCount, out int correctionValue )
+    {
+      ReadOnlyObservableCollection<ColumnBase> visibleColumns = this.VisibleColumns;
 
-      int firstScrollingColumnVisiblePosition = visibleColumn[ Math.Min( initialFixedColumnCount, visibleColumn.Count - 1 ) ].VisiblePosition;
+      int initialFixedColumnCount = this.ColumnVirtualizationManager.GetFixedColumnCount( m_level );
+      int lastFixedColumnVisiblePosition = visibleColumns[ Math.Max( 0, Math.Min( initialFixedColumnCount, visibleColumns.Count ) - 1 ) ].VisiblePosition;
+      int firstScrollingColumnVisiblePosition = visibleColumns[ Math.Min( initialFixedColumnCount, visibleColumns.Count - 1 ) ].VisiblePosition;
+      newFixedColumnCount = initialFixedColumnCount;
+      correctionValue = initialFixedColumnCount == visibleColumns.Count ? 1 : 0;
 
       // Ensure we have fixed and/or scrolling columns
       if( lastFixedColumnVisiblePosition != firstScrollingColumnVisiblePosition )
       {
-        // Initially at the left of the splitter
-        if( initialVisiblePosition <= lastFixedColumnVisiblePosition )
+        // Initially at the left of the splitter and moving after the first column after the splitter
+        if( ( initialVisiblePosition <= lastFixedColumnVisiblePosition ) && ( newTargetVisiblePosition > lastFixedColumnVisiblePosition ) )
         {
-          // Moving at the right of the splitter or over the left edged of the first visible scrolling Column
-          bool movingAtRightOfSplitter = ( newTargetVisiblePosition >= lastFixedColumnVisiblePosition ) && ( newTargetVisiblePosition >= firstScrollingColumnVisiblePosition );
-
-          bool movingOverFirstVisibleColumnLeftEdge = ( newTargetVisiblePosition == lastFixedColumnVisiblePosition ) && ( draggedOverCellRegion == DraggedOverCellRegion.Left );
-
-          if( movingAtRightOfSplitter || movingOverFirstVisibleColumnLeftEdge )
+          newFixedColumnCount--;
+          if( newFixedColumnCount > 0 )
           {
-            newFixedColumnCount--;
+            correctionValue = 1;
           }
         }
-        // Initially at the right of the splitter
-        else if( initialVisiblePosition >= firstScrollingColumnVisiblePosition )
+        // Initially at the right of the splitter and moving before the first column before the splitter
+        else if( ( initialVisiblePosition >= firstScrollingColumnVisiblePosition ) && ( newTargetVisiblePosition < firstScrollingColumnVisiblePosition ) )
         {
-          // Moving at the left of the splitter or over right edge of the last fixed Column
-          bool movingAtLeftOfSpliter = ( newTargetVisiblePosition < firstScrollingColumnVisiblePosition );
-
-          bool movingOverLastFixedColumnRightEdged = ( newTargetVisiblePosition == lastFixedColumnVisiblePosition ) && ( draggedOverCellRegion == DraggedOverCellRegion.Right );
-
-          if( movingAtLeftOfSpliter || movingOverLastFixedColumnRightEdged )
+          newFixedColumnCount++;
+          if( newFixedColumnCount == visibleColumns.Count )
           {
-            newFixedColumnCount++;
+            correctionValue = 1;
           }
         }
       }
-
-      // Update the VisiblePositions, DraggedOverCellRegion and FixedColumnCount of the ReorderingInfoManager
-      ReorderingInfoManager reorderingInfoManager = this.ReorderingInfoManagerInstance;
-
-      reorderingInfoManager.InitalizeInfoManager( newFixedColumnCount );
-      reorderingInfoManager.UpdateDraggedColumnVisiblePosition( newTargetVisiblePosition );
-      reorderingInfoManager.UpdateReorderingInfo( this.ColumnVirtualizationManager );
     }
 
     private void ProcessDragOverColumnManagerCell()
@@ -1465,14 +1384,20 @@ namespace Xceed.Wpf.DataGrid.Views
 
       double draggedColumnWidth = draggedCell.ParentColumn.ActualWidth;
 
-      foreach( ColumnBase column in animationState.AnimateToLeft )
+      if( animationState.AnimateToLeft.Count > 0 )
       {
-        this.DoColumnAnimation( column, -draggedColumnWidth, m_columnAnimationDuration, false );
+        foreach( ColumnBase column in animationState.AnimateToLeft )
+        {
+          this.DoColumnAnimation( column, -draggedColumnWidth, m_columnAnimationDuration, false );
+        }
       }
 
-      foreach( ColumnBase column in animationState.AnimateToRight )
+      if( animationState.AnimateToRight.Count > 0 )
       {
-        this.DoColumnAnimation( column, draggedColumnWidth, m_columnAnimationDuration, false );
+        foreach( ColumnBase column in animationState.AnimateToRight )
+        {
+          this.DoColumnAnimation( column, draggedColumnWidth, m_columnAnimationDuration, false );
+        }
       }
 
       foreach( ColumnBase column in animationState.RollbackAnimation )
@@ -1483,20 +1408,22 @@ namespace Xceed.Wpf.DataGrid.Views
       this.SetSplitterAnimation( reorderingInfoManager.InitialFixedColumnCount, animationState.NewFixedColumnCount, draggedColumnWidth );
     }
 
-    private AnimationClock AnimateColumn( ColumnBase column, double offset, Duration animationDuration )
-    {
-      return this.DoColumnAnimation( column, offset, animationDuration, false );
-    }
-
     private void RollbackReordering()
     {
-      this.ReorderingInfoManagerInstance.RollbackReorderedColumnsAndFixedColumnCount();
+      RequiredAnimationsInfo animationState = this.ReorderingInfoManagerInstance.RequiredAnimations;
+
+      foreach( ColumnBase column in animationState.AnimateToLeft )
+      {
+        this.RollbackColumnAnimation( column );
+      }
 
-      foreach( ColumnBase column in this.DraggedDataGridContext.VisibleColumns )
+      foreach( ColumnBase column in animationState.AnimateToRight )
       {
         this.RollbackColumnAnimation( column );
       }
 
+      this.ReorderingInfoManagerInstance.RollbackReorderedColumnsAndFixedColumnCount();
+
       this.DoSplitterAnimation( 0, true );
 
       m_reorderCancelled = true;
@@ -1507,64 +1434,50 @@ namespace Xceed.Wpf.DataGrid.Views
       this.DoColumnAnimation( column, 0, m_columnAnimationDuration, true );
     }
 
-    private AnimationClock DoColumnAnimation( ColumnBase column, double toValue, Duration duration, bool isReverting )
+    private void DoColumnAnimation( ColumnBase column, double toValue, Duration duration, bool isReverting )
     {
       if( column == null )
-        return null;
+        return;
 
+      // Never animate the dragged Column to avoid flickering effects on the ghosts because we compute its position on each MouseMove event
       Cell draggedCell = this.DraggedElement as Cell;
-
-      // Never animate the dragged Column to avoid flickering
-      // effects on the ghosts because we compute its position
-      // on each MouseMove event
       if( ( draggedCell != null ) && ( column == draggedCell.ParentColumn ) )
-        return null;
-
-      TranslateTransform transform = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingTranslation( column );
-
-      if( transform == null )
-      {
-        transform = new TranslateTransform();
-        ColumnReorderingDragSourceManager.SetAnimatedColumnReorderingTranslation( column, transform );
-      }
-
-      string fieldName = column.FieldName;
+        return;
 
-      AnimationClock animationClock = null;
+      TranslateTransform positionTransform = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingPositionTransform( column );
+      List<AnimationClock> animationClocks;
+      AnimationClock positionAnimationClock = null;
 
       // Pause previously applied AnimationClock
-      if( m_fieldNameToClock.TryGetValue( fieldName, out animationClock ) )
+      if( m_fieldNameToClock.TryGetValue( column, out animationClocks ) )
       {
-        OffsetAnimation clockOffsetAnimation = animationClock.Timeline as OffsetAnimation;
-
         // If the target value is already the correct one, no need to stop animation and create another one
-        if( ( clockOffsetAnimation != null ) && ( clockOffsetAnimation.To == toValue ) )
-          return animationClock;
+        positionAnimationClock = animationClocks[ 0 ];
+        OffsetAnimation positionTimeLine = positionAnimationClock.Timeline as OffsetAnimation;
+        if( ( positionTimeLine != null ) && ( positionTimeLine.To == toValue ) )
+          return;
 
         // Stop the animation, do not simply pause it, so it resets correctly.
-        animationClock.Controller.Stop();
-        animationClock.Completed -= this.ColumnAnimationCompleted;
+        positionAnimationClock.Controller.Stop();
+        positionAnimationClock.Completed -= this.ColumnAnimationCompleted;
 
-        m_fieldNameToClock.Remove( fieldName );
-        m_clockToFieldName.Remove( animationClock );
+        m_fieldNameToClock.Remove( column );
       }
 
-      OffsetAnimation animation = new OffsetAnimation( toValue, duration );
-      animationClock = animation.CreateClock( true ) as AnimationClock;
-
-      transform.ApplyAnimationClock( TranslateTransform.XProperty, animationClock, HandoffBehavior.SnapshotAndReplace );
+      OffsetAnimation positionAnimation = new OffsetAnimation( toValue, duration );
+      positionAnimationClock = positionAnimation.CreateClock( true ) as AnimationClock;
+      positionTransform.ApplyAnimationClock( TranslateTransform.XProperty, positionAnimationClock, HandoffBehavior.SnapshotAndReplace );
 
-      m_fieldNameToClock.Add( fieldName, animationClock );
-      m_clockToFieldName.Add( animationClock, fieldName );
+      //Since we are dealing with regular Columns (i.e. not MergedColumns), no need for resize animation, so we can simply store a null value for the resize AnimationClock.
+      m_fieldNameToClock.Add( column, new List<AnimationClock>() { positionAnimationClock, null } );
 
       if( isReverting )
       {
-        animationClock.Completed += this.ColumnAnimationCompleted;
+        positionAnimationClock.Completed += this.ColumnAnimationCompleted;
       }
 
-      animationClock.Controller.Begin();
-
-      return animationClock;
+      //Start the animation
+      positionAnimationClock.Controller.Begin();
     }
 
     private void ColumnAnimationCompleted( object sender, EventArgs e )
@@ -1580,32 +1493,41 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void CleanUpColumnAnimations()
     {
-      foreach( KeyValuePair<string, AnimationClock> fieldNameToClock in m_fieldNameToClock )
+      foreach( KeyValuePair<ColumnBase, List<AnimationClock>> animationClocks in m_fieldNameToClock )
       {
-        // Using Columns instead of Visible Columns for performance reasons
-        ColumnBase column = this.DraggedDataGridContext.Columns[ fieldNameToClock.Key ];
+        foreach( AnimationClock animationClock in animationClocks.Value )
+        {
+          if( animationClock != null )
+          {
+            animationClock.Controller.Remove();
+          }
+        }
 
-        Debug.Assert( column != null );
+        ColumnBase column = animationClocks.Key;
+        TransformGroup transformGroup = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingTransformGroup( column );
 
-        //Remove the animation translate form the column.
-        TranslateTransform transform = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingTranslation( column );
-        Debug.Assert( transform != null );
-        transform.X = 0;
+        TranslateTransform positionTransform = transformGroup.Children[ 0 ] as TranslateTransform;
+        if( positionTransform != null )
+        {
+          positionTransform.X = 0;
+        }
 
-        //Clear the animation
-        fieldNameToClock.Value.Controller.Remove();
+        ScaleTransform sizeTransform = transformGroup.Children[ 1 ] as ScaleTransform;
+        if( sizeTransform != null )
+        {
+          sizeTransform.CenterX = 0;
+          sizeTransform.ScaleX = 1;
+        }
       }
 
       m_fieldNameToClock.Clear();
-      m_clockToFieldName.Clear();
     }
 
-    private void RemoveColumnsPreviousAnimations( ReadOnlyObservableCollection<ColumnBase> readOnlyObservableCollection )
+    private void RemoveColumnsPreviousAnimations()
     {
-      foreach( ColumnBase column in readOnlyObservableCollection )
+      foreach( ColumnBase column in this.VisibleColumns )
       {
-        TranslateTransform transform = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingTranslation( column );
-
+        TranslateTransform transform = ColumnReorderingDragSourceManager.GetAnimatedColumnReorderingPositionTransform( column );
         ColumnReorderingDragSourceManager.ClearTranslateTransformAnimation( transform );
       }
     }
@@ -1677,11 +1599,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void RemoveFixedColumnSplitterPreviousAnimation( DataGridContext dataGridContext )
     {
-      if( dataGridContext == null )
-        return;
-
       TranslateTransform transform = TableflowView.GetFixedColumnSplitterTranslation( dataGridContext ) as TranslateTransform;
-
       ColumnReorderingDragSourceManager.ClearTranslateTransformAnimation( transform );
     }
 
@@ -1690,8 +1608,7 @@ namespace Xceed.Wpf.DataGrid.Views
       if( adorner == null )
         return;
 
-      UIElement adornedElement = adorner.AdornedElement;
-
+      var adornedElement = adorner.AdornedElement;
       if( adornedElement == null )
         return;
 
@@ -1699,18 +1616,19 @@ namespace Xceed.Wpf.DataGrid.Views
       if( adornedElement == this.DraggedElement )
         return;
 
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( adornedElement );
-
+      var dataGridContext = DataGridControl.GetDataGridContext( adornedElement );
       if( dataGridContext == null )
         return;
 
-      object dataItem = adornedElement.GetValue( CustomItemContainerGenerator.DataItemPropertyProperty );
+      var dataItemStore = CustomItemContainerGenerator.GetDataItemProperty( adornedElement );
+      if( ( dataItemStore == null ) || dataItemStore.IsEmpty )
+        return;
 
+      var dataItem = dataItemStore.Data;
       if( dataItem == null )
         return;
 
-      UIElement container = dataGridContext.GetContainerFromItem( dataItem ) as UIElement;
-
+      var container = dataGridContext.GetContainerFromItem( dataItem ) as UIElement;
       if( container != null )
       {
         RectangleGeometry containerClip = container.Clip as RectangleGeometry;
@@ -1727,19 +1645,15 @@ namespace Xceed.Wpf.DataGrid.Views
       }
       else
       {
-        // Clip adorner completely
-        adorner.AdornedElementImage.Clip = new RectangleGeometry( Rect.Empty );
+        //This is an item that is in the FixedHeaders/Footers of the gird, do not clip it.
+        adorner.AdornedElementImage.Clip = null;
       }
     }
 
     private TableflowViewItemsHost GetTableFlowViewItemsHost()
     {
-      if( ( this.DraggedDataGridContext != null )
-        && ( this.DraggedDataGridContext.DataGridControl != null )
-        && ( this.DraggedDataGridContext.DataGridControl.ItemsHost != null ) )
-      {
+      if( ( this.DraggedDataGridContext != null ) && ( this.DraggedDataGridContext.DataGridControl != null ) && ( this.DraggedDataGridContext.DataGridControl.ItemsHost != null ) )
         return this.DraggedDataGridContext.DataGridControl.ItemsHost as TableflowViewItemsHost;
-      }
 
       return null;
     }
@@ -1753,14 +1667,10 @@ namespace Xceed.Wpf.DataGrid.Views
         double stickyHeadersHeight = itemsHost.GetStickyHeadersRegionHeight();
         double stickyFootersHeight = itemsHost.GetStickyHeadersRegionHeight();
 
-        Point itemsHostToDragContainer =
-          itemsHost.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, this.DragContainer );
+        Point itemsHostToDragContainer = itemsHost.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, this.DragContainer );
 
-        tableflowItemsHostToDragContainerRect = new Rect(
-          itemsHostToDragContainer.X,
-          itemsHostToDragContainer.Y + stickyHeadersHeight,
-          itemsHost.RenderSize.Width,
-          Math.Max( 0, itemsHost.RenderSize.Height - stickyHeadersHeight - stickyFootersHeight ) );
+        tableflowItemsHostToDragContainerRect = new Rect( itemsHostToDragContainer.X, itemsHostToDragContainer.Y + stickyHeadersHeight, itemsHost.RenderSize.Width,
+                                                          Math.Max( 0d, itemsHost.RenderSize.Height - stickyHeadersHeight - stickyFootersHeight ) );
       }
 
       return tableflowItemsHostToDragContainerRect;
@@ -1768,31 +1678,25 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private Dictionary<DataGridContext, Rect> GetColumnManagerCellGhostRects()
     {
-      Dictionary<DataGridContext, Rect> dataGridContextToColumnManagerCellRects =
-        new Dictionary<DataGridContext, Rect>();
+      Dictionary<DataGridContext, Rect> dataGridContextToColumnManagerCellRects = new Dictionary<DataGridContext, Rect>();
 
-      foreach( Cell cell in m_elementToDraggedElementAdorner.Keys )
+      foreach( var element in this.GetElements() )
       {
-        ColumnManagerCell columnManagerCell = cell as ColumnManagerCell;
+        var columnManagerCell = element as ColumnManagerCell;
+        if( columnManagerCell == null )
+          continue;
 
-        if( columnManagerCell != null )
-        {
-          Point columnManagerCellToDragContainer =
-            columnManagerCell.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, this.DragContainer );
+        Point columnManagerCellToDragContainer = columnManagerCell.TranslatePoint( ColumnReorderingDragSourceManager.EmptyPoint, this.DragContainer );
 
-          Rect columnManagerCellRect = new Rect(
-            columnManagerCellToDragContainer.X,
-            columnManagerCellToDragContainer.Y,
-            columnManagerCell.RenderSize.Width,
-            columnManagerCell.RenderSize.Height );
+        Rect columnManagerCellRect = new Rect( columnManagerCellToDragContainer.X, columnManagerCellToDragContainer.Y, columnManagerCell.RenderSize.Width,
+                                               columnManagerCell.RenderSize.Height );
 
-          DataGridContext columnManagerCellDataGridContext = DataGridControl.GetDataGridContext( columnManagerCell );
+        DataGridContext columnManagerCellDataGridContext = DataGridControl.GetDataGridContext( columnManagerCell );
 
-          // We will only consider the first ColumnManagerRow added to this DataGridContext
-          if( !dataGridContextToColumnManagerCellRects.ContainsKey( columnManagerCellDataGridContext ) )
-          {
-            dataGridContextToColumnManagerCellRects.Add( columnManagerCellDataGridContext, columnManagerCellRect );
-          }
+        // We will only consider the first ColumnManagerRow added to this DataGridContext
+        if( !dataGridContextToColumnManagerCellRects.ContainsKey( columnManagerCellDataGridContext ) )
+        {
+          dataGridContextToColumnManagerCellRects.Add( columnManagerCellDataGridContext, columnManagerCellRect );
         }
       }
 
@@ -1801,16 +1705,14 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void RemoveAllGhosts()
     {
-      DraggedElementAdorner adorner = null;
-
       this.PauseDraggedElementFadeInAnimation();
 
-      foreach( UIElement element in m_elementToDraggedElementAdorner.Keys )
+      foreach( var entry in this.GetElementAdornerEntries() )
       {
-        adorner = m_elementToDraggedElementAdorner[ element ];
-        Debug.Assert( adorner != null );
-        this.AdornerLayerInsideDragContainer.Remove( adorner );
-        element.Opacity = 1;
+        Debug.Assert( entry.Value != null );
+        this.AdornerLayerInsideDragContainer.Remove( entry.Value );
+
+        entry.Key.Opacity = 1d;
       }
 
       m_elementToDraggedElementAdorner.Clear();
@@ -1824,18 +1726,18 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void ShowDraggedColumnGhosts()
     {
-      foreach( DraggedElementAdorner adorner in m_elementToDraggedElementAdorner.Values )
+      foreach( var adorner in this.GetElementAdorners() )
       {
         this.ApplyContainerClip( adorner );
-        adorner.AdornedElementImage.Opacity = 1;
+        adorner.AdornedElementImage.Opacity = 1d;
       }
     }
 
     private void HideDraggedColumnGhosts()
     {
-      foreach( DraggedElementAdorner adorner in m_elementToDraggedElementAdorner.Values )
+      foreach( var adorner in this.GetElementAdorners() )
       {
-        adorner.AdornedElementImage.Opacity = 0;
+        adorner.AdornedElementImage.Opacity = 0d;
       }
     }
 
@@ -1843,9 +1745,9 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       this.PauseDraggedElementFadeInAnimation();
 
-      foreach( UIElement element in m_elementToDraggedElementAdorner.Keys )
+      foreach( var element in this.GetElements() )
       {
-        element.Opacity = 1;
+        element.Opacity = 1d;
       }
     }
 
@@ -1853,9 +1755,9 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       this.PauseDraggedElementFadeInAnimation();
 
-      foreach( UIElement element in m_elementToDraggedElementAdorner.Keys )
+      foreach( var element in this.GetElements() )
       {
-        element.Opacity = 0;
+        element.Opacity = 0d;
       }
     }
 
@@ -1863,12 +1765,11 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       int remainingOpacityDuration = this.DraggedElementFadeInDuration;
 
-
       if( m_draggedElementFadeInAnimationClock != null )
       {
         OffsetAnimation fadeInAnimation = m_draggedElementFadeInAnimationClock.Timeline as OffsetAnimation;
 
-        if( ( fadeInAnimation != null ) && ( fadeInAnimation.To == 1 ) )
+        if( ( fadeInAnimation != null ) && ( fadeInAnimation.To == 1d ) )
         {
           return;
         }
@@ -1886,17 +1787,15 @@ namespace Xceed.Wpf.DataGrid.Views
 
       UIElement draggedElement = this.DraggedElement;
 
-      // Apply an animation on the opacity of the Cell to ensure a nice transition between
-      // the ColumnReordering and another IDropTarget that is not handled by this manager
+      // Apply an animation on the opacity of the Cell to ensure a nice transition between the ColumnReordering and another IDropTarget that is not handled by this manager
       if( draggedElement != null )
       {
         OffsetAnimation opacityAnimation = new OffsetAnimation( 1, new Duration( TimeSpan.FromMilliseconds( remainingOpacityDuration ) ) );
 
         m_draggedElementFadeInAnimationClock = opacityAnimation.CreateClock( true ) as AnimationClock;
 
-        // We ust the same completed callback as MoveGhostToTarget animation to 
-        // be sure that the DraggedElement FadeIn is completed and the ghosts are
-        // correctly positioned before displaying the original UIElements
+        // We ust the same completed callback as MoveGhostToTarget animation to  be sure that the DraggedElement
+        // FadeIn is completed and the ghosts are correctly positioned before displaying the original UIElements
         m_draggedElementFadeInAnimationClock.Completed += this.GhostToTargetAnimation_Completed;
 
         draggedElement.ApplyAnimationClock( UIElement.OpacityProperty, m_draggedElementFadeInAnimationClock );
@@ -1907,8 +1806,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void PauseDraggedElementFadeInAnimation()
     {
-      // Ensure to stop dragged element FadeIn in order
-      // to correctly display the DraggedElementGhost
+      // Ensure to stop dragged element FadeIn in order to correctly display the DraggedElementGhost
       UIElement draggedElement = this.DraggedElement;
 
       if( draggedElement != null )
@@ -1925,6 +1823,56 @@ namespace Xceed.Wpf.DataGrid.Views
       m_draggedElementFadeInAnimationClock = null;
     }
 
+    private IEnumerable<UIElement> GetElements()
+    {
+      return this.GetElementAdornerEntries().Select( item => item.Key );
+    }
+
+    private IEnumerable<DraggedElementAdorner> GetElementAdorners()
+    {
+      return this.GetElementAdornerEntries().Select( item => item.Value );
+    }
+
+    private IEnumerable<KeyValuePair<UIElement, DraggedElementAdorner>> GetElementAdornerEntries()
+    {
+      var entries = m_elementToDraggedElementAdorner.ToList();
+
+      foreach( var entry in entries )
+      {
+        var container = entry.Key;
+
+        if( this.OwnElement( container ) )
+        {
+          Debug.Assert( m_elementToDraggedElementAdorner.ContainsKey( container ) );
+
+          yield return entry;
+        }
+        else
+        {
+          this.RemoveDraggedColumnGhost( container );
+        }
+      }
+    }
+
+    private bool OwnElement( DependencyObject target )
+    {
+      if( target == null )
+        return false;
+
+      ColumnReorderingDragSourceManager manager;
+      Cell cell = target as Cell;
+
+      if( cell != null )
+      {
+        manager = cell.ParentColumnReorderingDragSourceManager;
+      }
+      else
+      {
+        manager = TableflowView.GetColumnReorderingDragSourceManager( target );
+      }
+
+      return ( this == manager );
+    }
 
     private bool m_reorderCancelled; // = false;
     private bool m_noColumnsReorderingNeeded = false;
@@ -1936,9 +1884,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private AnimationClock m_splitterAnimationClock; // = null;
 
-    private Dictionary<string, AnimationClock> m_fieldNameToClock = new Dictionary<string, AnimationClock>();
-
-    private Dictionary<AnimationClock, string> m_clockToFieldName = new Dictionary<AnimationClock, string>();
+    private Dictionary<ColumnBase, List<AnimationClock>> m_fieldNameToClock = new Dictionary<ColumnBase, List<AnimationClock>>();
 
     private Dictionary<UIElement, DraggedElementAdorner> m_elementToDraggedElementAdorner = new Dictionary<UIElement, DraggedElementAdorner>();
     private DraggedElementAdorner m_popupDraggedElementAdorner;
@@ -1950,16 +1896,10 @@ namespace Xceed.Wpf.DataGrid.Views
     private int m_columnAnimationDurationCache;
     private Duration m_columnAnimationDuration;
 
-    private static Point EmptyPoint = new Point();
-
-    ReorderingInfoManager m_reorderingInfoManager; // = null;
+    private ReorderingInfoManager m_reorderingInfoManager; // = null;
+    private int m_level;
 
-    internal enum DraggedOverCellRegion
-    {
-      Unknown,
-      Left,
-      Right
-    }
+    private static Point EmptyPoint = new Point();
 
     private enum HorizontalMouseDragDirection
     {
@@ -1970,48 +1910,50 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private class ReorderingInfoManager
     {
-      public ReorderingInfoManager()
+      internal ReorderingInfoManager( int level )
       {
+        m_level = level;
       }
 
-      public int InitialColumnVisiblePosition
+      internal int InitialColumnVisiblePosition
       {
         get;
-        private set;
+        set;
       }
 
-      public int InitialFixedColumnCount
+      internal int InitialFixedColumnCount
       {
         get;
-        private set;
+        set;
       }
 
-      public List<ColumnBase> InitialColumnsByVisiblePosition
+      internal List<ColumnBase> InitialColumnsByVisiblePosition
       {
         get;
-        private set;
+        set;
       }
 
       // Contains the ColumnsByVisiblePosition of the DataGridContext in the current reordered order
-      public List<ColumnBase> ReorderedColumnsByVisiblePosition
+      internal List<ColumnBase> ReorderedColumnsByVisiblePosition
       {
         get;
-        private set;
+        set;
       }
 
-      public RequiredAnimationsInfo RequiredAnimations
+      internal RequiredAnimationsInfo RequiredAnimations
       {
         get;
-        private set;
+        set;
       }
 
-      internal void InitalizeInfoManager( int newFixedColumnCount )
+      internal void InitializeInfoManager( int newFixedColumnCount, int correctionValue )
       {
         this.RequiredAnimations = new RequiredAnimationsInfo();
         this.RequiredAnimations.NewFixedColumnCount = newFixedColumnCount;
+        this.RequiredAnimations.CorrectionValue = correctionValue;
       }
 
-      public void BeginReordering( DataGridContext dataGridContext, int initialColumnVisiblePosition )
+      internal void BeginReordering( DataGridContext dataGridContext, int initialColumnVisiblePosition, int initialFixedColumnCount )
       {
         if( dataGridContext == null )
           throw new ArgumentNullException( "dataGridContext" );
@@ -2022,25 +1964,30 @@ namespace Xceed.Wpf.DataGrid.Views
         }
 
         this.InitialColumnVisiblePosition = initialColumnVisiblePosition;
-        this.InitialFixedColumnCount = TableflowView.GetFixedColumnCount( dataGridContext );
+        this.InitialFixedColumnCount = initialFixedColumnCount;
 
-        int columnsByVisiblePositionCount = dataGridContext.ColumnsByVisiblePosition.Count;
-        ColumnBase[] columnsByVisiblePosition = new ColumnBase[ columnsByVisiblePositionCount ];
-        dataGridContext.ColumnsByVisiblePosition.CopyTo( columnsByVisiblePosition, 0 );
+        ColumnBase[] columnsByVisiblePosition;
+        HashedLinkedList<ColumnBase> sourceColumnList;
+        sourceColumnList = dataGridContext.ColumnsByVisiblePosition;
+
+        columnsByVisiblePosition = new ColumnBase[ sourceColumnList.Count ];
+        sourceColumnList.CopyTo( columnsByVisiblePosition, 0 );
 
         this.InitialColumnsByVisiblePosition = new List<ColumnBase>( columnsByVisiblePosition );
 
         this.ReorderedColumnsByVisiblePosition = new List<ColumnBase>();
 
+        this.RollbackReorderedColumnsAndFixedColumnCount();
+
         m_isProcessingReordering = true;
       }
 
-      public void EndReordering()
+      internal void EndReordering()
       {
         m_isProcessingReordering = false;
       }
 
-      public void UpdateDraggedColumnVisiblePosition( int newPosition )
+      internal void UpdateDraggedColumnVisiblePosition( int newPosition )
       {
         // Reinitialize the ReorderedColumns List
         this.ReorderedColumnsByVisiblePosition = new List<ColumnBase>( this.InitialColumnsByVisiblePosition );
@@ -2149,14 +2096,12 @@ namespace Xceed.Wpf.DataGrid.Views
         }
       }
 
-      public void RollbackReorderedColumnsAndFixedColumnCount()
+      internal void RollbackReorderedColumnsAndFixedColumnCount()
       {
-        this.RequiredAnimations = new RequiredAnimationsInfo( this.InitialColumnVisiblePosition,
-          this.InitialFixedColumnCount,
-          this.InitialColumnsByVisiblePosition );
+        this.RequiredAnimations = new RequiredAnimationsInfo( this.InitialColumnVisiblePosition, this.InitialFixedColumnCount, 0, this.InitialColumnsByVisiblePosition );
       }
 
-      internal void UpdateReorderingInfo( TableViewColumnVirtualizationManager columnVirtualizationManager )
+      internal void UpdateReorderingInfo( TableViewColumnVirtualizationManagerBase columnVirtualizationManager )
       {
         // Do not create another instance since we want to keep the NewFixedColumnCount
         RequiredAnimationsInfo animationState = this.RequiredAnimations;
@@ -2173,7 +2118,7 @@ namespace Xceed.Wpf.DataGrid.Views
         bool draggedColumnReached = false;
         int visibleColumnCount = columnsByVisiblePosition.Count;
 
-        Dictionary<string, object> columnsInView = columnVirtualizationManager.FixedAndScrollingFieldNamesLookupDictionary;
+        var columnsInView = columnVirtualizationManager.GetVisibleFieldNames( m_level );
 
         for( int i = 0; i < visibleColumnCount; i++ )
         {
@@ -2192,19 +2137,19 @@ namespace Xceed.Wpf.DataGrid.Views
 
           if( originalColumn == reorderedColumn )
           {
-            animationState.RollbackAnimation.Add( reorderedColumn );
+            this.ProcessAnimatedCollectionAddition( reorderedColumn, animationState.RollbackAnimation );
             continue;
           }
 
-          if( columnsInView.ContainsKey( reorderedColumn.FieldName ) )
+          if( columnsInView.Contains( reorderedColumn.FieldName ) )
           {
             if( !draggedColumnReached )
             {
-              animationState.AnimateToLeft.Add( reorderedColumn );
+              this.ProcessAnimatedCollectionAddition( reorderedColumn, animationState.AnimateToLeft );
             }
             else
             {
-              animationState.AnimateToRight.Add( reorderedColumn );
+              this.ProcessAnimatedCollectionAddition( reorderedColumn, animationState.AnimateToRight );
             }
           }
         }
@@ -2212,17 +2157,22 @@ namespace Xceed.Wpf.DataGrid.Views
         animationState.DraggedColumnNewVisiblePosition = reorderedColumnsByVisiblePosition.IndexOf( draggedColumn );
       }
 
+      private void ProcessAnimatedCollectionAddition( ColumnBase animatedColumn, List<ColumnBase> animatedCollection )
+      {
+        animatedCollection.Add( animatedColumn );
+      }
       private bool m_isProcessingReordering; // = false;
+      private int m_level;
     }
 
     private class RequiredAnimationsInfo
     {
-      public RequiredAnimationsInfo()
-        : this( -1, -1, null )
+      internal RequiredAnimationsInfo()
+        : this( -1, -1, 0, null )
       {
       }
 
-      public RequiredAnimationsInfo( int draggedColumnNewVisiblePosition, int newFixedColumnCount, IList<ColumnBase> initialColumns )
+      internal RequiredAnimationsInfo( int draggedColumnNewVisiblePosition, int newFixedColumnCount, int correctionValue, IList<ColumnBase> initialColumns )
       {
         this.AnimateToLeft = new List<ColumnBase>();
         this.AnimateToRight = new List<ColumnBase>();
@@ -2230,6 +2180,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
         this.DraggedColumnNewVisiblePosition = draggedColumnNewVisiblePosition;
         this.NewFixedColumnCount = newFixedColumnCount;
+        this.CorrectionValue = correctionValue;
 
         if( initialColumns != null )
         {
@@ -2237,34 +2188,40 @@ namespace Xceed.Wpf.DataGrid.Views
         }
       }
 
-      public int DraggedColumnNewVisiblePosition
+      internal int DraggedColumnNewVisiblePosition
       {
         get;
         set;
       }
 
-      public int NewFixedColumnCount
+      internal int NewFixedColumnCount
       {
         get;
         set;
       }
 
-      public List<ColumnBase> AnimateToLeft
+      internal int CorrectionValue
       {
         get;
-        private set;
+        set;
+      }
+
+      internal List<ColumnBase> AnimateToLeft
+      {
+        get;
+        set;
       }
 
-      public List<ColumnBase> AnimateToRight
+      internal List<ColumnBase> AnimateToRight
       {
         get;
-        private set;
+        set;
       }
 
-      public List<ColumnBase> RollbackAnimation
+      internal List<ColumnBase> RollbackAnimation
       {
         get;
-        private set;
+        set;
       }
     }
   }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowView.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowView.cs
index 3b630d8f..56b92276 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowView.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowView.cs
@@ -14,13 +14,9 @@
 
   ***********************************************************************************/
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.ComponentModel;
 using System.Windows;
 using System.Windows.Media;
-using System.ComponentModel;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
@@ -144,7 +140,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region AreColumnsBeingReordered Attached Property
 
-    [ViewProperty( ViewPropertyMode.RoutedNoFallback )]
+    [ViewProperty( ViewPropertyMode.RoutedNoFallback, FlattenDetailBindingMode.MasterOneWay )]
     public static readonly DependencyProperty AreColumnsBeingReorderedProperty = DependencyProperty.RegisterAttached(
       "AreColumnsBeingReordered",
       typeof( bool ),
@@ -225,7 +221,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region FixedColumnSplitterTranslation Attached Property
 
-    [ViewProperty( ViewPropertyMode.RoutedNoFallback )]
+    [ViewProperty( ViewPropertyMode.RoutedNoFallback, FlattenDetailBindingMode.MasterOneWay )]
     internal static readonly DependencyProperty FixedColumnSplitterTranslationProperty = DependencyProperty.RegisterAttached(
       "FixedColumnSplitterTranslation",
       typeof( TranslateTransform ),
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowViewItemsHost.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowViewItemsHost.cs
index fb99ff61..d519afb2 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowViewItemsHost.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/(TableflowView)/TableflowViewItemsHost.cs
@@ -16,21 +16,16 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Diagnostics;
 using System.Linq;
-using System.Text;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
+using System.Windows.Input;
 using System.Windows.Media;
-using System.Windows.Controls;
-using Xceed.Utils.Math;
-using System.Windows.Threading;
-using System.Diagnostics;
 using System.Windows.Media.Animation;
-using Xceed.Utils.Wpf;
-using System.Windows.Input;
-using System.Collections;
-using System.Collections.ObjectModel;
-using System.Collections.Specialized;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
@@ -334,7 +329,14 @@ namespace Xceed.Wpf.DataGrid.Views
       TableflowViewItemsHost host = ( TableflowViewItemsHost )sender;
 
       host.SetVerticalOffsetCore( ( double )e.NewValue );
-      host.GeneratePage( false, host.AnimatedScrollInfo.ViewportHeight );
+
+      // Do not generate a page while the changed is due to the unloading 
+      // of the grid. See TableflowViewItemsHost.OnParentDataGridControlChanged
+      if( DataGridControl.GetDataGridContext( host ) != null )
+      {
+        host.GeneratePage( false, host.AnimatedScrollInfo.ViewportHeight );
+      }
+
       host.InvalidateArrange();
       host.InvalidateScrollInfo();
     }
@@ -550,8 +552,6 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected override Size MeasureOverride( Size availableSize )
     {
-      this.InvalidateAutomationPeerChildren();
-
       m_cachedContainerDesiredWidth.Clear();
       m_cachedContainerRealDesiredWidth.Clear();
       m_autoWidthCalculatedDataGridContextList.Clear();
@@ -637,8 +637,8 @@ namespace Xceed.Wpf.DataGrid.Views
         // We invalidate the CellsHostPanel of the row and all is parent to ensure the
         // size is correctly evaluated when we have some auto stretching column.
         container.InvalidateMeasure();
-        Row row = this.ExtractRowFromContainer( container );
 
+        Row row = Row.FromContainer( container );
         if( row != null )
         {
           UIElement itemToInvalidate = row.CellsHostPanel;
@@ -672,41 +672,24 @@ namespace Xceed.Wpf.DataGrid.Views
         m_cachedContainerDesiredWidth.Add( dataGridContextName, desiredSize );
       }
 
-      HeaderFooterItem headerFooterItem = container as HeaderFooterItem;
-
-      if( headerFooterItem != null )
+      PassiveLayoutDecorator decorator = this.GetPassiveLayoutDecorator( container as HeaderFooterItem );
+      if( decorator != null )
       {
-        PassiveLayoutDecorator passiveLayoutDecorator = null;
+        desiredSize = decorator.RealDesiredSize.Width;
 
-        if( VisualTreeHelper.GetChildrenCount( headerFooterItem ) > 0 )
+        if( m_cachedContainerRealDesiredWidth.TryGetValue( dataGridContextName, out cachedSize ) )
         {
-          DependencyObject child = VisualTreeHelper.GetChild( headerFooterItem, 0 );
-          passiveLayoutDecorator = child as PassiveLayoutDecorator;
-
-          if( ( passiveLayoutDecorator == null ) && ( VisualTreeHelper.GetChildrenCount( child ) > 0 ) )
-          {
-            passiveLayoutDecorator = VisualTreeHelper.GetChild( child, 0 ) as PassiveLayoutDecorator;
-          }
-
-          if( passiveLayoutDecorator != null )
+          // Keep the largest size!
+          if( cachedSize < desiredSize )
           {
-            desiredSize = passiveLayoutDecorator.RealDesiredSize.Width;
-
-            if( m_cachedContainerRealDesiredWidth.TryGetValue( dataGridContextName, out cachedSize ) )
-            {
-              // Keep the largest size!
-              if( cachedSize < desiredSize )
-              {
-                m_cachedContainerRealDesiredWidth[ dataGridContextName ] = desiredSize;
-              }
-            }
-            else
-            {
-              // Cache the size for the context.
-              m_cachedContainerRealDesiredWidth.Add( dataGridContextName, desiredSize );
-            }
+            m_cachedContainerRealDesiredWidth[ dataGridContextName ] = desiredSize;
           }
         }
+        else
+        {
+          // Cache the size for the context.
+          m_cachedContainerRealDesiredWidth.Add( dataGridContextName, desiredSize );
+        }
       }
     }
 
@@ -723,6 +706,22 @@ namespace Xceed.Wpf.DataGrid.Views
       return finalSize;
     }
 
+    private PassiveLayoutDecorator GetPassiveLayoutDecorator( HeaderFooterItem item )
+    {
+      if( ( item == null ) || ( VisualTreeHelper.GetChildrenCount( item ) == 0 ) )
+        return null;
+
+      DependencyObject firstChild = VisualTreeHelper.GetChild( item, 0 );
+      PassiveLayoutDecorator decorator = firstChild as PassiveLayoutDecorator;
+
+      if( ( decorator == null ) && ( VisualTreeHelper.GetChildrenCount( firstChild ) > 0 ) )
+      {
+        decorator = VisualTreeHelper.GetChild( firstChild, 0 ) as PassiveLayoutDecorator;
+      }
+
+      return decorator;
+    }
+
     private void ArrangeContainer( UIElement container, Point translationPoint, bool rowSelectorPaneVisible )
     {
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( container );
@@ -736,7 +735,9 @@ namespace Xceed.Wpf.DataGrid.Views
       this.SetCompensationOffset( dataGridContext, container, containerSize.Width );
 
       if( rowSelectorPaneVisible )
+      {
         this.SetRowSelector( container, translationPoint, containerSize );
+      }
     }
 
     private double GetContainerWidth( string dataGridContextName )
@@ -825,7 +826,9 @@ namespace Xceed.Wpf.DataGrid.Views
         }
 
         if( desiredWidth > maxDesiredWidth )
+        {
           maxDesiredWidth = desiredWidth;
+        }
       }
 
       return maxDesiredWidth;
@@ -835,24 +838,6 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region Containers Methods
 
-    private Row ExtractRowFromContainer( UIElement container )
-    {
-      Row row = container as Row;
-
-      if( row != null )
-        return row;
-
-      HeaderFooterItem headerFooterItem = container as HeaderFooterItem;
-
-      if( headerFooterItem != null )
-      {
-        // Until the first measure is called, this will always return null.
-        row = HeaderFooterItem.FindIDataGridItemContainerInChildren( headerFooterItem, headerFooterItem.AsVisual() ) as Row;
-      }
-
-      return row;
-    }
-
     private bool ContainerIsRow( UIElement container )
     {
       if( container is Row )
@@ -990,57 +975,52 @@ namespace Xceed.Wpf.DataGrid.Views
       ICustomItemContainerGenerator generator = this.CustomItemContainerGenerator;
 
       // The generator can be null if we're in design mode.
-      if( generator == null )
-        return;
-
-      if( Double.IsInfinity( viewportHeight ) )
-        viewportHeight = this.AnimatedScrollInfo.ExtentHeight;
-
-      // Make sure that container recycling is currently enabled on the generator.
-      generator.IsRecyclingEnabled = true;
-
-      // Calculate the start and end index of the current page.
-      PageIndexes visiblePageIndexes;
-      this.CalculateLayoutedIndexes( m_verticalOffset, viewportHeight, out visiblePageIndexes );
-
-      bool pageChanged = ( m_lastVisiblePageIndexes != visiblePageIndexes );
-      m_lastVisiblePageIndexes = visiblePageIndexes;
-
-      if( measureInvalidated || pageChanged )
+      if( generator != null )
       {
-        // Recycle and layout the containers for the current page.
-        UIElement focusedElement = this.RecycleContainers( generator, visiblePageIndexes.StartIndex, visiblePageIndexes.EndIndex );
-
-        if( m_containerHeight > 0 )
+        if( Double.IsInfinity( viewportHeight ) )
         {
-          this.GenerateContainers( generator, visiblePageIndexes.StartIndex, visiblePageIndexes.EndIndex, measureInvalidated, ref focusedElement );
-          this.GenerateStickyHeaders( generator, measureInvalidated, ref focusedElement );
-          this.GenerateStickyFooters( generator, measureInvalidated, ref focusedElement );
+          viewportHeight = this.AnimatedScrollInfo.ExtentHeight;
         }
 
-        if( focusedElement != null )
+        // Make sure that container recycling is currently enabled on the generator.
+        generator.IsRecyclingEnabled = true;
+
+        // Calculate the start and end index of the current page.
+        PageIndexes visiblePageIndexes;
+        this.CalculateLayoutedIndexes( m_verticalOffset, viewportHeight, out visiblePageIndexes );
+
+        bool pageChanged = ( m_lastVisiblePageIndexes != visiblePageIndexes );
+
+        if( measureInvalidated || pageChanged )
         {
-          int index = generator.GetRealizedIndexForContainer( focusedElement );
+          UIElement focusedElement;
 
-          if( index > -1 )
+          if( m_containerHeight > 0d )
           {
-            if( measureInvalidated )
-            {
-              this.MeasureContainer( focusedElement );
-            }
+            // Recycle the containers we know will not be in the current page.  GenerateContainers will recycle
+            // the remaining containers that were uncertain.
+            focusedElement = this.RecycleSafeContainers( generator, visiblePageIndexes.StartIndex, visiblePageIndexes.EndIndex );
 
-            m_layoutedContainers.Add( new LayoutedContainerInfo( index, focusedElement ) );
-            focusedElement = null;
+            this.GenerateContainers( generator, visiblePageIndexes.StartIndex, visiblePageIndexes.EndIndex, measureInvalidated, ref focusedElement );
+            this.GenerateStickyHeaders( generator, measureInvalidated, ref focusedElement );
+            this.GenerateStickyFooters( generator, measureInvalidated, ref focusedElement );
           }
           else
           {
-            this.RecycleContainer( focusedElement );
-            m_layoutedContainersToRecycle.Add( focusedElement );
+            focusedElement = this.RecycleAllContainers( generator );
+            Debug.Assert( m_layoutedContainers.Count == 0 );
           }
+
+          // Reuse or recycle the focused element's container.
+          this.GenerateFocusedContainer( generator, measureInvalidated, focusedElement );
         }
+
+        m_lastVisiblePageIndexes = visiblePageIndexes;
+
+        this.PreventOpacityAnimation = false;
       }
 
-      this.PreventOpacityAnimation = false;
+      this.InvalidateAutomationPeerChildren();
     }
 
     private UIElement RecycleContainers(
@@ -1050,32 +1030,69 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       UIElement focusedElement = null;
 
-      for( int i = 0; i < m_layoutedContainers.Count; i++ )
+      for( int i = m_layoutedContainers.Count - 1; i >= 0; i-- )
       {
-        LayoutedContainerInfo layoutedContainerInfo = m_layoutedContainers[ i ];
-        UIElement container = layoutedContainerInfo.Container;
-
-        // We do not recycle the focused element!
-        if( container.IsKeyboardFocusWithin )
-        {
-          focusedElement = container;
-          continue;
-        }
+        var container = m_layoutedContainers[ i ].Container;
 
         int index = generator.GetRealizedIndexForContainer( container );
 
         // If the container's index is now out of view, recycle that container.
         if( ( index < pageStartIndex ) || ( index > pageEndIndex ) )
         {
-          this.RecycleContainer( generator, index, container );
-          m_layoutedContainersToRecycle.Add( container );
+          // We do not recycle the focused element!
+          if( container.IsKeyboardFocusWithin )
+          {
+            focusedElement = container;
+          }
+          else
+          {
+            this.RecycleContainer( generator, index, container );
+          }
+
+          m_layoutedContainers.RemoveAt( i );
         }
       }
 
-      m_layoutedContainers.Clear();
       return focusedElement;
     }
 
+    private UIElement RecycleAllContainers( ICustomItemContainerGenerator generator )
+    {
+      return this.RecycleContainers( generator, -1, -1 );
+    }
+
+    private UIElement RecycleSafeContainers(
+      ICustomItemContainerGenerator generator,
+      int pageStartIndex,
+      int pageEndIndex )
+    {
+      if( m_lastVisiblePageIndexes == PageIndexes.Empty )
+        return this.RecycleContainers( generator, pageStartIndex, pageEndIndex );
+
+      if( m_lastVisiblePageIndexes.StartIndex == pageStartIndex )
+        return this.RecycleContainers( generator,
+                                       pageStartIndex,
+                                       Math.Max( pageEndIndex, m_lastVisiblePageIndexes.EndIndex ) );
+
+      if( m_lastVisiblePageIndexes.EndIndex == pageEndIndex )
+        return this.RecycleContainers( generator,
+                                       Math.Min( pageStartIndex, m_lastVisiblePageIndexes.StartIndex ),
+                                       pageEndIndex );
+
+      int itemCount = generator.ItemCount;
+      int threshold = Math.Max( 0,
+                                ( m_lastVisiblePageIndexes.EndIndex - m_lastVisiblePageIndexes.StartIndex ) -
+                                ( pageEndIndex - pageStartIndex ) );
+
+      int endIndex = Math.Min( pageEndIndex + threshold, itemCount - 1 );
+      if( endIndex < 0 )
+        return this.RecycleAllContainers( generator );
+
+      int startIndex = Math.Max( endIndex - threshold - ( pageEndIndex - pageStartIndex ), 0 );
+
+      return this.RecycleContainers( generator, startIndex, endIndex );
+    }
+
     private void RecycleUnusedStickyContainers(
       ICustomItemContainerGenerator generator,
       StickyContainerInfoList stickyContainers,
@@ -1090,15 +1107,12 @@ namespace Xceed.Wpf.DataGrid.Views
         if( m_layoutedContainers.ContainsContainer( container ) )
           continue;
 
-        if( ( stickyContainersToExclude != null )
-          && ( stickyContainersToExclude.ContainsContainer( container ) ) )
-        {
+        if( ( stickyContainersToExclude != null ) && ( stickyContainersToExclude.ContainsContainer( container ) ) )
           continue;
-        }
 
         if( container.IsKeyboardFocusWithin )
         {
-          System.Diagnostics.Debug.Assert( ( focusedElement == null ) || ( focusedElement == container ) );
+          Debug.Assert( ( focusedElement == null ) || ( focusedElement == container ) );
           focusedElement = container;
           continue;
         }
@@ -1106,7 +1120,6 @@ namespace Xceed.Wpf.DataGrid.Views
         int index = generator.GetRealizedIndexForContainer( container );
 
         this.RecycleContainer( generator, index, container );
-        m_layoutedContainersToRecycle.Add( container );
         stickyContainers.RemoveAt( i );
       }
     }
@@ -1139,6 +1152,8 @@ namespace Xceed.Wpf.DataGrid.Views
 
       this.DisableElementNavigation( container );
       this.FreeRowSelector( container );
+
+      m_layoutedContainersToRecycle.Add( container );
     }
 
     private void GenerateContainers(
@@ -1148,39 +1163,41 @@ namespace Xceed.Wpf.DataGrid.Views
       bool measureInvalidated,
       ref UIElement focusedElement )
     {
+      HashSet<UIElement> unusedLayoutedContainers = new HashSet<UIElement>( m_layoutedContainers.Select( item => item.Container ) );
+      m_layoutedContainers.Clear();
+
       ScrollDirection scrollDirection = this.AnimatedScrollInfo.VerticalScrollingDirection;
 
       GeneratorPosition position;
       GeneratorDirection direction;
+      int currentIndex;
+      int step;
 
       if( ( scrollDirection == ScrollDirection.Forward )
         || ( scrollDirection == ScrollDirection.None ) )
       {
         position = generator.GeneratorPositionFromIndex( pageStartIndex );
         direction = GeneratorDirection.Forward;
+        currentIndex = pageStartIndex;
+        step = 1;
       }
       else
       {
         position = generator.GeneratorPositionFromIndex( pageEndIndex );
         direction = GeneratorDirection.Backward;
+        currentIndex = pageEndIndex;
+        step = -1;
       }
 
       using( generator.StartAt( position, direction, true ) )
       {
-        int currentIndex = ( direction == GeneratorDirection.Forward )
-          ? pageStartIndex
-          : pageEndIndex;
-
-        while( ( direction == GeneratorDirection.Forward )
-          ? ( currentIndex <= pageEndIndex )
-          : ( currentIndex >= pageStartIndex ) )
+        while( ( currentIndex >= pageStartIndex ) && ( currentIndex <= pageEndIndex ) )
         {
           UIElement container = this.GenerateContainer( generator, currentIndex, measureInvalidated, true );
-
           if( container == null )
-            return;
+            break;
 
-          if( ( focusedElement != null ) && ( focusedElement == container ) )
+          if( focusedElement == container )
           {
             focusedElement = null;
           }
@@ -1188,12 +1205,98 @@ namespace Xceed.Wpf.DataGrid.Views
           // The container is now part of the page layout. Add it to the list.
           m_layoutedContainers.Add( new LayoutedContainerInfo( currentIndex, container ) );
           m_layoutedContainersToRecycle.Remove( container );
+          unusedLayoutedContainers.Remove( container );
 
-          currentIndex += ( direction == GeneratorDirection.Forward ) ? 1 : -1;
+          currentIndex += step;
+        }
+      }
+
+      // A ScrollViewer may measure forever if the containers that are "underneath" the horizontal
+      // scrollbar are the ones that required the scrollbar in the first place.
+      if( m_lastVisiblePageIndexes != PageIndexes.Empty )
+      {
+        int remainingItemCount = ( m_lastVisiblePageIndexes.EndIndex - m_lastVisiblePageIndexes.StartIndex )
+                               - ( pageEndIndex - pageStartIndex );
+
+        if( ( remainingItemCount > 0 ) && ( this.GetMaxDesiredWidth() < this.AnimatedScrollInfo.ExtentWidth ) )
+        {
+          int itemCount = generator.ItemCount;
+
+          if( ( currentIndex >= 0 ) && ( currentIndex < itemCount ) )
+          {
+            position = generator.GeneratorPositionFromIndex( currentIndex );
+
+            using( generator.StartAt( position, direction, true ) )
+            {
+              while( ( remainingItemCount > 0 ) && ( currentIndex >= 0 ) && ( currentIndex < itemCount ) )
+              {
+                UIElement container = this.GenerateContainer( generator, currentIndex, measureInvalidated, true );
+                if( container == null )
+                  break;
+
+                if( focusedElement == container )
+                {
+                  focusedElement = null;
+                }
+
+                // The container is now part of the page layout. Add it to the list.
+                m_layoutedContainers.Add( new LayoutedContainerInfo( currentIndex, container ) );
+                m_layoutedContainersToRecycle.Remove( container );
+                unusedLayoutedContainers.Remove( container );
+
+                currentIndex += step;
+                remainingItemCount--;
+              }
+            }
+          }
         }
       }
 
       m_layoutedContainers.Sort();
+
+      // Recycle the containers that have not been reused in the current page.
+      foreach( var container in unusedLayoutedContainers )
+      {
+        // We do not recycle the focused element!
+        if( container.IsKeyboardFocusWithin )
+        {
+          Debug.Assert( focusedElement == null );
+          focusedElement = container;
+        }
+        else
+        {
+          int index = generator.GetRealizedIndexForContainer( container );
+
+          this.RecycleContainer( generator, index, container );
+
+          m_layoutedContainersToRecycle.Add( container );
+        }
+      }
+    }
+
+    private void GenerateFocusedContainer(
+      ICustomItemContainerGenerator generator,
+      bool measureInvalidated,
+      UIElement focusedElement )
+    {
+      if( focusedElement == null )
+        return;
+
+      int index = generator.GetRealizedIndexForContainer( focusedElement );
+
+      if( index >= 0 )
+      {
+        if( measureInvalidated )
+        {
+          this.MeasureContainer( focusedElement );
+        }
+
+        m_layoutedContainers.Add( new LayoutedContainerInfo( index, focusedElement ) );
+      }
+      else
+      {
+        this.RecycleContainer( focusedElement );
+      }
     }
 
     private int GetStickyHeaderCountForIndex( int desiredIndex )
@@ -1526,7 +1629,8 @@ namespace Xceed.Wpf.DataGrid.Views
         this.ArrangeContainer( container, TableflowViewItemsHost.OutOfViewPoint, false );
       }
 
-      m_layoutedContainersToRecycle = new HashSet<UIElement>();
+      m_layoutedContainersToRecycle.Clear();
+      m_layoutedContainersToRecycle.TrimExcess();
 
       this.LayoutStickyHeaders( rowSelectorPaneVisible );
       this.LayoutStickyFooters( rowSelectorPaneVisible );
@@ -1787,13 +1891,16 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void PrepareContainer( UIElement container )
     {
-      object dataItem = container.GetValue( Xceed.Wpf.DataGrid.CustomItemContainerGenerator.DataItemPropertyProperty );
+      var dataItemStore = Xceed.Wpf.DataGrid.CustomItemContainerGenerator.GetDataItemProperty( container );
+      if( ( dataItemStore == null ) || dataItemStore.IsEmpty )
+        return;
 
-      if( dataItem != null )
-      {
-        // Prepare the container.
-        this.ParentDataGridControl.PrepareItemContainer( container, dataItem );
-      }
+      var dataItem = dataItemStore.Data;
+      if( dataItem == null )
+        return;
+
+      // Prepare the container.
+      this.ParentDataGridControl.PrepareItemContainer( container, dataItem );
     }
 
     #endregion Containers Methods
@@ -1901,19 +2008,24 @@ namespace Xceed.Wpf.DataGrid.Views
         && ( m_verticalOffsetAnimationClock.Controller != null ) )
       {
         if( resetScrollDirection )
+        {
           this.AnimatedScrollInfo.VerticalScrollingDirection = ScrollDirection.None;
+        }
 
         // We must call Pause instead on Stop to avoid having our
         // offset momentary set to 0. Weird...
         m_verticalOffsetAnimationClock.Controller.Pause();
         m_verticalOffsetAnimationClock.Completed -= this.OnVerticalOffsetAnimationCompleted;
         m_verticalOffsetAnimationClock = null;
+
+        this.InvalidateAutomationPeerChildren();
       }
     }
 
     private void OnVerticalOffsetAnimationCompleted( object sender, EventArgs e )
     {
       this.AnimatedScrollInfo.VerticalScrollingDirection = ScrollDirection.None;
+      this.InvalidateAutomationPeerChildren();
     }
 
     #endregion Animations Management
@@ -2181,10 +2293,12 @@ namespace Xceed.Wpf.DataGrid.Views
         if( ( isDataRow )
           && ( ( changeColumn ) && ( ( column == null ) || ( !column.CanBeCurrentWhenReadOnly && column.ReadOnly ) ) ) )
         {
-          int focusableIndex = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( dataGridContext );
+          int focusableIndex = NavigationHelper.GetFirstVisibleFocusableColumnIndex( dataGridContext );
 
           if( focusableIndex >= 0 )
+          {
             column = dataGridContext.VisibleColumns[ focusableIndex ];
+          }
         }
 
         try
@@ -2239,7 +2353,6 @@ namespace Xceed.Wpf.DataGrid.Views
       if( desiredIndex != focusedIndex )
       {
         DataGridControl dataGridControl = this.ParentDataGridControl;
-
         int cannotFocusCount = 0;
 
         // We want to find the first element that can receive focus upward.
@@ -2262,11 +2375,15 @@ namespace Xceed.Wpf.DataGrid.Views
             }
           }
 
-          // We succeded in changing the current or we're already 
-          // at the first index? Then nothing we can do.
-          if( ( currentChanged )
-            || ( desiredIndex == firstIndex ) )
+          // We succeded in changing the current.
+          if( currentChanged )
+            break;
+
+          // We already are at the first index and still not focused on a new container.
+          if( desiredIndex == firstIndex )
           {
+            //Let's keep the focus on the last focused container.
+            currentChanged = this.SetCurrent( focusedIndex, changeColumn, out isDataRow );
             break;
           }
 
@@ -2274,9 +2391,7 @@ namespace Xceed.Wpf.DataGrid.Views
         }
 
         // We will use MoveFocus if the focused index is currently in view.
-        if( ( !currentChanged )
-          && ( focusedIndex >= layoutedIndexes.StartIndex )
-          && ( focusedIndex <= layoutedIndexes.EndIndex ) )
+        if( ( !currentChanged ) && ( focusedIndex >= layoutedIndexes.StartIndex ) && ( focusedIndex <= layoutedIndexes.EndIndex ) )
         {
           currentChanged = this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Up ) );
         }
@@ -2288,9 +2403,7 @@ namespace Xceed.Wpf.DataGrid.Views
     private bool FocusIndexOrPreviousFocusable( int desiredIndex, int minimumIndex, bool changeColumn )
     {
       bool currentChanged = false;
-
       DataGridControl dataGridControl = this.ParentDataGridControl;
-
       int cannotFocusCount = 0;
 
       // We want to find the first element that can receive focus upward.
@@ -2313,13 +2426,9 @@ namespace Xceed.Wpf.DataGrid.Views
           }
         }
 
-        // We succeded in changing the current or we're already 
-        // at the first index? Then nothing we can do.
-        if( ( currentChanged )
-          || ( desiredIndex == minimumIndex ) )
-        {
+        // We succeded in changing the current or we're already at the first index? Then nothing we can do.
+        if( ( currentChanged ) || ( desiredIndex == minimumIndex ) )
           break;
-        }
 
         desiredIndex--;
       }
@@ -2343,7 +2452,6 @@ namespace Xceed.Wpf.DataGrid.Views
       if( desiredIndex != focusedIndex )
       {
         DataGridControl dataGridControl = this.ParentDataGridControl;
-
         int cannotFocusCount = 0;
 
         // We want to find the first element that can receive focus downward.
@@ -2366,21 +2474,22 @@ namespace Xceed.Wpf.DataGrid.Views
             }
           }
 
-          // We succeded in changing the current or we're already 
-          // at the first index? Then nothing we can do.
-          if( ( currentChanged )
-            || ( desiredIndex == lastIndex ) )
-          {
+          // We succeded in changing the current.
+          if( currentChanged )
             break;
+
+          // We already are at the last index and still not focused on a new container.
+          if( desiredIndex == lastIndex )
+          {
+            //Let's keep the focus on the last focused container.
+            currentChanged = this.SetCurrent( focusedIndex, changeColumn, out isDataRow );
           }
 
           desiredIndex++;
         }
 
         // We will use MoveFocus if the focused index is currently in view.
-        if( ( !currentChanged )
-          && ( focusedIndex >= layoutedIndexes.StartIndex )
-          && ( focusedIndex <= layoutedIndexes.EndIndex ) )
+        if( ( !currentChanged ) && ( focusedIndex >= layoutedIndexes.StartIndex ) && ( focusedIndex <= layoutedIndexes.EndIndex ) )
         {
           currentChanged = this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Down ) );
         }
@@ -2392,9 +2501,7 @@ namespace Xceed.Wpf.DataGrid.Views
     private bool FocusIndexOrNextFocusable( int desiredIndex, int maximumIndex, bool changeColumn )
     {
       bool currentChanged = false;
-
       DataGridControl dataGridControl = this.ParentDataGridControl;
-
       int cannotFocusCount = 0;
 
       // We want to find the first element that can receive focus downward.
@@ -2417,13 +2524,9 @@ namespace Xceed.Wpf.DataGrid.Views
           }
         }
 
-        // We succeded in changing the current or we're already 
-        // at the first index? Then nothing we can do.
-        if( ( currentChanged )
-          || ( desiredIndex == maximumIndex ) )
-        {
+        // We succeded in changing the current or we're already at the first index? Then nothing we can do.
+        if( ( currentChanged ) || ( desiredIndex == maximumIndex ) )
           break;
-        }
 
         desiredIndex++;
       }
@@ -2562,155 +2665,15 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
+      var dataGridControl = this.ParentDataGridControl;
       if( dataGridControl == null )
         return;
 
-      DataGridContext currentDataGridContext = dataGridControl.CurrentContext;
-
-      if( currentDataGridContext == null )
-        return;
-
-      // Only process tab in a special way when the grid has focus and is
-      // being edited
-      if( !dataGridControl.IsKeyboardFocusWithin || !dataGridControl.IsBeingEdited )
+      var dataGridContext = dataGridControl.CurrentContext;
+      if( dataGridContext == null )
         return;
 
-      DependencyObject predictedNextVisual = null;
-
-      //If the original source is not a control (e.g. the cells panel instead of a cell), columns will be used to move focus.
-      Control originalSource = e.OriginalSource as Control;
-      if( originalSource != null )
-      {
-        if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-        {
-          predictedNextVisual = ( e.OriginalSource as Control ).PredictFocus( FocusNavigationDirection.Left );
-        }
-        else
-        {
-          predictedNextVisual = ( e.OriginalSource as Control ).PredictFocus( FocusNavigationDirection.Right );
-        }
-      }
-
-      if( predictedNextVisual != null )
-      {
-        Cell ownerCell = Cell.FindFromChild( predictedNextVisual );
-
-        if( ( ownerCell != null ) && ( ownerCell.ParentColumn == dataGridControl.CurrentColumn ) )
-        {
-          if( object.Equals( ownerCell.ParentRow.DataContext, dataGridControl.CurrentItemInEdition ) )
-            return;
-        }
-      }
-
-      int visibleColumnCount = currentDataGridContext.VisibleColumns.Count;
-      ReadOnlyObservableCollection<ColumnBase> visibleColumns = currentDataGridContext.VisibleColumns;
-
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
-
-      if( currentColumn == null )
-      {
-        int firstFocusableColumn = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( currentDataGridContext );
-
-        if( firstFocusableColumn < 0 )
-          throw new DataGridException( "Trying to edit while no cell is focusable. " );
-
-        try
-        {
-          currentDataGridContext.SetCurrentColumnAndChangeSelection( currentDataGridContext.VisibleColumns[ firstFocusableColumn ] );
-        }
-        catch( DataGridException )
-        {
-          // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-          // any other GridException.
-        }
-
-        e.Handled = true;
-      }
-      else
-      {
-        if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-        {
-          int previousColumnVisiblePosition = DataGridScrollViewer.GetPreviousVisibleFocusableColumnIndex( currentDataGridContext );
-
-          if( previousColumnVisiblePosition < visibleColumnCount )
-          {
-            if( previousColumnVisiblePosition >= 0 )
-            {
-              try
-              {
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ previousColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-            else
-            {
-              previousColumnVisiblePosition = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( currentDataGridContext );
-
-              if( previousColumnVisiblePosition < 0 )
-                throw new DataGridException( "Trying to edit while no cell is focusable. " );
-
-              try
-              {
-                // Wrap around to the last column
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ previousColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-            e.Handled = true;
-          }
-        }
-        else
-        {
-          int nextColumnVisiblePosition = DataGridScrollViewer.GetNextVisibleFocusableColumnIndex( currentDataGridContext );
-
-          // If previous Column VisiblePosition is greater than 0 and
-          // less than the total VisibleColumn count, affect it
-          if( nextColumnVisiblePosition >= 0 )
-          {
-            if( nextColumnVisiblePosition < visibleColumnCount )
-            {
-              try
-              {
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ nextColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-            else
-            {
-              nextColumnVisiblePosition = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( currentDataGridContext );
-
-              if( nextColumnVisiblePosition < 0 )
-                throw new DataGridException( "Trying to edit while no cell is focusable. " );
-
-              try
-              {
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ nextColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-
-            e.Handled = true;
-          }
-        }
-      }
+      e.Handled = NavigationHelper.HandleTabKey( dataGridControl, dataGridContext, e.OriginalSource as FrameworkElement, e.KeyboardDevice );
     }
 
     protected override void HandleLeftKey( KeyEventArgs e )
@@ -2718,7 +2681,11 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      e.Handled = this.MoveFocusLeft();
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusLeft( dataGridControl.CurrentContext );
     }
 
     protected override void HandleRightKey( KeyEventArgs e )
@@ -2726,7 +2693,11 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      e.Handled = this.MoveFocusRight();
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusRight( dataGridControl.CurrentContext );
     }
 
     protected override void HandleUpKey( KeyEventArgs e )
@@ -2758,23 +2729,19 @@ namespace Xceed.Wpf.DataGrid.Views
 
       if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
       {
-        // Simply scroll to top and set first index as current
-        this.AnimatedScrollInfo.ScrollOwner.ScrollToTop();
-        this.SetCurrent( 0, changeCurrentColumn );
+        this.MoveToFirstOverallUIElement( changeCurrentColumn );
         return;
       }
 
       UIElement focusedContainer = DataGridItemsHost.GetItemsHostContainerFromElement( this, Keyboard.FocusedElement as DependencyObject );
 
-      if( ( focusedContainer == null ) ||
-        ( navigationBehavior == NavigationBehavior.None ) )
+      if( ( focusedContainer == null ) || ( navigationBehavior == NavigationBehavior.None ) )
       {
         // We just need to scroll one page up.
         this.AnimatedScrollInfo.ScrollOwner.PageUp();
         return;
       }
 
-      int generatorItemCount = this.CustomItemContainerGenerator.ItemCount;
       int focusedContainerRealizedIndex = this.CustomItemContainerGenerator.GetRealizedIndexForContainer( focusedContainer );
       int desiredPageUpIndex = Math.Max( 0, focusedContainerRealizedIndex - m_pageVisibleContainerCount + 1 );
       int initialDesiredIndex = desiredPageUpIndex;
@@ -2786,17 +2753,12 @@ namespace Xceed.Wpf.DataGrid.Views
       else if( focusedContainerRealizedIndex != initialDesiredIndex )
       {
         PageIndexes pageIndexes = this.CalculateVisibleIndexesForDesiredLastVisibleIndex( focusedContainerRealizedIndex );
-
         desiredPageUpIndex = Math.Max( 0, pageIndexes.StartIndex );
-
         initialDesiredIndex = desiredPageUpIndex;
-
         bool isDataRow = false;
 
-        // SetCurrent on the index or down to a focusable index
-        while( ( !dataGridControl.HasValidationError )
-            && ( !isDataRow )
-            && ( desiredPageUpIndex < generatorItemCount ) )
+        // SetCurrent on the desired index or down until BEFORE the focused container.
+        while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageUpIndex < focusedContainerRealizedIndex ) )
         {
           if( this.SetCurrent( desiredPageUpIndex, changeCurrentColumn, out isDataRow ) )
             return;
@@ -2807,21 +2769,20 @@ namespace Xceed.Wpf.DataGrid.Views
         if( ( dataGridControl.HasValidationError ) || ( isDataRow ) )
           return;
 
-        // No container were focused while processing indexes from focused to 
-        // initialDesiredIndex, try SetCurrent on indexes lower than
-        // the initial up to 0
+        // No container were focused while processing indexes from focused to initialDesiredIndex, try SetCurrent on indexes lower than the initial up to 0
         desiredPageUpIndex = initialDesiredIndex - 1;
         isDataRow = false;
 
-        while( ( !dataGridControl.HasValidationError )
-            && ( !isDataRow )
-            && ( desiredPageUpIndex > 0 ) )
+        while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageUpIndex > 0 ) )
         {
           if( this.SetCurrent( desiredPageUpIndex, changeCurrentColumn, out isDataRow ) )
             return;
 
           desiredPageUpIndex--;
         }
+
+        // If not container was successfuly focused, set focus back to the current UIElement.
+        this.SetCurrent( focusedContainerRealizedIndex, changeCurrentColumn, out isDataRow );
       }
     }
 
@@ -2831,24 +2792,21 @@ namespace Xceed.Wpf.DataGrid.Views
         return;
 
       e.Handled = true;
+
       DataGridControl dataGridControl = this.ParentDataGridControl;
       NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
       bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
 
-      // CTRL + PageDown
       if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
       {
-        // Simply scroll to bottom and set last index as current
-        this.AnimatedScrollInfo.ScrollOwner.ScrollToBottom();
-        this.SetCurrent( this.CustomItemContainerGenerator.ItemCount - 1, changeCurrentColumn );
+        this.MoveToLastOverallUIElement( changeCurrentColumn );
         return;
       }
 
       UIElement focusedContainer = DataGridItemsHost.GetItemsHostContainerFromElement( this, Keyboard.FocusedElement as DependencyObject );
 
       // No focused container or no navigation allowed
-      if( ( focusedContainer == null ) ||
-        ( navigationBehavior == NavigationBehavior.None ) )
+      if( ( focusedContainer == null ) || ( navigationBehavior == NavigationBehavior.None ) )
       {
         // We just need to scroll one page down.
         this.AnimatedScrollInfo.ScrollOwner.PageDown();
@@ -2857,13 +2815,9 @@ namespace Xceed.Wpf.DataGrid.Views
 
       int generatorItemCount = this.CustomItemContainerGenerator.ItemCount;
       int focusedContainerRealizedIndex = this.CustomItemContainerGenerator.GetRealizedIndexForContainer( focusedContainer );
-
-      int desiredPageDownIndex = Math.Min( generatorItemCount - 1,
-                                       focusedContainerRealizedIndex + m_pageVisibleContainerCount - 1 );
-
-      int initialDesiredIndex = desiredPageDownIndex;
-
       int maxIndex = generatorItemCount - 1;
+      int desiredPageDownIndex = Math.Min( generatorItemCount - 1, focusedContainerRealizedIndex + m_pageVisibleContainerCount - 1 );
+      int initialDesiredIndex = desiredPageDownIndex;
 
       if( focusedContainerRealizedIndex == maxIndex )
       {
@@ -2878,11 +2832,8 @@ namespace Xceed.Wpf.DataGrid.Views
 
         bool isDataRow = false;
 
-        // SetCurrent on the index or up to focusedContainerRealizedIndex to a focusable index 
-
-        while( ( !dataGridControl.HasValidationError )
-            && ( !isDataRow )
-            && ( desiredPageDownIndex > focusedContainerRealizedIndex ) )
+        // SetCurrent on the desired index or up until BEFORE the focused container.
+        while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageDownIndex > focusedContainerRealizedIndex ) )
         {
           if( this.SetCurrent( desiredPageDownIndex, changeCurrentColumn, out isDataRow ) )
             return;
@@ -2893,22 +2844,20 @@ namespace Xceed.Wpf.DataGrid.Views
         if( ( dataGridControl.HasValidationError ) || ( isDataRow ) )
           return;
 
-        //Debug.Assert( false, "When this will occur???" );
         desiredPageDownIndex = initialDesiredIndex + 1;
         isDataRow = false;
 
-        // No container were focused while processing indexes from focused to 
-        // initialDesiredIndex, try SetCurrent on indexes higher than
-        // the initial down to maxIndex
-        while( ( !dataGridControl.HasValidationError )
-            && ( !isDataRow )
-            && ( desiredPageDownIndex < maxIndex ) )
+        // No container were focused while processing indexes from focused to initialDesiredIndex, try SetCurrent on indexes higher than the initial down to maxIndex
+        while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageDownIndex <= maxIndex ) )
         {
-          if( this.SetCurrent( Math.Min( maxIndex, desiredPageDownIndex ), changeCurrentColumn, out isDataRow ) )
+          if( this.SetCurrent( desiredPageDownIndex, changeCurrentColumn, out isDataRow ) )
             return;
 
           desiredPageDownIndex++;
         }
+
+        // If not container was successfuly focused, set focus back to the current UIElement.
+        this.SetCurrent( focusedContainerRealizedIndex, changeCurrentColumn, out isDataRow );
       }
     }
 
@@ -2917,28 +2866,16 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-      IAnimatedScrollInfo scrollInfo = this.AnimatedScrollInfo;
-      ICustomItemContainerGenerator generator = this.CustomItemContainerGenerator;
-
-      NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
-      bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
-
       if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
       {
+        DataGridControl dataGridControl = this.ParentDataGridControl;
+        IAnimatedScrollInfo scrollInfo = this.AnimatedScrollInfo;
+        NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
+        bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
+
         if( navigationBehavior != NavigationBehavior.None )
         {
-          int currentIndex = generator.GetCurrentIndex();
-          int itemCount = generator.ItemCount;
-
-          // If the current index is different than the CurrentIndex
-          // force the first focusable from index 0 to become Current
-          if( ( currentIndex != 0 ) && ( itemCount > 0 ) )
-          {
-            // We have to find the first index that can get keyboard focus
-            // from 0 to currentIndex
-            this.FocusIndexOrNextFocusable( 0, currentIndex, changeCurrentColumn );
-          }
+          this.MoveToFirstOverallUIElement( changeCurrentColumn );
 
           if( navigationBehavior == NavigationBehavior.CellOnly )
           {
@@ -2962,14 +2899,6 @@ namespace Xceed.Wpf.DataGrid.Views
       e.Handled = true;
     }
 
-    private void ResetHorizontalOffset()
-    {
-      ScrollViewer parentScrollViewer = this.m_scrollOwner;
-
-      if( parentScrollViewer != null )
-        parentScrollViewer.ScrollToHorizontalOffset( 0d );
-    }
-
     protected override void HandleEndKey( KeyEventArgs e )
     {
       if( e.Handled )
@@ -2979,26 +2908,12 @@ namespace Xceed.Wpf.DataGrid.Views
       {
         DataGridControl dataGridControl = this.ParentDataGridControl;
         IAnimatedScrollInfo scrollInfo = this.AnimatedScrollInfo;
-        ICustomItemContainerGenerator generator = this.CustomItemContainerGenerator;
-
-        FlowDirection flowDirection = dataGridControl.FlowDirection;
         NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
         bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
 
         if( navigationBehavior != NavigationBehavior.None )
         {
-          int currentIndex = generator.GetCurrentIndex();
-          int itemCount = generator.ItemCount;
-          int lastItemIndex = itemCount - 1;
-
-          // If the current index is different than the CurrentIndex
-          // force the last focusable from index itemCount to become Current
-          if( ( currentIndex != lastItemIndex ) && ( itemCount > 0 ) )
-          {
-            // We have to find the last index that can get keyboard focus
-            // from lastItemIndex to currentIndex
-            this.FocusIndexOrPreviousFocusable( lastItemIndex, currentIndex, changeCurrentColumn );
-          }
+          this.MoveToLastOverallUIElement( changeCurrentColumn );
 
           if( navigationBehavior == NavigationBehavior.CellOnly )
           {
@@ -3022,143 +2937,35 @@ namespace Xceed.Wpf.DataGrid.Views
       e.Handled = true;
     }
 
-    private bool MoveToNextColumn()
+    private void MoveToFirstOverallUIElement( bool changeCurrentColumn )
     {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
-      if( dataGridControl == null )
-        return false;
-
-      DataGridContext currentDataGridContext = dataGridControl.CurrentContext;
-
-      if( currentDataGridContext == null )
-        return false;
-
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-      int visibleColumnsCollectionCount = visibleColumnsCollection.Count;
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
-
-      if( currentColumn == null )
-      {
-        if( visibleColumnsCollectionCount > 0 )
-        {
-          this.MoveToFirstVisibleColumn();
-          return true;
-        }
-      }
-      Row currentRow = currentDataGridContext.CurrentRow;
-
-      int currentColumnIndex = visibleColumnsCollection.IndexOf( currentColumn );
-
-      int nextFocusableVisibleColumn = 0;
-
-      bool focusableColumnFound = false;
+      // Simply scroll to top.
+      this.AnimatedScrollInfo.ScrollOwner.ScrollToTop();
 
-      if( currentRow != null )
+      //Try to focus on first UIElement.
+      if( !this.SetCurrent( 0, changeCurrentColumn ) )
       {
-        for( nextFocusableVisibleColumn = currentColumnIndex + 1; nextFocusableVisibleColumn < visibleColumnsCollectionCount; nextFocusableVisibleColumn++ )
-        {
-          if( currentRow.Cells[ visibleColumnsCollection[ nextFocusableVisibleColumn ] ].GetCalculatedCanBeCurrent() )
-          {
-            focusableColumnFound = true;
-            break;
-          }
-        }
-
-        if( focusableColumnFound )
-        {
-          try
-          {
-            currentDataGridContext.SetCurrentColumnAndChangeSelection(
-              currentDataGridContext.VisibleColumns[ nextFocusableVisibleColumn ] );
-          }
-          catch( DataGridException )
-          {
-            // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-            // any other GridException.
-          }
-
-          return true;
-        }
-        // If the column is other than last Column or than the last current column
-        else
-        {
-          this.MoveToLastVisibleColumn();
-        }
+        //If not focusable, find the next one downward.
+        CustomItemContainerGenerator generator = this.CustomItemContainerGenerator as CustomItemContainerGenerator;
+        this.FocusIndexOrNextFocusable( 1, generator.RealizedContainers.Count - 1, changeCurrentColumn );
       }
-      return false;
     }
 
-    private bool MoveToPreviousColumn()
+    private void MoveToLastOverallUIElement( bool changeCurrentColumn )
     {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
+      // Simply scroll to end
+      this.AnimatedScrollInfo.ScrollOwner.ScrollToBottom();
 
-      if( dataGridControl == null )
-        return false;
+      CustomItemContainerGenerator generator = this.CustomItemContainerGenerator as CustomItemContainerGenerator;
+      int lastItemIndex = generator.ItemCount - 1;
 
-      DataGridContext currentDataGridContext = dataGridControl.CurrentContext;
-
-      if( currentDataGridContext == null )
-        return false;
-
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-      int visibleColumnsCollectionCount = visibleColumnsCollection.Count;
-
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
-
-      if( currentColumn == null )
+      //Try to focus on last UIElement.
+      if( !this.SetCurrent( lastItemIndex, changeCurrentColumn ) )
       {
-        if( visibleColumnsCollectionCount > 0 )
-        {
-          this.MoveToFirstVisibleColumn();
-          return true;
-        }
-      }
-      else
-      {
-        Row currentRow = currentDataGridContext.CurrentRow;
-
-        int currentColumnIndex = visibleColumnsCollection.IndexOf( currentColumn );
-        bool focusableColumnFound = false;
-
-        // If the column is other than first Column
-        if( currentColumnIndex > 0 )
-        {
-          int previousFocusableVisibleColumn = 0;
-          if( currentRow != null )
-          {
-            for( previousFocusableVisibleColumn = currentColumnIndex - 1; previousFocusableVisibleColumn >= 0; previousFocusableVisibleColumn-- )
-            {
-              if( currentRow.Cells[ visibleColumnsCollection[ previousFocusableVisibleColumn ] ].GetCalculatedCanBeCurrent() )
-              {
-                focusableColumnFound = true;
-                break;
-              }
-            }
-          }
-
-          if( focusableColumnFound )
-          {
-            try
-            {
-              currentDataGridContext.SetCurrentColumnAndChangeSelection(
-                 currentDataGridContext.VisibleColumns[ previousFocusableVisibleColumn ] );
-            }
-            catch( DataGridException )
-            {
-              // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-              // any other GridException.
-            }
-
-            return true;
-          }
-          else
-          {
-            this.MoveToFirstVisibleColumn();
-          }
-        }
+        //If not focusable, find the next one upward.
+        int minimumIndex = lastItemIndex - generator.RealizedContainers.Count;
+        this.FocusIndexOrPreviousFocusable( lastItemIndex, minimumIndex, changeCurrentColumn );
       }
-      return false;
     }
 
     private void MoveToFirstVisibleColumn()
@@ -3261,6 +3068,14 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
+    private void ResetHorizontalOffset()
+    {
+      ScrollViewer parentScrollViewer = this.m_scrollOwner;
+
+      if( parentScrollViewer != null )
+        parentScrollViewer.ScrollToHorizontalOffset( 0d );
+    }
+
     #endregion
 
     #region Scroll Easing Management
@@ -3649,7 +3464,12 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private static void MoveFocusForwardExecuted( object sender, ExecutedRoutedEventArgs e )
     {
-      e.Handled = ( ( TableflowViewItemsHost )sender ).MoveFocusRight();
+      var itemsHost = ( TableflowViewItemsHost )sender;
+      var dataGridControl = itemsHost.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusRight( dataGridControl.CurrentContext );
     }
 
     private static void MoveFocusForwardCanExecute( object sender, CanExecuteRoutedEventArgs e )
@@ -3660,7 +3480,12 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private static void MoveFocusBackExecuted( object sender, ExecutedRoutedEventArgs e )
     {
-      e.Handled = ( ( TableflowViewItemsHost )sender ).MoveFocusLeft();
+      var itemsHost = ( TableflowViewItemsHost )sender;
+      var dataGridControl = itemsHost.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusLeft( dataGridControl.CurrentContext );
     }
 
     private static void MoveFocusBackCanExecute( object sender, CanExecuteRoutedEventArgs e )
@@ -3691,78 +3516,6 @@ namespace Xceed.Wpf.DataGrid.Views
       e.Handled = true;
     }
 
-    private bool MoveFocusLeft()
-    {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
-      if( dataGridControl == null )
-        return false;
-
-      bool dataGridControlFocusWithin = dataGridControl.IsKeyboardFocusWithin;
-
-      // Process Left key even if NavigationBehavior is RowOnly
-      // when the grid is being edited 
-      bool dataGridControlIsBeingEdited =
-        dataGridControlFocusWithin && dataGridControl.IsBeingEdited;
-
-      FlowDirection flowDirection = dataGridControl.FlowDirection;
-      NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
-
-      if( ( navigationBehavior == NavigationBehavior.CellOnly )
-        || ( ( navigationBehavior == NavigationBehavior.RowOnly ) && dataGridControlIsBeingEdited )
-        || ( ( navigationBehavior == NavigationBehavior.RowOrCell )
-              && dataGridControlFocusWithin
-              && dataGridControl.CurrentContext.CurrentColumn != null ) )
-      {
-        if( flowDirection == FlowDirection.LeftToRight )
-        {
-          return this.MoveToPreviousColumn();
-        }
-        else
-        {
-          return this.MoveToNextColumn();
-        }
-      }
-
-      return false;
-    }
-
-    private bool MoveFocusRight()
-    {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
-      if( dataGridControl == null )
-        return false;
-
-      bool dataGridControlFocusWithin = dataGridControl.IsKeyboardFocusWithin;
-
-      // Process Right key even if NavigationBehavior is RowOnly
-      // when the grid is being edited 
-      bool dataGridControlIsBeingEdited =
-        dataGridControlFocusWithin && dataGridControl.IsBeingEdited;
-
-      FlowDirection flowDirection = dataGridControl.FlowDirection;
-      NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
-
-      if( ( navigationBehavior == NavigationBehavior.CellOnly )
-        || ( ( navigationBehavior == NavigationBehavior.RowOnly ) && dataGridControlIsBeingEdited )
-        || ( ( navigationBehavior == NavigationBehavior.RowOrCell )
-              && dataGridControlFocusWithin
-              && dataGridControl.CurrentContext.CurrentColumn != null ) )
-      {
-        if( flowDirection == FlowDirection.LeftToRight )
-        {
-          return this.MoveToNextColumn();
-        }
-        else
-        {
-          return this.MoveToPreviousColumn();
-        }
-      }
-
-      return false;
-    }
-
     private bool MoveFocusUp()
     {
       DataGridControl dataGridControl = this.ParentDataGridControl;
@@ -3820,11 +3573,11 @@ namespace Xceed.Wpf.DataGrid.Views
 
 
 
-    private LayoutedContainerInfoList m_layoutedContainers = new LayoutedContainerInfoList();
-    private HashSet<UIElement> m_layoutedContainersToRecycle = new HashSet<UIElement>();
+    private readonly LayoutedContainerInfoList m_layoutedContainers = new LayoutedContainerInfoList();
+    private readonly HashSet<UIElement> m_layoutedContainersToRecycle = new HashSet<UIElement>();
 
-    private StickyContainerInfoList m_stickyHeaders = new StickyContainerInfoList();
-    private StickyContainerInfoList m_stickyFooters = new StickyContainerInfoList();
+    private readonly StickyContainerInfoList m_stickyHeaders = new StickyContainerInfoList();
+    private readonly StickyContainerInfoList m_stickyFooters = new StickyContainerInfoList();
 
     private int m_pageVisibleContainerCount;
 
@@ -3836,10 +3589,10 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private PageIndexes m_lastVisiblePageIndexes = PageIndexes.Empty;
 
-    private Dictionary<string, double> m_cachedContainerDesiredWidth = new Dictionary<string, double>();
-    private Dictionary<string, double> m_cachedContainerRealDesiredWidth = new Dictionary<string, double>();
+    private readonly Dictionary<string, double> m_cachedContainerDesiredWidth = new Dictionary<string, double>();
+    private readonly Dictionary<string, double> m_cachedContainerRealDesiredWidth = new Dictionary<string, double>();
 
-    private List<string> m_autoWidthCalculatedDataGridContextList = new List<string>();
+    private readonly List<string> m_autoWidthCalculatedDataGridContextList = new List<string>();
 
     private int m_delayedBringIntoViewIndex = -1;
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DataGridScrollViewer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DataGridScrollViewer.cs
index cbaa80a6..04cc2fcb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DataGridScrollViewer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DataGridScrollViewer.cs
@@ -46,6 +46,7 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       this.Loaded += new RoutedEventHandler( OnLoaded );
       this.Unloaded += new RoutedEventHandler( OnUnloaded );
+      m_templateHelper = new ScrollViewerTemplateHelper( this, this.DragScrollBegin, this.DragScrollEnd );
     }
 
     #endregion
@@ -153,7 +154,7 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
-        return m_horizontalScrollBar;
+        return m_templateHelper.HorizontalScrollBar;
       }
     }
 
@@ -161,7 +162,7 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
-        return m_verticalScrollBar;
+        return m_templateHelper.VerticalScrollBar;
       }
     }
 
@@ -179,57 +180,9 @@ namespace Xceed.Wpf.DataGrid.Views
       this.PopulateScrollViewerList( this, m_childScrollViewers );
       this.FindAllDeferableChildren( this, m_deferableChilds );
 
-      m_horizontalScrollBar = this.GetTemplateChild( "PART_HorizontalScrollBar" ) as ScrollBar;
-      m_verticalScrollBar = this.GetTemplateChild( "PART_VerticalScrollBar" ) as ScrollBar;
+      m_templateHelper.RefreshTemplate();
 
       this.UpdateChildScrollViewers();
-
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
-      if( dataGridContext == null )
-        return;
-
-      if( m_verticalScrollBar != null )
-      {
-        if( dataGridContext.DataGridControl.ScrollViewer != null )
-        {
-          // Assert the Template as been applied on the ScrollBar to get access to the ScrollThumb
-          if( m_verticalScrollBar.Track == null )
-            m_verticalScrollBar.ApplyTemplate();
-
-          Debug.Assert( m_verticalScrollBar.Track != null );
-
-          if( m_verticalScrollBar.Track != null )
-            m_verticalScrollThumb = m_verticalScrollBar.Track.Thumb;
-
-          if( m_verticalScrollThumb != null )
-          {
-            // Register to IsMouseCaptureChanged to know when this ScrollThumb is clicked to display the ScrollTip if required
-            m_verticalScrollThumb.IsMouseCapturedChanged += new DependencyPropertyChangedEventHandler( this.ScrollThumb_IsMouseCapturedChanged );
-          }
-        }
-      }
-
-      if( m_horizontalScrollBar != null )
-      {
-        if( dataGridContext.DataGridControl.ScrollViewer != null )
-        {
-          // Assert the Template as been applied on the ScrollBar to get access to the ScrollThumb
-          if( m_horizontalScrollBar.Track == null )
-            m_horizontalScrollBar.ApplyTemplate();
-
-          Debug.Assert( m_horizontalScrollBar.Track != null );
-
-          if( m_horizontalScrollBar.Track != null )
-            m_horizontalScrollThumb = m_horizontalScrollBar.Track.Thumb;
-
-          if( m_horizontalScrollThumb != null )
-          {
-            // Register to IsMouseCaptureChanged to know when this ScrollThumb is clicked to display the ScrollTip if required
-            m_horizontalScrollThumb.IsMouseCapturedChanged += new DependencyPropertyChangedEventHandler( this.ScrollThumb_IsMouseCapturedChanged );
-          }
-        }
-      }
     }
 
     #endregion
@@ -331,183 +284,6 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    #region GetVisibleColumn
-
-
-    internal static int GetFirstVisibleFocusableColumnIndex( DataGridContext currentDataGridContext )
-    {
-      return DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( currentDataGridContext, null );
-    }
-
-    internal static int GetFirstVisibleFocusableColumnIndex( DataGridContext currentDataGridContext, Row newRow )
-    {
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-
-      if( visibleColumnsCollection == null )
-        return -1;
-
-      int firstVisiblefocusableColumnIndex;
-      int visibleColumnsCount = visibleColumnsCollection.Count - 1;
-
-      Row currentRow = ( currentDataGridContext.CurrentRow != null ) ? currentDataGridContext.CurrentRow : newRow;
-
-      if( currentRow != null )
-      {
-        for( firstVisiblefocusableColumnIndex = 0; firstVisiblefocusableColumnIndex <= visibleColumnsCount; firstVisiblefocusableColumnIndex++ )
-        {
-          if( currentRow.Cells[ visibleColumnsCollection[ firstVisiblefocusableColumnIndex ] ].GetCalculatedCanBeCurrent() )
-          {
-            return firstVisiblefocusableColumnIndex;
-          }
-        }
-      }
-
-      return -1;
-    }
-
-    internal static int GetLastVisibleFocusableColumnIndex( DataGridContext currentDataGridContext )
-    {
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-
-      if( visibleColumnsCollection == null )
-        return -1;
-
-      int lastVisiblefocusableColumnIndex;
-      int visibleColumnsCount = visibleColumnsCollection.Count - 1;
-
-      Row currentRow = currentDataGridContext.CurrentRow;
-
-      if( currentRow != null )
-      {
-        for( lastVisiblefocusableColumnIndex = visibleColumnsCount; lastVisiblefocusableColumnIndex >= 0; lastVisiblefocusableColumnIndex-- )
-        {
-          if( currentRow.Cells[ visibleColumnsCollection[ lastVisiblefocusableColumnIndex ] ].GetCalculatedCanBeCurrent() )
-          {
-            return lastVisiblefocusableColumnIndex;
-          }
-        }
-      }
-      return -1;
-    }
-
-    internal static int GetNextVisibleFocusableColumnIndex( DataGridContext currentDataGridContext )
-    {
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
-
-      return DataGridScrollViewer.GetNextVisibleFocusableColumnIndex( currentDataGridContext, currentColumn );
-    }
-
-    internal static int GetNextVisibleFocusableColumnIndex( DataGridContext currentDataGridContext, ColumnBase currentColumn )
-    {
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-
-      if( visibleColumnsCollection == null )
-        return -1;
-
-      int visibleColumnsCollectionCount = visibleColumnsCollection.Count;
-
-      Row currentRow = currentDataGridContext.CurrentRow;
-
-      if( currentRow != null )
-      {
-        int currentColumnIndex = currentDataGridContext.VisibleColumns.IndexOf( currentColumn );
-        int NextVisibleFocusableColumnIndex;
-
-        for( NextVisibleFocusableColumnIndex = currentColumnIndex + 1; NextVisibleFocusableColumnIndex < visibleColumnsCollectionCount; NextVisibleFocusableColumnIndex++ )
-        {
-          if( currentRow.Cells[ visibleColumnsCollection[ NextVisibleFocusableColumnIndex ] ].GetCalculatedCanBeCurrent() )
-          {
-            return NextVisibleFocusableColumnIndex;
-          }
-        }
-      }
-
-      return -1;
-    }
-
-    internal static int GetPreviousVisibleFocusableColumnIndex( DataGridContext currentDataGridContext, ColumnBase currentColumn )
-    {
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-      int visibleColumnsCollectionCount = visibleColumnsCollection.Count;
-
-      if( currentColumn != null )
-      {
-        Row currentRow = currentDataGridContext.CurrentRow;
-
-        int currentColumnIndex = currentDataGridContext.VisibleColumns.IndexOf( currentColumn );
-        int previousVisibleFocusableColumnIndex;
-
-        for( previousVisibleFocusableColumnIndex = currentColumnIndex - 1; previousVisibleFocusableColumnIndex >= 0; previousVisibleFocusableColumnIndex-- )
-        {
-          if( currentRow.Cells[ visibleColumnsCollection[ previousVisibleFocusableColumnIndex ] ].GetCalculatedCanBeCurrent() )
-          {
-            return previousVisibleFocusableColumnIndex;
-          }
-        }
-      }
-      return DataGridScrollViewer.GetLastVisibleFocusableColumnIndex( currentDataGridContext );
-    }
-
-    internal static int GetPreviousVisibleFocusableColumnIndex( DataGridContext currentDataGridContext )
-    {
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
-
-      return DataGridScrollViewer.GetPreviousVisibleFocusableColumnIndex( currentDataGridContext, currentColumn );
-    }
-
-    #endregion GetVisibleColumn
-
-    internal static void ProcessHomeKey( DataGridContext dataGridContext )
-    {
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )dataGridContext.VisibleColumns;
-
-      int visibleColumnsCount = visibleColumnsCollection.Count;
-
-      // Set the CurrentColumn only if there are VisibleColumns
-      if( visibleColumnsCount > 0 )
-      {
-        int firstVisiblefocusableColumnIndex = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( dataGridContext );
-
-        if( firstVisiblefocusableColumnIndex >= 0 )
-        {
-          try
-          {
-            dataGridContext.SetCurrentColumnAndChangeSelection( visibleColumnsCollection[ firstVisiblefocusableColumnIndex ] );
-          }
-          catch( DataGridException )
-          {
-            // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-            // any other GridException.
-          }
-        }
-      }
-    }
-
-    internal static void ProcessEndKey( DataGridContext dataGridContext )
-    {
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )dataGridContext.VisibleColumns;
-      int visibleColumnsCount = visibleColumnsCollection.Count;
-
-      // Set the CurrentColumn only if there are VisibleColumns
-      if( visibleColumnsCount > 0 )
-      {
-        int lastVisiblefocusableColumnIndex = DataGridScrollViewer.GetLastVisibleFocusableColumnIndex( dataGridContext );
-
-        if( lastVisiblefocusableColumnIndex >= 0 )
-        {
-          try
-          {
-            dataGridContext.SetCurrentColumnAndChangeSelection( visibleColumnsCollection[ lastVisiblefocusableColumnIndex ] );
-          }
-          catch( DataGridException )
-          {
-            // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-            // any other GridException.
-          }
-        }
-      }
-    }
-
     #endregion
 
     #region PROTECTED METHODS
@@ -832,12 +608,13 @@ namespace Xceed.Wpf.DataGrid.Views
 
         int oldCurrentIndex = currentColumn.Index;
 
-        DataGridScrollViewer.ProcessHomeKey( dataGridContext );
-        TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
+        NavigationHelper.MoveFocusToFirstVisibleColumn( dataGridContext );
+
+        var columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManagerBase;
 
         //if the first focusable column is is within the viewport, scroll so 0d offset, otherwise, bringIntoView
         bool isFixedColumn = ( columnVirtualizationManager == null ) ?
-          false : columnVirtualizationManager.FixedFieldNames.Contains( currentColumn.FieldName );
+          false : columnVirtualizationManager.GetFixedFieldNames().Contains( currentColumn.FieldName );
 
         if( ( ( this.IsCellsOffsetNeedReset( dataGridContext ) )
           && ( oldCurrentIndex == currentColumn.Index ) )
@@ -915,7 +692,7 @@ namespace Xceed.Wpf.DataGrid.Views
       {
         int oldCurrentIndex = CurrentColumn.Index;
 
-        DataGridScrollViewer.ProcessEndKey( dataGridContext );
+        NavigationHelper.MoveFocusToLastVisibleColumn( dataGridContext );
 
         //if the last focusable column is is within the viewport, scroll to Extended offset, otherwise, bringIntoView
 
@@ -965,8 +742,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private bool IsCellsOffsetNeedReset( DataGridContext dataGridContext )
     {
-      TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
+      var columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManagerBase;
       if( columnVirtualizationManager == null )
         return false;
 
@@ -1197,39 +973,19 @@ namespace Xceed.Wpf.DataGrid.Views
       this.ClearScrollViewerList();
     }
 
-    private void ScrollThumb_IsMouseCapturedChanged( object sender, DependencyPropertyChangedEventArgs e )
+    private void DragScrollBegin( Orientation orientation )
     {
-      Thumb scrollThumb = sender as Thumb;
-
-      if( scrollThumb == null )
-        return;
-
-      if( scrollThumb.IsMouseCaptured == false )
-        return;
-
       DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
 
       if( dataGridContext == null )
         return;
 
-      // Register to LostMouseCapture to be notified when to DeferScroll
-      if( scrollThumb == m_horizontalScrollThumb )
-      {
-        m_horizontalScrollThumb.LostMouseCapture += new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
-      }
-      else if( scrollThumb == m_verticalScrollThumb )
-      {
-        m_verticalScrollThumb.LostMouseCapture += new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
-      }
-      else
-      {
-        Debug.Fail( "Unknown thumb used for scrolling." );
-        return;
-      }
-
       DataGridControl parentGridControl = dataGridContext.DataGridControl;
 
-      if( ( parentGridControl != null ) && ( parentGridControl.ItemScrollingBehavior == ItemScrollingBehavior.Deferred ) )
+      if( parentGridControl == null || dataGridContext.DataGridControl.ScrollViewer == null )
+        return;
+
+      if( parentGridControl.ItemScrollingBehavior == ItemScrollingBehavior.Deferred )
       {
         IDeferableScrollInfoRefresh panel = this.ScrollInfo as IDeferableScrollInfoRefresh;
 
@@ -1246,21 +1002,7 @@ namespace Xceed.Wpf.DataGrid.Views
             m_deferScrollInfoRefresh = null;
           }
 
-          ScrollBar scrollBar = scrollThumb.TemplatedParent as ScrollBar;
-
-          if( scrollBar == m_horizontalScrollBar )
-          {
-            m_deferScrollInfoRefresh = panel.DeferScrollInfoRefresh( Orientation.Horizontal );
-          }
-          else if( scrollBar == m_verticalScrollBar )
-          {
-            m_deferScrollInfoRefresh = panel.DeferScrollInfoRefresh( Orientation.Vertical );
-          }
-          else
-          {
-            Debug.Fail( "Unknown scroll bar used for DeferredScrolling." );
-            return;
-          }
+          m_deferScrollInfoRefresh = panel.DeferScrollInfoRefresh( orientation );
 
           if( m_deferScrollInfoRefresh != null )
           {
@@ -1273,15 +1015,8 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private void ScrollThumb_LostMouseCapture( object sender, MouseEventArgs e )
+    private void DragScrollEnd( Orientation orientation )
     {
-      Thumb scrollBarThumb = sender as Thumb;
-
-      Debug.Assert( scrollBarThumb != null );
-
-      if( scrollBarThumb != null )
-        scrollBarThumb.LostMouseCapture -= new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
-
       if( m_deferScrollInfoRefresh != null )
       {
         foreach( IDeferableScrollChanged deferable in m_deferableChilds )
@@ -1438,10 +1173,7 @@ namespace Xceed.Wpf.DataGrid.Views
     private List<SynchronizedScrollViewer> m_childScrollViewers = new List<SynchronizedScrollViewer>();
     private List<IDeferableScrollChanged> m_deferableChilds = new List<IDeferableScrollChanged>();
 
-    ScrollBar m_horizontalScrollBar; // = null
-    Thumb m_horizontalScrollThumb; // = null
-    ScrollBar m_verticalScrollBar; // = null
-    Thumb m_verticalScrollThumb; // = null
+    ScrollViewerTemplateHelper m_templateHelper;
     IDisposable m_deferScrollInfoRefresh; // = null 
     int m_measureVersion;
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DictionaryTheme.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DictionaryTheme.cs
index 31173ba9..29b100b7 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DictionaryTheme.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/DictionaryTheme.cs
@@ -15,9 +15,6 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Windows;
 
 namespace Xceed.Wpf.DataGrid.Views
@@ -30,13 +27,30 @@ namespace Xceed.Wpf.DataGrid.Views
 
     public DictionaryTheme( ResourceDictionary themeResourceDictionary )
     {
-      this.ThemeResourceDictionary = themeResourceDictionary;
+      m_themeResourceDictionary = themeResourceDictionary;
+      m_themeResourceDictionaryInitialized = true;
     }
 
+    #region ThemeResourceDictionary Property
+
     public ResourceDictionary ThemeResourceDictionary
     {
-      get;
-      set;
+      get
+      {
+        return m_themeResourceDictionary;
+      }
+      set
+      {
+        if( m_themeResourceDictionaryInitialized )
+          throw new InvalidOperationException( "An attempt was made to set the ThemeResourceDictionary property when it has already been initialized." );
+
+        m_themeResourceDictionary = value;
+      }
     }
+
+    private ResourceDictionary m_themeResourceDictionary;
+    private bool m_themeResourceDictionaryInitialized; //false
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellPanel.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellPanel.cs
index 08a77856..9583063c 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellPanel.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellPanel.cs
@@ -17,39 +17,32 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
 using System.Windows.Data;
 using System.Windows.Documents;
-using System.Windows.Media;
-using Xceed.Wpf.DataGrid.Print;
-using Xceed.Utils.Math;
-using System.Windows.Threading;
 using System.Windows.Input;
-using System.Collections.Specialized;
-using System.Windows.Controls.Primitives;
+using System.Windows.Media;
 using System.Windows.Media.Animation;
+using System.Windows.Threading;
+using Xceed.Utils.Wpf;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
-  public class FixedCellPanel : Panel, IPrintInfo, IVirtualizingCellsHost, IWeakEventListener
+  public class FixedCellPanel : Panel, IVirtualizingCellsHost, IWeakEventListener
   {
-    #region Static Fields
-
     private static readonly Point EmptyPoint = new Point();
-    private static readonly Rect PositiveInfinityRect = new Rect( new Size( Double.PositiveInfinity, Double.PositiveInfinity ) );
-
-    #endregion Static Fields
-
-    #region Constructors
 
     public FixedCellPanel()
     {
-      // None of the Visual children of the FixedCellPanel will scroll. The needed scrolling
-      // as demanded by the parent ScrollViewer will be manually transferred to the 
-      // content (m_scrollingPanel) of the ScrollingCellsDecorator below.
+      // None of the Visual children of the FixedCellPanel will scroll. The needed scrolling as demanded by the parent ScrollViewer
+      // will be manually transferred to the  content (m_scrollingPanel) of the ScrollingCellsDecorator below.
 
       m_fixedPanel = new FixedCellSubPanel( this );
 
@@ -71,24 +64,21 @@ namespace Xceed.Wpf.DataGrid.Views
 
     }
 
-    #endregion Constructors
-
     #region ColumnStretchMinWidth Property
 
     public static readonly DependencyProperty ColumnStretchMinWidthProperty = DependencyProperty.Register(
       "ColumnStretchMinWidth",
       typeof( double ),
       typeof( FixedCellPanel ),
-      new UIPropertyMetadata( 50d, new PropertyChangedCallback( FixedCellPanel.ColumnStretchMinWidthChanged ) ),
-      new ValidateValueCallback( TableView.ValidateColumnStretchMinWidthCallback ) );
-
-    private double m_columnStretchMinWidth = 50d;
+      new UIPropertyMetadata( 50d,
+        new PropertyChangedCallback( FixedCellPanel.ColumnStretchMinWidthChanged ) ),
+        new ValidateValueCallback( TableView.ValidateColumnStretchMinWidthCallback ) );
 
     public double ColumnStretchMinWidth
     {
       get
       {
-        return m_columnStretchMinWidth;
+        return ( double )this.GetValue( FixedCellPanel.ColumnStretchMinWidthProperty );
       }
       set
       {
@@ -98,20 +88,21 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private static void ColumnStretchMinWidthChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
-      FixedCellPanel panel = sender as FixedCellPanel;
-
+      var panel = sender as FixedCellPanel;
       if( panel == null )
         return;
 
-      if( e.NewValue != null )
-        panel.m_columnStretchMinWidth = ( double )e.NewValue;
+      //Do not process merged headers.  Their width is determined by their child columns.
+      if( panel.ParentRow.LevelCache != -1 )
+        return;
 
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( panel );
+      var dataGridContext = DataGridControl.GetDataGridContext( panel );
+      if( dataGridContext == null )
+        return;
 
-      if( ( dataGridContext != null ) && ( dataGridContext.VisibleColumns.Count > 0 ) )
+      if( ( dataGridContext.VisibleColumns.Count > 0 ) && !dataGridContext.IsAFlattenDetail )
       {
-        // When ColumnStretchMinWidth changes trigger an update by clearing all 
-        // DesiredWidth values.
+        // When ColumnStretchMinWidth changes trigger an update by clearing all DesiredWidth values.
         foreach( ColumnBase column in dataGridContext.VisibleColumns )
         {
           column.ClearValue( Column.DesiredWidthProperty );
@@ -127,15 +118,13 @@ namespace Xceed.Wpf.DataGrid.Views
       "ColumnStretchMode",
       typeof( ColumnStretchMode ),
       typeof( FixedCellPanel ),
-      new UIPropertyMetadata( ColumnStretchMode.None, new PropertyChangedCallback( FixedCellPanel.ColumnStretchModeChanged ) ) );
-
-    private ColumnStretchMode m_columnStretchMode = ColumnStretchMode.None;
+      new UIPropertyMetadata( ColumnStretchMode.None ) );
 
     public ColumnStretchMode ColumnStretchMode
     {
       get
       {
-        return m_columnStretchMode;
+        return ( ColumnStretchMode )this.GetValue( FixedCellPanel.ColumnStretchModeProperty );
       }
       set
       {
@@ -143,29 +132,41 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private static void ColumnStretchModeChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
+    #endregion ColumnStretchMode Property
+
+    #region DataGridContext Property
+
+    // DataGridContext is set when IVirtualizingCellsHost.PrepareCellsHost is called and cleared when IVirtualizingCellsHost.ClearContainer is called.
+    // We always use the DataGridContext passed and assert the old one is never referenced
+    internal DataGridContext DataGridContext
     {
-      FixedCellPanel panel = sender as FixedCellPanel;
+      get
+      {
+        return m_dataGridContext;
+      }
+    }
 
-      if( panel == null )
-        return;
+    #endregion
+
+    #region Columns Internal Property
 
-      if( e.NewValue != null )
-        panel.m_columnStretchMode = ( ColumnStretchMode )e.NewValue;
+    internal ColumnCollection Columns
+    {
+      get
+      {
+        return m_dataGridContext.Columns;
+      }
     }
 
-    #endregion ColumnStretchMode Property
+    #endregion
 
-    #region DataGridContext Internal Property
+    #region ColumnsByVisiblePosition Property
 
-    // DataGridContext is set when IVirtualizingCellsHost.PrepareCellsHost is called and cleared when
-    // IVirtualizingCellsHost.ClearContainer is called. We always use the DataGridContext passed
-    // and assert the old one is never referenced
-    internal DataGridContext DataGridContext
+    internal HashedLinkedList<ColumnBase> ColumnsByVisiblePosition
     {
       get
       {
-        return m_dataGridContext;
+        return m_dataGridContext.ColumnsByVisiblePosition;
       }
     }
 
@@ -177,16 +178,16 @@ namespace Xceed.Wpf.DataGrid.Views
       "FixedCellCount",
       typeof( int ),
       typeof( FixedCellPanel ),
-      new UIPropertyMetadata( 0, new PropertyChangedCallback( FixedCellPanel.FixedCellCountChanged ) ),
-      new ValidateValueCallback( FixedCellPanel.ValidateFixedCellCountCallback ) );
-
-    private int m_fixedCellCount; // = 0;
+      new UIPropertyMetadata(
+        0,
+        new PropertyChangedCallback( FixedCellPanel.FixedCellCountChanged ) ),
+        new ValidateValueCallback( FixedCellPanel.ValidateFixedCellCountCallback ) );
 
     public int FixedCellCount
     {
       get
       {
-        return m_fixedCellCount;
+        return ( int )this.GetValue( FixedCellPanel.FixedCellCountProperty );
       }
       set
       {
@@ -197,13 +198,9 @@ namespace Xceed.Wpf.DataGrid.Views
     private static void FixedCellCountChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
       FixedCellPanel panel = sender as FixedCellPanel;
-
       if( panel == null )
         return;
 
-      if( e.NewValue != null )
-        panel.m_fixedCellCount = ( int )e.NewValue;
-
       // Invalidate the measure to force a layout pass
       panel.InvalidateMeasure();
     }
@@ -229,26 +226,17 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region FixedColumnDropMarkPen Property
 
-    public static readonly DependencyProperty FixedColumnDropMarkPenProperty =
-        DependencyProperty.Register( "FixedColumnDropMarkPen", typeof( Pen ), typeof( FixedCellPanel ), new PropertyMetadata( new PropertyChangedCallback( FixedCellPanel.OnFixedColumnDropMarkPenChanged ) ) );
-
-    private Pen m_fixedColumnDropMarkPen;
-
-    private static void OnFixedColumnDropMarkPenChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
-    {
-      FixedCellPanel panel = o as FixedCellPanel;
-
-      if( panel == null )
-        return;
-
-      panel.m_fixedColumnDropMarkPen = e.NewValue as Pen;
-    }
+    public static readonly DependencyProperty FixedColumnDropMarkPenProperty = DependencyProperty.Register(
+      "FixedColumnDropMarkPen",
+      typeof( Pen ),
+      typeof( FixedCellPanel ),
+      new PropertyMetadata( null ) );
 
     public Pen FixedColumnDropMarkPen
     {
       get
       {
-        return m_fixedColumnDropMarkPen;
+        return ( Pen )this.GetValue( FixedCellPanel.FixedColumnDropMarkPenProperty );
       }
       set
       {
@@ -266,7 +254,6 @@ namespace Xceed.Wpf.DataGrid.Views
       {
         if( m_parentRow == null )
         {
-          Debug.Assert( this.DataGridContext != null );
           m_parentRow = Row.FindFromChild( this.DataGridContext, this );
         }
 
@@ -330,33 +317,37 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #endregion
 
-    #region CellsHostPrepared Private Property
+    #region ColumnVirtualizationManager Internal Property
 
-    private bool CellsHostPrepared
+    internal TableViewColumnVirtualizationManagerBase ColumnVirtualizationManager
     {
       get
       {
-        return m_flags[ ( int )FixedCellPanelFlags.CellsHostPrepared ];
-      }
-      set
-      {
-        m_flags[ ( int )FixedCellPanelFlags.CellsHostPrepared ] = value;
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return null;
+
+        var columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManagerBase;
+        if( columnVirtualizationManager == null )
+          throw new DataGridInternalException( "Invalid ColumnVirtualizationManager for FixedCellPanel", dataGridContext.DataGridControl );
+
+        return columnVirtualizationManager;
       }
     }
 
     #endregion
 
-    #region NeedToClearAllCreatedCells Private Property
+    #region CellsHostPrepared Private Property
 
-    private bool NeedToClearAllCreatedCells
+    private bool CellsHostPrepared
     {
       get
       {
-        return m_flags[ ( int )FixedCellPanelFlags.NeedToClearAllCreatedCells ];
+        return m_flags[ ( int )FixedCellPanelFlags.CellsHostPrepared ];
       }
       set
       {
-        m_flags[ ( int )FixedCellPanelFlags.NeedToClearAllCreatedCells ] = value;
+        m_flags[ ( int )FixedCellPanelFlags.CellsHostPrepared ] = value;
       }
     }
 
@@ -440,11 +431,34 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
-        VirtualizingCellCollection cellCollection = this.ParentRowCells;
-        if( cellCollection == null )
+        VirtualizingCellCollection virtualizingCellCollection = this.ParentRowCells;
+        if( virtualizingCellCollection == null )
           return new Cell[ 0 ];
 
-        return cellCollection.BindedCells;
+        TableViewColumnVirtualizationManagerBase columnVirtualizationManager = this.ColumnVirtualizationManager;
+        if( columnVirtualizationManager == null )
+          return new Cell[ 0 ];
+
+        List<Cell> cells = new List<Cell>();
+        Cell cell;
+
+        foreach( string fieldName in columnVirtualizationManager.GetFixedFieldNames( m_parentRow.LevelCache ) )
+        {
+          if( virtualizingCellCollection.TryGetBindedCell( fieldName, out cell ) )
+          {
+            cells.Add( cell );
+          }
+        }
+
+        foreach( string fieldName in columnVirtualizationManager.GetScrollingFieldNames( m_parentRow.LevelCache ) )
+        {
+          if( virtualizingCellCollection.TryGetBindedCell( fieldName, out cell ) )
+          {
+            cells.Add( cell );
+          }
+        }
+
+        return cells;
       }
     }
 
@@ -462,46 +476,28 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void AddPermanentScrollingFieldNames( string fieldName )
     {
-      if( string.IsNullOrEmpty( fieldName ) )
+      if( string.IsNullOrEmpty( fieldName ) || m_permanentScrollingFieldNames.Contains( fieldName ) )
         return;
 
-      if( !m_permanentScrollingFieldNames.Contains( fieldName ) )
-      {
-        m_permanentScrollingFieldNames.Add( fieldName );
-      }
+      m_permanentScrollingFieldNames.Add( fieldName );
     }
 
     private bool AddPermanentScrollingFieldNamesIfOutOfViewColumn( string fieldName )
     {
-      bool retVal = false;
-
-      if( string.IsNullOrEmpty( fieldName ) )
-        return retVal;
+      if( string.IsNullOrEmpty( fieldName ) || m_permanentScrollingFieldNames.Contains( fieldName ) )
+        return false;
 
-      if( this.DataGridContext == null )
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
+      if( columnVirtualizationManager != null )
       {
-        if( !m_permanentScrollingFieldNames.Contains( fieldName ) )
-        {
-          m_permanentScrollingFieldNames.Add( fieldName );
-          retVal = true;
-        }
-
-        return retVal;
+        if( columnVirtualizationManager.GetFixedFieldNames( m_parentRow.LevelCache ).Contains( fieldName )
+          || columnVirtualizationManager.GetScrollingFieldNames( m_parentRow.LevelCache ).Contains( fieldName ) )
+          return false;
       }
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager = this.DataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
+      m_permanentScrollingFieldNames.Add( fieldName );
 
-      if( columnVirtualizationManager == null )
-        throw new DataGridInternalException();
-
-      if( !m_permanentScrollingFieldNames.Contains( fieldName ) && !columnVirtualizationManager.FixedFieldNames.Contains( fieldName )
-        && !columnVirtualizationManager.ScrollingFieldNames.Contains( fieldName ) )
-      {
-        m_permanentScrollingFieldNames.Add( fieldName );
-        retVal = true;
-      }
-
-      return retVal;
+      return true;
     }
 
     private void ClearPermanentScrollingFieldNames()
@@ -510,18 +506,18 @@ namespace Xceed.Wpf.DataGrid.Views
       m_permanentScrollingFieldNames.TrimExcess();
     }
 
-    private readonly HashSet<string> m_permanentScrollingFieldNames = new HashSet<string>();
+    private readonly List<string> m_permanentScrollingFieldNames = new List<string>( 0 );
 
     #endregion
 
     protected override Visual GetVisualChild( int index )
     {
       if( this.ZOrderDirty )
+      {
         this.RecomputeZOrder();
+      }
 
-      int correctedIndex = ( m_zIndexMapping == null )
-      ? index
-      : m_zIndexMapping[ index ];
+      int correctedIndex = ( m_zIndexMapping == null ) ? index : m_zIndexMapping[ index ];
 
       switch( correctedIndex )
       {
@@ -532,7 +528,9 @@ namespace Xceed.Wpf.DataGrid.Views
         case 2:
           return m_scrollingCellsDecorator;
         default:
-          throw new ArgumentOutOfRangeException( "index" );
+          DataGridException.ThrowSystemException( "Invalid visual child index.", typeof( IndexOutOfRangeException ), this.DataGridContext.DataGridControl.Name );
+          //Simply there to remove compiling error
+          return null;
       }
     }
 
@@ -549,16 +547,10 @@ namespace Xceed.Wpf.DataGrid.Views
       if( dataGridContext == null )
         return this.DesiredSize;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager =
-        dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-      if( columnVirtualizationManager == null )
-        throw new DataGridInternalException();
-
       this.ApplyFixedTranform();
 
-      // If a change occured and did not triggered an UpdateMeasureRequiredEvent by the
-      // columnVirtualizationManager, we ensure the Row contains the necessary Cells
+      // If a change occured and did not triggered an UpdateMeasureRequiredEvent by the columnVirtualizationManager, we ensure the Row contains the necessary Cells
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
       if( m_lastColumnVirtualizationManagerVersion != columnVirtualizationManager.Version )
       {
         this.UpdateChildren();
@@ -570,30 +562,29 @@ namespace Xceed.Wpf.DataGrid.Views
       // Measure the Splitter
       m_splitter.Measure( availableSize );
 
-      // Measure the Panels (visual children) around the cells (logical children).
-      // Logical children will not be measured again during this process.
+      // Measure the Panels (visual children) around the cells (logical children).  Logical children will not be measured again during this process.
       m_fixedPanel.Measure( availableSize );
 
       if( m_fixedPanel.DesiredSize.Height > tempDesiredHeight )
+      {
         tempDesiredHeight = m_fixedPanel.DesiredSize.Height;
+      }
 
-      // Set the desired size for m_scrollingPanel which will be passed to the 
-      // Decorated that will allow the first cell to be clipped
-      m_desiredSize.Width += columnVirtualizationManager.VisibleColumnsTotalWidth;
+      // Set the desired size for m_scrollingPanel which will be passed to the Decorated that will allow the first cell to be clipped
+      m_desiredSize.Width += columnVirtualizationManager.VisibleColumnsWidth;
 
       m_scrollingCellsDecorator.Measure( availableSize );
 
       if( m_scrollingCellsDecorator.DesiredSize.Height > tempDesiredHeight )
+      {
         tempDesiredHeight = m_scrollingCellsDecorator.DesiredSize.Height;
+      }
 
       m_desiredSize.Height = tempDesiredHeight;
 
-      if( !double.IsPositiveInfinity( availableSize.Width ) )
+      if( !double.IsPositiveInfinity( availableSize.Width ) && !dataGridContext.IsAFlattenDetail )
       {
-        dataGridContext.ColumnStretchingManager.CalculateColumnStretchWidths(
-          availableSize.Width,
-          this.ColumnStretchMode,
-          this.ColumnStretchMinWidth );
+        dataGridContext.ColumnStretchingManager.CalculateColumnStretchWidths( availableSize.Width, this.ColumnStretchMode, this.ColumnStretchMinWidth );
       }
 
       // Adjust TabIndex of fixed cell and scrolling cell for the tab navigation to be ok
@@ -608,10 +599,8 @@ namespace Xceed.Wpf.DataGrid.Views
       if( this.DataGridContext == null )
         return this.DesiredSize;
 
-      // Very simple horizontally Arrange implementation
-      // We use m_visualChildren instead of GetVisualChild(index)
-      // to ensure the sub panels are always arranged in the 
-      // correct visible order
+      // Very simple horizontally Arrange implementation.  We use m_visualChildren instead of GetVisualChild(index)
+      // to ensure the sub panels are always arranged in the  correct visible order
       int childrenCount = m_visualChildren.Count;
       Rect finalRect = new Rect( finalSize );
       double offset = 0d;
@@ -636,13 +625,13 @@ namespace Xceed.Wpf.DataGrid.Views
     }
 
     // Returns the visible index of a column by its visible position
-    internal static int CalculateVisibleIndex( int visiblePosition, DataGridContext dataGridContext )
+    internal static int CalculateVisibleIndex( int visiblePosition, HashedLinkedList<ColumnBase> columnsByVisiblePosition )
     {
-      if( dataGridContext == null )
+      if( columnsByVisiblePosition == null )
         return -1;
 
       int visibleIndex = 0;
-      LinkedListNode<ColumnBase> tempNode = dataGridContext.ColumnsByVisiblePosition.First;
+      LinkedListNode<ColumnBase> tempNode = columnsByVisiblePosition.First;
 
       for( int i = 0; i < visiblePosition; i++ )
       {
@@ -650,7 +639,9 @@ namespace Xceed.Wpf.DataGrid.Views
           break;
 
         if( tempNode.Value.Visible )
+        {
           visibleIndex++;
+        }
 
         tempNode = tempNode.Next;
       }
@@ -660,9 +651,8 @@ namespace Xceed.Wpf.DataGrid.Views
 
     internal double GetFixedWidth()
     {
-      double offset = VisualTreeHelper.GetOffset( m_scrollingCellsDecorator ).X;
-
-      DependencyObject parent = VisualTreeHelper.GetParent( this );
+      var offset = VisualTreeHelper.GetOffset( m_scrollingCellsDecorator ).X;
+      var parent = VisualTreeHelper.GetParent( this );
 
       while( parent != null )
       {
@@ -681,7 +671,9 @@ namespace Xceed.Wpf.DataGrid.Views
     internal ScrollViewer GetParentScrollViewer()
     {
       if( m_parentScrollViewer == null )
+      {
         m_parentScrollViewer = TableViewScrollViewer.GetParentScrollViewer( this );
+      }
 
       return m_parentScrollViewer;
     }
@@ -726,31 +718,28 @@ namespace Xceed.Wpf.DataGrid.Views
       return ( cell != null )
           && ( dataGridContext != null )
           && ( cell.CanBeRecycled )
-          && ( !cell.HasCellEditorError )
           && ( cell != dataGridContext.CurrentCell )
           && ( !Row.GetIsTemplateCell( cell ) )
-          && ( !TableflowView.GetIsBeingDraggedAnimated( cell.ParentColumn ) )
+          && ( ( cell.ParentColumn == null ) || ( !TableflowView.GetIsBeingDraggedAnimated( cell.ParentColumn ) ) )
           && ( !( bool )cell.GetValue( ColumnManagerCell.IsBeingDraggedProperty ) );
     }
 
-    private static void ClearCellVisualState( Cell cell )
+    private void AddCellToVisualTree( Cell cellToAdd )
     {
-      if( cell == null )
+      if( cellToAdd == null )
         return;
 
-      ContextMenu contextMenu = cell.ContextMenu;
+      UIElementCollection scrollingChildren = m_scrollingPanel.Children;
 
-      // Ensure to close the ContextMenu if it is open and the Cell
-      // is virtualized to avoid problems with ContextMenus
-      // defined as static resources that won't be able to reopen
-      // again if the Close private method is called after the 
-      // PlacementTarget is removed from the VisualTree
-      if( ( contextMenu != null ) && ( contextMenu.IsOpen ) )
-      {
-        contextMenu.IsOpen = false;
-      }
+      if( scrollingChildren.Contains( cellToAdd ) )
+        return;
+
+      UIElementCollection fixedChildren = m_fixedPanel.Children;
+
+      if( m_fixedPanel.Children.Contains( cellToAdd ) )
+        return;
 
-      cell.ClearContainerVisualState();
+      scrollingChildren.Add( cellToAdd );
     }
 
     private void MoveCellToFixedPanel( Cell movingCell )
@@ -770,7 +759,7 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private bool MoveCellToScrollingPanel( Cell movingCell, bool release = false )
+    private bool MoveCellToScrollingPanel( Cell movingCell )
     {
       bool retVal = false;
 
@@ -789,12 +778,6 @@ namespace Xceed.Wpf.DataGrid.Views
         retVal = true;
       }
 
-      if( release )
-      {
-        FixedCellPanel.ClearCellVisualState( movingCell );
-        retVal = true;
-      }
-
       return retVal;
     }
 
@@ -821,6 +804,22 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
+    private int GetCurrentLevelDropPoint( ColumnBase parentColumn, bool isPassedHalfWidth )
+    {
+      string dummystring;
+      return this.GetCurrentLevelDropPoint( parentColumn, isPassedHalfWidth, out dummystring );
+    }
+
+    private int GetCurrentLevelDropPoint( ColumnBase parentColumn, bool isPassedHalfWidth, out string offsetCellFieldName )
+    {
+      offsetCellFieldName = parentColumn.FieldName;
+
+      if( isPassedHalfWidth )
+        return parentColumn.VisiblePosition + 1;
+
+      return parentColumn.VisiblePosition;
+    }
+
     private void UpdateChildren()
     {
       this.UpdateChildren( UpdateMeasureTriggeredAction.Unspecified );
@@ -842,12 +841,8 @@ namespace Xceed.Wpf.DataGrid.Views
       if( dataGridContext == null )
         return;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-      if( columnVirtualizationManager == null )
-        throw new DataGridInternalException();
-
       bool currentItemChangedOnCurrentRow = ( action == UpdateMeasureTriggeredAction.CurrentItemChanged ) && ( parentRow != null ) && ( parentRow.IsCurrent );
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
 
       if( ( m_lastColumnVirtualizationManagerVersion != columnVirtualizationManager.Version ) || ( currentItemChangedOnCurrentRow )
             || ( m_virtualizingCellCollectionChangedDispatcherOperation != null ) )
@@ -862,100 +857,85 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private void UpdateChildren( DataGridContext dataGridContext, TableViewColumnVirtualizationManager columnVirtualizationManager, VirtualizingCellCollection parentRowCells )
+    private void UpdateChildren( DataGridContext dataGridContext, TableViewColumnVirtualizationManagerBase columnVirtualizationManager, VirtualizingCellCollection parentRowCells )
     {
       //Prevent reentrance
-      if( m_parentRowCells.AlreadyUpdating )
+      if( ( parentRowCells == null ) || m_parentRowCells.IsUpdating )
         return;
 
-      m_parentRowCells.AlreadyUpdating = true;
-
-      if( dataGridContext == null )
-        throw new DataGridInternalException( "DataGridContext is null for FixedCellPanel" );
-
-      if( columnVirtualizationManager == null )
-        throw new DataGridInternalException( "ColumnVirtualizationManager is null for FixedCellPanel" );
-
-      if( parentRowCells == null )
-        return;
+      using( m_parentRowCells.SetIsUpdating() )
+      {
+        this.ClearPermanentScrollingFieldNames();
 
-      this.ClearPermanentScrollingFieldNames();
+        //Retrieve the cells that aren't needed anymore.
+        var unusedCells = ( from cell in parentRowCells.BindedCells
+                            where !columnVirtualizationManager.GetScrollingFieldNames( m_parentRow.LevelCache ).Contains( cell.FieldName )
+                               && !columnVirtualizationManager.GetFixedFieldNames( m_parentRow.LevelCache ).Contains( cell.FieldName )
+                            select cell ).ToList();
 
-      List<string> currentFieldsName = new List<string>();
-      currentFieldsName.AddRange( columnVirtualizationManager.FixedFieldNames );
-      currentFieldsName.AddRange( columnVirtualizationManager.ScrollingFieldNames );
+        //Release the unused binded cells now in order to minimize the number of cell's creation.
+        foreach( Cell cell in unusedCells )
+        {
+          this.AddCellToVisualTree( cell );
 
-      HashSet<Cell> unusedCells = new HashSet<Cell>( parentRowCells.BindedCells );
+          if( this.CanReleaseCell( cell ) )
+          {
+            // Ensure to close the ContextMenu if it is open and the Cell is virtualized to avoid problems with ContextMenus defined as static resources
+            // that won't be able to reopen again if the Close private method is called after the PlacementTarget is removed from the VisualTree
+            var contextMenu = cell.ContextMenu;
+            if( ( contextMenu != null ) && ( contextMenu.IsOpen ) )
+            {
+              contextMenu.IsOpen = false;
+            }
 
-      //Idenfity the binded cells that aren't needed anymore.
-      foreach( string fieldName in currentFieldsName )
-      {
-        ColumnBase column = dataGridContext.Columns[ fieldName ];
-        Cell cell;
+            cell.ClearContainer();
+            parentRowCells.Release( cell );
+          }
+          //Since the cell cannot be released, it will not be collapsed. We must keep the field
+          //name in order to let the scrolling sub-panel measure and arrange the cell out of view.
+          else
+          {
+            //Certain non recyclable cells like StatCells needs their content binding to be removed when they become out of view.
+            cell.RemoveContentBinding();
+            this.AddPermanentScrollingFieldNames( cell.FieldName );
+          }
+        }
 
-        if( parentRowCells.TryGetCell( column, out cell ) )
+        //Add the missing cells to the fixed region.
+        foreach( string fieldName in columnVirtualizationManager.GetFixedFieldNames( m_parentRow.LevelCache ) )
         {
+          //The cell is created if it is missing.
+          Cell cell = parentRowCells[ fieldName ];
+
           //Certain non recyclable cells like StatCells need their content binding to be updated when they become (or stay) in view.
-          cell.AddContentBinding();
-          unusedCells.Remove( cell );
+          cell.AddContentBinding( dataGridContext, this.ParentRow, this.Columns[ cell.FieldName ] );
+
+          //Make sure the cell is in the appropriate panel.
+          this.MoveCellToFixedPanel( cell );
         }
-      }
-      currentFieldsName.Clear();
-      currentFieldsName.TrimExcess();
 
-      //Release the unused binded cells now in order to minimize the number of cell's creation.
-      foreach( Cell cell in unusedCells )
-      {
-        bool release = this.CanReleaseCell( cell );
+        //Add the missing cells to the scrolling region.
+        foreach( string fieldName in columnVirtualizationManager.GetScrollingFieldNames( m_parentRow.LevelCache ) )
+        {
+          //The cell is created if it is missing.
+          Cell cell = parentRowCells[ fieldName ];
 
-        //We move the unused cell into the scrolling panel since there is more chance it will be reused there in the future.
-        this.MoveCellToScrollingPanel( cell, release );
+          //Certain non recyclable cells like StatCells need their content binding to be updated when they become (or stay) in view.
+          cell.AddContentBinding( dataGridContext, this.ParentRow, this.Columns[ cell.FieldName ] );
 
-        if( release )
-        {
-          parentRowCells.Release( cell );
+          //Make sure the cell is in the appropriate panel.
+          this.MoveCellToScrollingPanel( cell );
         }
-        //Since the cell cannot be released, it will not be collapsed. We must keep the field name in order to let the scrolling sub-panel measure and arrange the cell out of view.
-        else
+
+        if( m_clearUnusedCellsDispatcherOperation == null )
         {
-          //Certain non recyclable cells like StatCells needs their content binding to be removed when they become out of view.
-          cell.RemoveContentBinding();
-          this.AddPermanentScrollingFieldNames( cell.FieldName );
+          m_clearUnusedCellsDispatcherOperation = this.Dispatcher.BeginInvoke( new Action( this.ClearUnusedCells ), DispatcherPriority.ApplicationIdle );
         }
-      }
-      unusedCells.Clear();
-      unusedCells.TrimExcess();
-
-      //Add the missing cells to the fixed region.
-      foreach( string fieldName in columnVirtualizationManager.FixedFieldNames )
-      {
-        //The cell is created if it is missing.
-        Cell cell = parentRowCells[ fieldName ];
 
-        //Make sure the cell is in the appropriate panel.
-        this.MoveCellToFixedPanel( cell );
+        m_fixedPanel.InvalidateMeasure();
+        m_scrollingCellsDecorator.InvalidateMeasure();
+        m_scrollingPanel.InvalidateMeasure();
       }
-
-      //Add the missing cells to the scrolling region.
-      foreach( string fieldName in columnVirtualizationManager.ScrollingFieldNames )
-      {
-        //The cell is created if it is missing.
-        Cell cell = parentRowCells[ fieldName ];
-
-        //Make sure the cell is in the appropriate panel.
-        this.MoveCellToScrollingPanel( cell );
-      }
-
-      if( m_clearUnusedCellsDispatcherOperation == null )
-      {
-        m_clearUnusedCellsDispatcherOperation = this.Dispatcher.BeginInvoke( new Action( this.ClearUnusedCells ), DispatcherPriority.ApplicationIdle );
-      }
-
-      m_fixedPanel.InvalidateMeasure();
-      m_scrollingCellsDecorator.InvalidateMeasure();
-      m_scrollingPanel.InvalidateMeasure();
-
-      m_parentRowCells.AlreadyUpdating = false;
     }
 
     private void ApplyFixedTranform()
@@ -978,52 +958,33 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private void AdjustCellTabIndex( TableViewColumnVirtualizationManager columnVirtualizationManager )
+    private void AdjustCellTabIndex( TableViewColumnVirtualizationManagerBase columnVirtualizationManager )
     {
-      // The order of the children in the panel is not guaranteed to be good.  We do not
-      // reorder children because we will have to remove and add them at a different location.
-      // Doing that will cause more calculations to occur, so we only change the TabIndex.
+      // The order of the children in the panel is not guaranteed to be good.  We do not reorder children because we will have to remove
+      // and add them at a different location.  Doing that will cause more calculations to occur, so we only change the TabIndex.
       VirtualizingCellCollection collection = this.ParentRowCells;
       if( collection == null )
         return;
 
-      HashSet<string> bindedFields = new HashSet<string>();
-      foreach( Cell cell in collection.BindedCells )
-      {
-        bindedFields.Add( cell.FieldName );
-        this.AdjustCellTabIndex( columnVirtualizationManager, cell );
-      }
-
-      List<string> targetFields = new List<string>();
-      targetFields.AddRange( columnVirtualizationManager.FixedFieldNames );
-      targetFields.AddRange( columnVirtualizationManager.ScrollingFieldNames );
-      targetFields.AddRange( m_permanentScrollingFieldNames );
+      var fieldNameToPositionMapping = columnVirtualizationManager.GetFieldNameToPosition( m_parentRow.LevelCache );
+      var fieldNames = columnVirtualizationManager.GetFixedFieldNames( m_parentRow.LevelCache )
+                         .Concat( columnVirtualizationManager.GetScrollingFieldNames( m_parentRow.LevelCache ) )
+                         .Concat( m_permanentScrollingFieldNames );
 
-      foreach( string fieldName in targetFields )
+      foreach( var fieldName in fieldNames )
       {
-        if( bindedFields.Contains( fieldName ) )
-          continue;
-
-        Cell cell = collection[ fieldName ];
+        Cell cell = collection.GetCell( fieldName, false );
         Debug.Assert( cell != null );
 
-        this.AdjustCellTabIndex( columnVirtualizationManager, cell );
-      }
-    }
-
-    private void AdjustCellTabIndex( TableViewColumnVirtualizationManager columnVirtualizationManager, Cell targetCell )
-    {
-      int tabIndex;
-      if( columnVirtualizationManager.FieldNameToPosition.TryGetValue( targetCell.FieldName, out tabIndex ) )
-      {
-        if( tabIndex != KeyboardNavigation.GetTabIndex( targetCell ) )
+        int tabIndex;
+        if( fieldNameToPositionMapping.TryGetValue( fieldName, out tabIndex ) )
         {
-          KeyboardNavigation.SetTabIndex( targetCell, tabIndex );
+          KeyboardNavigation.SetTabIndex( cell, tabIndex );
+        }
+        else
+        {
+          cell.ClearValue( Cell.TabIndexProperty );
         }
-      }
-      else
-      {
-        targetCell.ClearValue( Cell.TabIndexProperty );
       }
     }
 
@@ -1043,12 +1004,32 @@ namespace Xceed.Wpf.DataGrid.Views
         return;
 
       //Remove the recycling bins that aren't used anymore.
-      parentRowCells.ClearUnusedRecycleBins( dataGridContext.Columns );
+      parentRowCells.ClearUnusedRecycleBins( this.Columns );
 
       //Remove the inaccessible cells from the panels.
       this.RemoveLeakingCells( parentRowCells.Cells );
     }
 
+    private FrameworkElement GetPreparedContainer( Cell cell )
+    {
+      if( cell == null )
+        return null;
+
+      var parentRow = cell.ParentRow;
+      if( parentRow == null )
+        return null;
+
+      // Use the DataGridControl.Container attached property to assert a container is always returned even if the container is in FixedHeaders or FixedFooters.
+      var container = DataGridControl.GetContainer( parentRow );
+      if( container == null )
+        return null;
+
+      if( !DataGridControl.GetIsContainerPrepared( container ) )
+        return null;
+
+      return container;
+    }
+
     #region ZOrder Management
 
     private void RecomputeZOrder()
@@ -1068,8 +1049,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
       UIElement panelToChangeZOrder = null;
 
-      // Ensure the ZOrder is also considered
-      // by the panel containing the Cell
+      // Ensure the ZOrder is also considered by the panel containing the Cell
       if( m_fixedPanel.Children.Contains( cell ) )
       {
         panelToChangeZOrder = m_fixedPanel;
@@ -1100,7 +1080,6 @@ namespace Xceed.Wpf.DataGrid.Views
         }
       }
 
-
       Panel.SetZIndex( cell, zIndex );
 
       return zOrderChanged;
@@ -1116,36 +1095,6 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #endregion ZOrder Management
 
-    #region IPrintInfo Members
-
-    double IPrintInfo.GetPageRightOffset( double horizontalOffset, double viewportWidth )
-    {
-      double nonScrollingWidth = ( ( FixedCellPanel )this ).GetFixedWidth();
-
-      IPrintInfo printInfo = m_scrollingPanel as IPrintInfo;
-
-      return printInfo.GetPageRightOffset( horizontalOffset, viewportWidth - nonScrollingWidth );
-    }
-
-    void IPrintInfo.UpdateElementVisibility( double horizontalOffset, double viewportWidth, object state )
-    {
-      double nonScrollingWidth = ( ( FixedCellPanel )this ).GetFixedWidth();
-
-      IPrintInfo printInfo = m_scrollingPanel as IPrintInfo;
-      double compensationOffset = TableView.GetCompensationOffset( this );
-
-      printInfo.UpdateElementVisibility( horizontalOffset - compensationOffset, viewportWidth - nonScrollingWidth, state );
-    }
-
-    object IPrintInfo.CreateElementVisibilityState()
-    {
-      IPrintInfo printInfo = m_scrollingPanel as IPrintInfo;
-
-      return printInfo.CreateElementVisibilityState();
-    }
-
-    #endregion
-
     #region IVirtualizingCellsHost Members
 
     bool IVirtualizingCellsHost.CanModifyLogicalParent
@@ -1171,41 +1120,27 @@ namespace Xceed.Wpf.DataGrid.Views
 
     void IVirtualizingCellsHost.PrepareCellsHost( DataGridContext dataGridContext )
     {
-      // This method is called in Row.PrepareContainer and Row.OnApplyTemplate, which is also 
-      // called in Row.PrepareContainer but only if the template was not previously applied, so 
-      // it is possible that this panel is already prepared. In that case, we only ignore this preparation.
+      // This method is called in Row.PrepareContainer and Row.OnApplyTemplate, which is also called in Row.PrepareContainer but only if the template
+      // was not previously applied, so it is possible that this panel is already prepared. In that case, we only ignore this preparation.
       if( this.CellsHostPrepared )
         return;
 
-      Debug.Assert( ( this.DataGridContext == null ) || ( dataGridContext == this.DataGridContext ),
-        "DataGridContext must be null otherwise this indicates that the FixedCellPanel was not cleaned properly before it is prepared again." );
-
-      m_dataGridContext = dataGridContext;
-
       if( dataGridContext != null )
       {
-        object dataItem = this.ParentRow.DataContext;
+        m_dataGridContext = dataGridContext;
 
-        // We will clear every created Cells when ClearContainer will be called
-        // since some Cells may have been virtualized or prepared, but still
-        // have some invalid states from previous data item when the data item 
-        // is the current item in edition when the container is prepared
-        this.NeedToClearAllCreatedCells = ( dataGridContext.DataGridControl.CurrentItemInEdition == dataItem );
+        object dataItem = this.ParentRow.DataContext;
 
         foreach( Cell cell in this.CellsInView )
         {
           cell.PrepareContainer( dataGridContext, dataItem );
         }
 
-        TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-        if( columnVirtualizationManager != null )
-        {
-          UpdateMeasureRequiredEventManager.AddListener( columnVirtualizationManager, this );
-        }
+        TableViewColumnVirtualizationManagerBase columnVirtualizationManager = this.ColumnVirtualizationManager;
+        UpdateMeasureRequiredEventManager.AddListener( columnVirtualizationManager, this );
+        m_previousColumnVirualizationManager = columnVirtualizationManager;
 
         VirtualizingCellCollection parentRowCells = this.ParentRowCells;
-
         if( parentRowCells != null )
         {
           VirtualizingCellCollectionChangedEventManager.AddListener( parentRowCells, this );
@@ -1217,27 +1152,22 @@ namespace Xceed.Wpf.DataGrid.Views
 
     void IVirtualizingCellsHost.ClearCellsHost()
     {
-      if( m_dataGridContext != null )
-      {
-        TableViewColumnVirtualizationManager columnVirtualizationManager = m_dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-        if( columnVirtualizationManager != null )
-        {
-          UpdateMeasureRequiredEventManager.RemoveListener( columnVirtualizationManager, this );
-          this.CellsHostPrepared = false;
-        }
-
-        VirtualizingCellCollection parentRowCells = this.ParentRowCells;
+      if( !this.CellsHostPrepared )
+        return;
 
-        if( parentRowCells != null )
-        {
-          VirtualizingCellCollectionChangedEventManager.RemoveListener( parentRowCells, this );
-        }
+      VirtualizingCellCollection parentRowCells = this.ParentRowCells;
+      if( parentRowCells != null )
+      {
+        VirtualizingCellCollectionChangedEventManager.RemoveListener( parentRowCells, this );
       }
 
-      Debug.Assert( !this.CellsHostPrepared, "Should always be unregistered from DataGridContext.ColumnVirtualizationManager" );
+      //Make sure to stop listening from the same manager to which it started to listen.
+      UpdateMeasureRequiredEventManager.RemoveListener( m_previousColumnVirualizationManager, this );
+      m_previousColumnVirualizationManager = null;
 
       m_dataGridContext = null;
+
+      this.CellsHostPrepared = false;
     }
 
     void IVirtualizingCellsHost.InvalidateCellsHostMeasure()
@@ -1251,124 +1181,125 @@ namespace Xceed.Wpf.DataGrid.Views
       m_scrollingPanel.InvalidateMeasure();
     }
 
-    bool IVirtualizingCellsHost.BringIntoView( Cell cell )
+    bool IVirtualizingCellsHost.BringIntoView( Cell cell, RequestBringIntoViewEventArgs e )
     {
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
+      // This cell doesn't seem to be in the grid.  We return true to handle the event that triggered the BringIntoView.
+      var dataGridContext = DataGridControl.GetDataGridContext( this );
       if( dataGridContext == null )
-        return false;
+        return true;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-      if( columnVirtualizationManager == null )
-        return false;
+      // If the container is not in use, we return true to handle the event that triggered the BringIntoView.
+      var container = this.GetPreparedContainer( cell );
+      if( container == null )
+        return true;
 
-      Rect cellRect = new Rect();
-      cellRect.Width = cell.ParentColumn.Width;
-      cellRect.Height = cell.ActualHeight;
+      // The ScrollViewer can handle the bring into view if the grid isn't virtualized.
+      var scrollViewer = this.ParentScrollViewer;
+      if( ( scrollViewer == null ) || !scrollViewer.CanContentScroll )
+        return false;
 
-      string targetFieldName = cell.FieldName;
-      DataGridItemsHost itemsHost = dataGridContext.DataGridControl.ItemsHost as DataGridItemsHost;
+      // This cell seems to be dead.  We return true to handle the event that triggered the BringIntoView.
+      var row = cell.ParentRow;
+      var column = cell.ParentColumn;
+      if( ( row == null ) || ( column == null ) )
+        return true;
 
-      IScrollInfo scrollInfo = itemsHost as IScrollInfo;
-      Debug.Assert( scrollInfo != null );
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
 
-      // Fixed Cells are always visible
-      if( !columnVirtualizationManager.FixedFieldNames.Contains( targetFieldName ) )
-      {
-        // The Cell must be measured/arranged for the BringIntoView to correctly reacts
-        bool isCellLayouted = !this.ForceScrollingCellToLayout( cell );
+      // Fixed cells are always visible.
+      if( columnVirtualizationManager.GetFixedFieldNames( row.LevelCache ).Contains( column ) )
+        return this.BringIntoViewFixedCell( container );
 
-        // Use the DataGridControl.Container attached property to assert a container is always returned even if the container is in FixedHeaders or FixedFooters
-        FrameworkElement container = DataGridControl.GetContainer( cell.ParentRow );
+      return this.BringIntoViewScrollingCell( cell, container, e );
+    }
 
-        // Ensure to call UpdateLayout to be sure the offset returned are the correct ones.
-        if( ( !isCellLayouted ) && ( container != null ) )
-        {
-          container.UpdateLayout();
-        }
+    private bool BringIntoViewFixedCell( FrameworkElement container )
+    {
+      Debug.Assert( container != null );
 
-        double containerToCellsHostWidth = this.TranslatePoint( FixedCellPanel.EmptyPoint, container ).X;
-        double viewportWidth = scrollInfo.ViewportWidth;
-        double fixedColumnWidth = columnVirtualizationManager.FixedColumnsWidth;
+      // We always want the horizontal offset to change if Tab, Home, Left or Right is pressed.
+      if( Keyboard.IsKeyDown( Key.Tab ) || Keyboard.IsKeyDown( Key.Home ) || Keyboard.IsKeyDown( Key.Left ) || Keyboard.IsKeyDown( Key.Right ) )
+      {
+        container.BringIntoView( new Rect( 0d, 0d, 0d, 0d ) );
+      }
+      else
+      {
+        // Ensure to bring the container into view vertically.
+        container.BringIntoView();
+      }
 
-        Point cellToScrollingCellsDecorator = cell.TranslatePoint( FixedCellPanel.EmptyPoint, this.ScrollingCellsDecorator );
+      return true;
+    }
 
-        // If the Cell's left edge is not fully visible, but displays its full content in the Viewport because its width is still
-        // greater than the Viewport, let the ScrollViewer process any events that would have requested a BringIntoView
-        if( ( cellRect.Width - Math.Abs( cellToScrollingCellsDecorator.X ) ) >= ( viewportWidth - fixedColumnWidth ) )
-        {
-          // The cell can't be more into view horizontally, but ensure to bring into view the container vertically.
-          if( container != null )
-          {
-            container.BringIntoView();
-          }
-          return true;
-        }
+    private bool BringIntoViewScrollingCell( Cell cell, FrameworkElement container, RequestBringIntoViewEventArgs e )
+    {
+      Debug.Assert( cell != null );
+      Debug.Assert( container != null );
 
-        double scrollViewerDesiredOffset = 0;
+      // The cell must be measured/arranged for the BringIntoView to correctly reacts
+      if( this.ForceScrollingCellToLayout( cell ) )
+      {
+        container.UpdateLayout();
+      }
 
-        if( cellToScrollingCellsDecorator.X < 0 )
-        {
-          scrollViewerDesiredOffset = cellToScrollingCellsDecorator.X;
-        }
-        else
-        {
-          // The Cell's left edge is visible in the Viewport
-          double cellRightEdgeOffset = ( cellToScrollingCellsDecorator.X + cellRect.Width );
+      var fixedWidth = this.GetFixedWidth();
+      var scrollingPanel = this.ScrollingCellsDecorator;
+      var scrollingArea = new Rect( scrollingPanel.TranslatePoint( FixedCellPanel.EmptyPoint, this ),
+                                    new Size( this.ParentScrollViewer.ViewportWidth - fixedWidth, scrollingPanel.ActualHeight ) );
+      var cellArea = new Rect( cell.TranslatePoint( FixedCellPanel.EmptyPoint, this ),
+                               new Size( cell.ParentColumn.ActualWidth, cell.ActualHeight ) );
 
-          // Verify if the Cell's right edge is visible in the ViewPort
-          Point cellToItemsHost = cell.TranslatePoint( new Point( cellRect.Width, 0 ), itemsHost );
+      // The cell is larger than the scrolling area.
+      if( cellArea.Width > scrollingArea.Width )
+      {
+        var targetObject = e.TargetObject as UIElement;
+        var targetRect = e.TargetRect;
 
-          double rightSideOutOfViewOffset = ( cellToItemsHost.X - viewportWidth );
+        // Try to narrow the area within the cell that we clearly want to bring into view.
+        if( ( targetObject != null ) && ( targetObject != cell || !targetRect.IsEmpty ) )
+        {
+          Debug.Assert( targetObject.IsDescendantOf( cell ) );
 
-          // If the right edge is out of Viewport, ensure to bring into view the out of view part
-          if( rightSideOutOfViewOffset > 0 )
+          if( targetRect.IsEmpty )
           {
-            // Ensure to bring into view the right edge, but we don't want to scroll to far and hide the left edge. 
-            double avoidHiddingLeftEdgeCorrectedOffset = Math.Max( 0, ( rightSideOutOfViewOffset - cellToScrollingCellsDecorator.X ) );
-
-            // The desired offset of the rectangle is the left edge of the Cell and since we specified the width, IScrollInfo.MakeVisible
-            // will ensure to scroll horizontally so this rectangle is fully visible
-            scrollViewerDesiredOffset = cellToItemsHost.X - cellRect.Width - avoidHiddingLeftEdgeCorrectedOffset;
+            targetRect = new Rect( new Point( 0d, 0d ), targetObject.RenderSize );
           }
-          else
+
+          if( targetRect.Width <= scrollingArea.Width )
           {
-            // No need to precise a Rect to bring into view since the Cell is already fully visible. Only call BringIntoView on the container
-            // to be sure it will be fully visible vertically.
-            if( container != null )
-            {
-              container.BringIntoView();
-            }
-            return true;
+            var offset = targetObject.TranslatePoint( FixedCellPanel.EmptyPoint, cell );
+            var location = cellArea.Location;
+            location.Offset( offset.X, offset.Y );
+
+            cellArea.Location = location;
+            cellArea.Size = targetRect.Size;
           }
         }
+      }
 
-        // We computed the desired offset according to the ScrollViewer.Content ( ItemsHost in the DataGridControl)
-        // translate it to a point accoring to the FixedCellPanel to ensure to bring this point into view
-        cellRect.X = itemsHost.TranslatePoint( new Point( scrollViewerDesiredOffset, 0 ), this ).X;
+      if( ( cellArea.Left <= scrollingArea.Left ) && ( cellArea.Right >= scrollingArea.Right ) )
+      {
+        // Ensure to bring the container into view vertically.
+        container.BringIntoView();
       }
-      else
+      else if( cellArea.Left < scrollingArea.Left )
       {
-        // We must consider the actual position of the Cell according to the FixedCellPanel in order to be sure we don't force
-        // an horizontal change. The fixed Cells are always visible so there is no need for horizontal change.
-        double desiredOffset = -1;
-
-        // We always want the horizontal offset to change if Tab, Home, Left or Right is pressed.
-        if( Keyboard.IsKeyDown( Key.Tab ) || Keyboard.IsKeyDown( Key.Home ) || Keyboard.IsKeyDown( Key.Left ) || Keyboard.IsKeyDown( Key.Right ) )
-        {
-          // Fixed Cells are not computed as part of the scrollable offset. Ensure to specify a rectangle that will force the horizontal offset to be 0.
-          desiredOffset = -scrollInfo.HorizontalOffset;
-        }
-        else
-        {
-          desiredOffset = columnVirtualizationManager.FieldNameToOffset[ targetFieldName ];
-        }
+        // The ScrollViewer's extent width includes the fixed section.  We must offset the target area or the cell
+        // will come into view under the fixed panel.
+        cellArea.X -= fixedWidth;
 
-        // The Point returned by TranslatePoint will be according to the current layout, meaning the HorizontalOffset
-        // will be included. So there won't be any horizontal scrolling when bringing a fixed Cell into view.
-        cellRect.X = itemsHost.TranslatePoint( new Point( desiredOffset, 0 ), this ).X;
+        this.BringIntoView( cellArea );
+      }
+      else if( cellArea.Right > scrollingArea.Right )
+      {
+        this.BringIntoView( cellArea );
+      }
+      // The cell is fully visible.
+      else
+      {
+        // Ensure to bring the container into view vertically.
+        container.BringIntoView();
       }
-
-      this.BringIntoView( cellRect );
 
       return true;
     }
@@ -1405,7 +1336,7 @@ namespace Xceed.Wpf.DataGrid.Views
         //Changes to the Cells collection (i.e. VirtualizingCellCollection) can come directly from the Row.Cells property, without the FixedCellPanel knowing about it.
         //So it needs to be informed if this is the case, since it is the FixedCellPanel responsablility to correctly manage and recycle cells.
         //However, if changes to Cells come from the FixedCellPanel itself, of course there is nothing to do.
-        if( !m_parentRowCells.AlreadyUpdating )
+        if( !m_parentRowCells.IsUpdating )
         {
           //Update cells as rarely as possible, so performance is not affected by this (for instance when Row.Cells is updated in a loop, do it once at the end).
           if( m_virtualizingCellCollectionChangedDispatcherOperation == null )
@@ -1441,6 +1372,7 @@ namespace Xceed.Wpf.DataGrid.Views
     private readonly IList<UIElement> m_visualChildren = new List<UIElement>();
 
     private DataGridContext m_dataGridContext; // = null;
+    private TableViewColumnVirtualizationManagerBase m_previousColumnVirualizationManager; // = null;
 
     private DispatcherOperation m_clearUnusedCellsDispatcherOperation; // = null;
     private object m_virtualizingCellCollectionChangedDispatcherOperation;
@@ -1449,10 +1381,9 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       CellsHostPrepared = 1,
       HasDataItem = 2,
-      NeedToClearAllCreatedCells = 4,
-      ZOrderDirty = 8,
-      SplitterDragCanceled = 16,
-      SplitterDragCompleted = 32,
+      ZOrderDirty = 4,
+      SplitterDragCanceled = 8,
+      SplitterDragCompleted = 16,
     }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellSubPanel.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellSubPanel.cs
index 0e5fb901..0716822b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellSubPanel.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/FixedCellSubPanel.cs
@@ -15,17 +15,16 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
-using Xceed.Wpf.DataGrid.Print;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
   // Panel used as children of the FixedCellPanel that only layout horizontally.
-  internal class FixedCellSubPanel : Panel, IPrintInfo
+  internal class FixedCellSubPanel : Panel
   {
     public FixedCellSubPanel( FixedCellPanel parentPanel )
     {
@@ -35,7 +34,7 @@ namespace Xceed.Wpf.DataGrid.Views
       m_parentPanel = parentPanel;
     }
 
-    #region DataGridContext Property
+    #region DataGridContext Internal Property
 
     internal DataGridContext DataGridContext
     {
@@ -47,7 +46,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #endregion
 
-    #region ParentFixedCellPanel Property
+    #region ParentFixedCellPanel Internal Property
 
     internal FixedCellPanel ParentPanel
     {
@@ -61,32 +60,45 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #endregion
 
+    #region ColumnVirtualizationManager Internal Property
+
+    internal TableViewColumnVirtualizationManagerBase ColumnVirtualizationManager
+    {
+      get
+      {
+        var dataGridContext = this.DataGridContext;
+        if( dataGridContext == null )
+          return null;
+
+        return ( TableViewColumnVirtualizationManagerBase )dataGridContext.ColumnVirtualizationManager;
+      }
+    }
+
+    #endregion
+
     protected override UIElementCollection CreateUIElementCollection( FrameworkElement logicalParent )
     {
-      // We make sure that the element added to this panel won't have this panel as 
-      // logical parent. We want the logical parent of these element to be the 
-      // FixedCellPanel itself. This is handled in the UICellCollection class.
+      // We make sure that the element added to this panel won't have this panel as logical parent.
+      // We want the logical parent of these element to be the FixedCellPanel itself. This is handled in the UICellCollection class.
       return new UIElementCollection( this, null );
     }
 
     // Measure horizontally.
     protected override Size MeasureOverride( Size constraint )
     {
-      Size desiredSize = new Size();
-
-      DataGridContext dataGridContext = this.DataGridContext;
-
-      // DataGridContext can be null when a the parent Row was not prepared
-      if( dataGridContext == null )
+      // This can be null when the parent Row is not prepared yet.
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
+      if( columnVirtualizationManager == null )
         return this.DesiredSize;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
+      var desiredSize = new Size();
+      var fieldNameToWidth = columnVirtualizationManager.GetFieldNameToWidth( m_parentPanel.ParentRow.LevelCache );
 
-      foreach( Cell cell in this.GetVisibleCells() )
+      foreach( var cell in this.GetVisibleCells() )
       {
         Debug.Assert( !Row.GetIsTemplateCell( cell ), "No template Cells should be added to FixedCellPanel" );
 
-        cell.Measure( new Size( columnVirtualizationManager.FieldNameToWidth[ cell.FieldName ], constraint.Height ) );
+        cell.Measure( new Size( fieldNameToWidth[ cell.FieldName ], constraint.Height ) );
 
         if( cell.DesiredSize.Height > desiredSize.Height )
         {
@@ -102,17 +114,15 @@ namespace Xceed.Wpf.DataGrid.Views
     // Arrange horizontally.
     protected override Size ArrangeOverride( Size arrangeSize )
     {
-      DataGridContext dataGridContext = this.DataGridContext;
-
-      // DataGridContext can be null when the parent Row was not prepared
-      if( dataGridContext == null )
+      // This can be null when the parent Row is not prepared yet.
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
+      if( columnVirtualizationManager == null )
         return this.DesiredSize;
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager = dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-      Dictionary<string, double> columnToVisibleOffset = columnVirtualizationManager.FieldNameToOffset;
-      Rect finalRect = new Rect( arrangeSize );
+      var columnToVisibleOffset = columnVirtualizationManager.GetFieldNameToOffset( m_parentPanel.ParentRow.LevelCache );
+      var finalRect = new Rect( arrangeSize );
 
-      foreach( Cell cell in this.GetVisibleCells() )
+      foreach( var cell in this.GetVisibleCells() )
       {
         // Never add Template Cells to FixedCellPanel
         if( Row.GetIsTemplateCell( cell ) )
@@ -138,149 +148,24 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected virtual IEnumerable<string> GetVisibleFieldsName()
     {
-      DataGridContext dataGridContext = this.DataGridContext;
-      if( dataGridContext == null )
+      var columnVirtualizationManager = this.ColumnVirtualizationManager;
+      if( columnVirtualizationManager == null )
         return new string[ 0 ];
 
-      TableViewColumnVirtualizationManager columnVirtualizationManager =
-        dataGridContext.ColumnVirtualizationManager as TableViewColumnVirtualizationManager;
-
-      return columnVirtualizationManager.FixedFieldNames;
+      return columnVirtualizationManager.GetFixedFieldNames( m_parentPanel.ParentRow.LevelCache );
     }
 
     protected IEnumerable<Cell> GetVisibleCells()
     {
-      CellCollection collection = this.ParentPanel.ParentRowCells;
-
-      if( collection != null )
-      {
-        foreach( string fieldName in this.GetVisibleFieldsName() )
-        {
-          yield return collection[ fieldName ];
-        }
-      }
-    }
-
-    #region IPrintInfo Members
-
-    double IPrintInfo.GetPageRightOffset( double horizontalOffset, double viewportWidth )
-    {
-      Cell firstCellInView = null;
-      double offset = 0.0d;
-      double accumulatedWidth = 0.0d;
-
-      foreach( Cell cell in this.GetVisibleCells() )
-      {
-        double cellWidth = cell.ActualWidth;
-
-        offset += cellWidth;
-
-        // The cell is in view.
-        if( offset > horizontalOffset )
-        {
-          if( firstCellInView == null )
-          {
-            firstCellInView = cell;
-          }
-
-          accumulatedWidth += cellWidth;
-
-          if( accumulatedWidth > viewportWidth )
-          {
-            // If the first cell is larger than the viewPort, break.
-            if( cell != firstCellInView )
-            {
-              accumulatedWidth -= cellWidth;
-            }
-
-            break;
-          }
-        }
-      }
-
-      return accumulatedWidth + horizontalOffset;
-    }
-
-    void IPrintInfo.UpdateElementVisibility( double horizontalOffset, double viewportWidth, object state )
-    {
-      IDictionary<string, object> visibilityState = ( IDictionary<string, object> )state;
-      Debug.Assert( visibilityState != null );
+      VirtualizingCellCollection collection = this.ParentPanel.ParentRowCells;
 
-      double accumulatedWidth = 0.0d;
-      bool firstCellInViewportFound = false;
-      double viewportLimitsHorizontalOffset = horizontalOffset + viewportWidth;
+      if( collection == null )
+        yield break;
 
-      foreach( Cell cell in this.GetVisibleCells() )
+      foreach( string fieldName in this.GetVisibleFieldsName() )
       {
-        Visibility cellVisibility = cell.Visibility;
-        if( cellVisibility == Visibility.Collapsed )
-          continue;
-
-        accumulatedWidth += cell.ActualWidth;
-
-        bool isPastViewportStart = accumulatedWidth > horizontalOffset;
-        bool isBeforeViewportEnd = isPastViewportStart && ( accumulatedWidth <= ( viewportLimitsHorizontalOffset ) );
-
-        bool isFirstInViewport = ( isPastViewportStart ) && ( !firstCellInViewportFound );
-
-        if( isFirstInViewport )
-          firstCellInViewportFound = true;
-
-        if( isPastViewportStart )
-        {
-          // The cell is past the Viewport's start.
-          if( ( isBeforeViewportEnd ) || ( isFirstInViewport ) )
-          {
-            // Either the cell is completely visible in the Viewport
-            // or we face a cell which is the first in the Viewport but does not completely fit in the Viewport.
-            FixedCellSubPanel.RestoreCellVisibility( cell, visibilityState );
-          }
-          else if( cellVisibility == Visibility.Visible )
-          {
-            // The cell is past the Viewport's end.
-            FixedCellSubPanel.HideCell( cell, visibilityState );
-          }
-        }
-        else if( cellVisibility == Visibility.Visible )
-        {
-          // The cell is before the Viewport's start.
-          FixedCellSubPanel.HideCell( cell, visibilityState );
-        }
+        yield return collection.GetCell( fieldName, false );
       }
     }
-
-    object IPrintInfo.CreateElementVisibilityState()
-    {
-      return new Dictionary<string, object>();
-    }
-
-    private static void HideCell( Cell cell, IDictionary<string, object> visibilityState )
-    {
-      visibilityState[ cell.FieldName ] = cell.ReadLocalValue( Cell.VisibilityProperty );
-      cell.Visibility = Visibility.Hidden;
-    }
-
-    private static void RestoreCellVisibility( Cell cell, IDictionary<string, object> visibilityState )
-    {
-      string fieldName = cell.FieldName;
-      object storedVisibility;
-
-      if( !visibilityState.TryGetValue( fieldName, out storedVisibility ) )
-        return;
-
-      // Restore Visibility
-      if( storedVisibility is Visibility )
-      {
-        cell.Visibility = ( Visibility )storedVisibility;
-      }
-      else
-      {
-        cell.ClearValue( Cell.VisibilityProperty );
-      }
-
-      visibilityState.Remove( fieldName );
-    }
-
-    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/IVirtualizingCellsHost.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/IVirtualizingCellsHost.cs
index 4240f0ce..50507317 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/IVirtualizingCellsHost.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/IVirtualizingCellsHost.cs
@@ -14,9 +14,7 @@
 
   ***********************************************************************************/
 
-using System;
 using System.Windows;
-using System.Collections.Generic;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
@@ -37,6 +35,6 @@ namespace Xceed.Wpf.DataGrid.Views
 
     void InvalidateCellsHostMeasure();
 
-    bool BringIntoView( Cell cell );
+    bool BringIntoView( Cell cell, RequestBringIntoViewEventArgs e );
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/MasterDetailLayoutAttribute.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/MasterDetailLayoutAttribute.cs
new file mode 100644
index 00000000..9e3d4f2e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/MasterDetailLayoutAttribute.cs
@@ -0,0 +1,42 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  [AttributeUsage( AttributeTargets.Class, AllowMultiple = false )] // Applies only to the class of a view
+  internal sealed class MasterDetailLayoutAttribute : Attribute
+  {
+    public MasterDetailLayoutAttribute( MasterDetailLayoutMode masterDetailLayoutMode )
+    {
+      if( !Enum.IsDefined( typeof( MasterDetailLayoutMode ), masterDetailLayoutMode ) )
+        throw new ArgumentException( "The value is not a valid enum value.", "masterDetailLayoutMode" );
+
+      m_masterDetailLayoutMode = masterDetailLayoutMode;
+    }
+
+    public MasterDetailLayoutMode MasterDetailLayoutMode
+    {
+      get
+      {
+        return m_masterDetailLayoutMode;
+      }
+    }
+
+    private MasterDetailLayoutMode m_masterDetailLayoutMode = MasterDetailLayoutMode.Default;
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/NavigationHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/NavigationHelper.cs
new file mode 100644
index 00000000..3a26127b
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/NavigationHelper.cs
@@ -0,0 +1,556 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Input;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal static class NavigationHelper
+  {
+    internal static int GetFirstVisibleFocusableColumnIndex( DataGridContext dataGridContext )
+    {
+      if( dataGridContext == null )
+        return -1;
+
+      return NavigationHelper.GetFirstVisibleFocusableColumnIndex( dataGridContext, dataGridContext.CurrentRow );
+    }
+
+    internal static int GetFirstVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow )
+    {
+      if( dataGridContext == null )
+        return -1;
+
+      if( dataGridContext.IsAFlattenDetail )
+        return NavigationHelper.GetNextVisibleFocusableDetailColumnIndexFromMasterColumnIndex( dataGridContext, targetRow, int.MinValue );
+
+      return NavigationHelper.GetNextVisibleFocusableColumnIndex( dataGridContext, targetRow, int.MinValue );
+    }
+
+    internal static int GetLastVisibleFocusableColumnIndex( DataGridContext dataGridContext )
+    {
+      if( dataGridContext == null )
+        return -1;
+
+      return NavigationHelper.GetLastVisibleFocusableColumnIndex( dataGridContext, dataGridContext.CurrentRow );
+    }
+
+    internal static int GetLastVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow )
+    {
+      if( dataGridContext == null )
+        return -1;
+
+      if( dataGridContext.IsAFlattenDetail )
+        return NavigationHelper.GetPreviousVisibleFocusableDetailColumnIndexFromMasterColumnIndex( dataGridContext, targetRow, int.MaxValue );
+
+      return NavigationHelper.GetPreviousVisibleFocusableColumnIndex( dataGridContext, targetRow, int.MaxValue );
+    }
+
+    internal static int GetNextVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow, ColumnBase targetColumn )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) || ( targetColumn == null ) )
+        return -1;
+
+      var columns = dataGridContext.VisibleColumns;
+      if( ( columns == null ) || ( columns.Count <= 0 ) )
+        return -1;
+
+      var columnIndex = columns.IndexOf( targetColumn );
+      if( columnIndex < 0 )
+        return -1;
+
+      if( !dataGridContext.IsAFlattenDetail )
+        return NavigationHelper.GetNextVisibleFocusableColumnIndex( dataGridContext, targetRow, columnIndex + 1 );
+
+      var columnMap = dataGridContext.ItemPropertyMap;
+      var masterColumnName = default( string );
+
+      if( !columnMap.TryGetColumnFieldName( targetColumn, out masterColumnName ) )
+        return -1;
+
+      var masterDataGridContext = dataGridContext.RootDataGridContext;
+      var masterColumn = masterDataGridContext.Columns[ masterColumnName ];
+
+      if( masterColumn == null )
+        return -1;
+
+      var masterColumnIndex = masterDataGridContext.VisibleColumns.IndexOf( masterColumn );
+      if( masterColumnIndex < 0 )
+        return -1;
+
+      return NavigationHelper.GetNextVisibleFocusableDetailColumnIndexFromMasterColumnIndex( dataGridContext, targetRow, masterColumnIndex + 1 );
+    }
+
+    internal static int GetPreviousVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow, ColumnBase targetColumn )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) || ( targetColumn == null ) )
+        return -1;
+
+      var columns = dataGridContext.VisibleColumns;
+      if( ( columns == null ) || ( columns.Count <= 0 ) )
+        return -1;
+
+      var columnIndex = columns.IndexOf( targetColumn );
+      if( columnIndex < 0 )
+        return -1;
+
+      if( !dataGridContext.IsAFlattenDetail )
+        return NavigationHelper.GetPreviousVisibleFocusableColumnIndex( dataGridContext, targetRow, columnIndex - 1 );
+
+      var columnMap = dataGridContext.ItemPropertyMap;
+      var masterColumnName = default( string );
+
+      if( !columnMap.TryGetColumnFieldName( targetColumn, out masterColumnName ) )
+        return -1;
+
+      var masterDataGridContext = dataGridContext.RootDataGridContext;
+      var masterColumn = masterDataGridContext.Columns[ masterColumnName ];
+
+      if( masterColumn == null )
+        return -1;
+
+      var masterColumnIndex = masterDataGridContext.VisibleColumns.IndexOf( masterColumn );
+      if( masterColumnIndex < 0 )
+        return -1;
+
+      return NavigationHelper.GetPreviousVisibleFocusableDetailColumnIndexFromMasterColumnIndex( dataGridContext, targetRow, masterColumnIndex - 1 );
+    }
+
+    internal static bool MoveFocusLeft( DataGridContext dataGridContext )
+    {
+      var dataGridControl = NavigationHelper.GetDataGridControl( dataGridContext );
+      if( dataGridControl == null )
+        return false;
+
+      var leftToRight = ( dataGridControl.FlowDirection == FlowDirection.LeftToRight );
+
+      return NavigationHelper.MoveFocus( dataGridControl, dataGridContext, leftToRight );
+    }
+
+    internal static bool MoveFocusRight( DataGridContext dataGridContext )
+    {
+      var dataGridControl = NavigationHelper.GetDataGridControl( dataGridContext );
+      if( dataGridControl == null )
+        return false;
+
+      var leftToRight = ( dataGridControl.FlowDirection == FlowDirection.LeftToRight );
+
+      return NavigationHelper.MoveFocus( dataGridControl, dataGridContext, !leftToRight );
+    }
+
+    internal static bool MoveFocusToNextVisibleColumn( DataGridContext dataGridContext )
+    {
+      var dataGridControl = NavigationHelper.GetDataGridControl( dataGridContext );
+      if( dataGridControl == null )
+        return false;
+
+      Debug.Assert( dataGridControl.CurrentContext == dataGridContext );
+
+      return NavigationHelper.MoveFocusToNextVisibleColumn( dataGridContext, dataGridContext.CurrentRow, dataGridContext.CurrentColumn );
+    }
+
+    internal static bool MoveFocusToPreviousVisibleColumn( DataGridContext dataGridContext )
+    {
+      var dataGridControl = NavigationHelper.GetDataGridControl( dataGridContext );
+      if( dataGridControl == null )
+        return false;
+
+      Debug.Assert( dataGridControl.CurrentContext == dataGridContext );
+
+      return NavigationHelper.MoveFocusToPreviousVisibleColumn( dataGridContext, dataGridContext.CurrentRow, dataGridContext.CurrentColumn );
+    }
+
+    internal static bool MoveFocusToFirstVisibleColumn( DataGridContext dataGridContext )
+    {
+      var dataGridControl = NavigationHelper.GetDataGridControl( dataGridContext );
+      if( dataGridControl == null )
+        return false;
+
+      Debug.Assert( dataGridControl.CurrentContext == dataGridContext );
+
+      return NavigationHelper.MoveFocusToFirstVisibleColumn( dataGridContext, dataGridContext.CurrentRow );
+    }
+
+    internal static bool MoveFocusToLastVisibleColumn( DataGridContext dataGridContext )
+    {
+      var dataGridControl = NavigationHelper.GetDataGridControl( dataGridContext );
+      if( dataGridControl == null )
+        return false;
+
+      Debug.Assert( dataGridControl.CurrentContext == dataGridContext );
+
+      return NavigationHelper.MoveFocusToLastVisibleColumn( dataGridContext, dataGridContext.CurrentRow );
+    }
+
+    internal static bool HandleTabKey(
+      DataGridControl dataGridControl,
+      DataGridContext dataGridContext,
+      FrameworkElement source,
+      KeyboardDevice device )
+    {
+      if( ( dataGridControl == null ) || !dataGridControl.IsKeyboardFocusWithin )
+        return false;
+
+      Debug.Assert( dataGridControl.CurrentContext == dataGridContext );
+
+      if( !dataGridControl.IsBeingEdited )
+      {
+        Debug.Assert( dataGridContext != null );
+        return false;
+      }
+
+      if( NavigationHelper.ValidateTabKeyHandleIsWithin( dataGridControl, source, device ) )
+        return false;
+
+      var columns = dataGridContext.VisibleColumns;
+      if( columns.Count <= 0 )
+        return false;
+
+      bool handled;
+
+      if( dataGridContext.CurrentColumn == null )
+      {
+        handled = NavigationHelper.MoveFocusToFirstVisibleColumn( dataGridContext );
+      }
+      else
+      {
+        if( ( device.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
+        {
+          handled = NavigationHelper.MoveFocusToPreviousVisibleColumn( dataGridContext );
+        }
+        else
+        {
+          handled = NavigationHelper.MoveFocusToNextVisibleColumn( dataGridContext );
+        }
+      }
+
+      if( !handled )
+        throw new DataGridException( "Trying to edit while no cell is focusable.", dataGridControl );
+
+      return true;
+    }
+
+    private static int GetNextVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow, int startIndex )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return -1;
+
+      var columns = dataGridContext.VisibleColumns;
+      if( ( columns == null ) || ( columns.Count <= 0 ) )
+        return -1;
+
+      var cells = targetRow.Cells;
+
+      for( int i = Math.Max( 0, startIndex ); i < columns.Count; i++ )
+      {
+        var targetColumn = columns[ i ];
+
+        if( cells[ targetColumn ].GetCalculatedCanBeCurrent() )
+          return i;
+      }
+
+      return -1;
+    }
+
+    private static int GetPreviousVisibleFocusableColumnIndex( DataGridContext dataGridContext, Row targetRow, int startIndex )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return -1;
+
+      var columns = dataGridContext.VisibleColumns;
+      if( ( columns == null ) || ( columns.Count <= 0 ) )
+        return -1;
+
+      var cells = targetRow.Cells;
+
+      for( int i = Math.Min( columns.Count - 1, startIndex ); i >= 0; i-- )
+      {
+        var targetColumn = columns[ i ];
+
+        if( cells[ targetColumn ].GetCalculatedCanBeCurrent() )
+          return i;
+      }
+
+      return -1;
+    }
+
+    private static int GetNextVisibleFocusableDetailColumnIndexFromMasterColumnIndex( DataGridContext dataGridContext, Row targetRow, int startIndex )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return -1;
+
+      Debug.Assert( dataGridContext.IsAFlattenDetail );
+
+      var detailVisibleColumns = dataGridContext.VisibleColumns;
+      if( ( detailVisibleColumns == null ) || ( detailVisibleColumns.Count <= 0 ) )
+        return -1;
+
+      var masterDataGridContext = dataGridContext.RootDataGridContext;
+      var masterVisibleColumns = masterDataGridContext.VisibleColumns;
+
+      var detailColumns = dataGridContext.Columns;
+      var detailPropertyMap = dataGridContext.ItemPropertyMap;
+      var cells = targetRow.Cells;
+
+      for( int i = Math.Max( 0, startIndex ); i < masterVisibleColumns.Count; i++ )
+      {
+        var masterColumn = masterVisibleColumns[ i ];
+        Debug.Assert( masterColumn != null );
+
+        var detailColumnName = default( string );
+        if( detailPropertyMap.TryGetItemPropertyName( masterColumn, out detailColumnName ) )
+        {
+          var detailColumn = detailColumns[ detailColumnName ];
+
+          if( detailColumn != null )
+          {
+            var detailColumnIndex = detailVisibleColumns.IndexOf( detailColumn );
+
+            if( ( detailColumnIndex >= 0 ) && ( cells[ detailColumn ].GetCalculatedCanBeCurrent() ) )
+              return detailColumnIndex;
+          }
+        }
+      }
+
+      return -1;
+    }
+
+    private static int GetPreviousVisibleFocusableDetailColumnIndexFromMasterColumnIndex( DataGridContext dataGridContext, Row targetRow, int startIndex )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return -1;
+
+      Debug.Assert( dataGridContext.IsAFlattenDetail );
+
+      var detailVisibleColumns = dataGridContext.VisibleColumns;
+      if( ( detailVisibleColumns == null ) || ( detailVisibleColumns.Count <= 0 ) )
+        return -1;
+
+      var masterDataGridContext = dataGridContext.RootDataGridContext;
+      var masterVisibleColumns = masterDataGridContext.VisibleColumns;
+
+      var detailColumns = dataGridContext.Columns;
+      var detailPropertyMap = dataGridContext.ItemPropertyMap;
+      var cells = targetRow.Cells;
+
+      for( int i = Math.Min( masterVisibleColumns.Count - 1, startIndex ); i >= 0; i-- )
+      {
+        var masterColumn = masterVisibleColumns[ i ];
+        Debug.Assert( masterColumn != null );
+
+        var detailColumnName = default( string );
+        if( detailPropertyMap.TryGetItemPropertyName( masterColumn, out detailColumnName ) )
+        {
+          var detailColumn = detailColumns[ detailColumnName ];
+
+          if( detailColumn != null )
+          {
+            var detailColumnIndex = detailVisibleColumns.IndexOf( detailColumn );
+
+            if( ( detailColumnIndex >= 0 ) && ( cells[ detailColumn ].GetCalculatedCanBeCurrent() ) )
+              return detailColumnIndex;
+          }
+        }
+      }
+
+      return -1;
+    }
+
+    private static bool ValidateTabKeyHandleIsWithin(
+      DataGridControl dataGridControl,
+      FrameworkElement source,
+      KeyboardDevice device )
+    {
+      if( ( dataGridControl == null ) || ( source == null ) )
+        return false;
+
+      var nextControl = NavigationHelper.PredictNextElement( source, device );
+      if( nextControl == null )
+        return false;
+
+      //If the original source is not a control (e.g. the cells panel instead of a cell), columns will be used to move focus.
+      var cell = Cell.FindFromChild( nextControl );
+      if( ( cell == null ) || ( cell.ParentColumn != dataGridControl.CurrentColumn ) )
+        return false;
+
+      return object.Equals( cell.ParentRow.DataContext, dataGridControl.CurrentItemInEdition );
+    }
+
+    private static bool MoveFocus( DataGridControl dataGridControl, DataGridContext dataGridContext, bool moveLeft )
+    {
+      Debug.Assert( dataGridControl != null );
+      Debug.Assert( dataGridControl.CurrentContext == dataGridContext );
+
+      bool isFocusWithin = dataGridControl.IsKeyboardFocusWithin;
+      bool isBeingEdited = ( isFocusWithin && dataGridControl.IsBeingEdited );
+
+      var navigationBehavior = dataGridControl.NavigationBehavior;
+
+      // Process key even if NavigationBehavior is RowOnly when the grid is being edited.
+      if( ( navigationBehavior == NavigationBehavior.CellOnly )
+        || ( ( navigationBehavior == NavigationBehavior.RowOnly ) && isBeingEdited )
+        || ( ( navigationBehavior == NavigationBehavior.RowOrCell ) && isFocusWithin && ( dataGridContext.CurrentColumn != null ) ) )
+      {
+        if( moveLeft )
+          return NavigationHelper.MoveFocusToPreviousVisibleColumn( dataGridContext, dataGridContext.CurrentRow, dataGridContext.CurrentColumn );
+
+        return NavigationHelper.MoveFocusToNextVisibleColumn( dataGridContext, dataGridContext.CurrentRow, dataGridContext.CurrentColumn );
+      }
+
+      return false;
+    }
+
+    private static bool MoveFocusToNextVisibleColumn( DataGridContext dataGridContext, Row targetRow, ColumnBase targetColumn )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return false;
+
+      var columnIndex = NavigationHelper.GetNextVisibleFocusableColumnIndex( dataGridContext, targetRow, targetColumn );
+      if( columnIndex < 0 )
+        return NavigationHelper.MoveFocusToFirstVisibleColumn( dataGridContext, targetRow );
+
+      var columns = dataGridContext.VisibleColumns;
+      Debug.Assert( columns != null );
+
+      NavigationHelper.SetCurrentColumnAndChangeSelection( dataGridContext, columns[ columnIndex ] );
+
+      return true;
+    }
+
+    private static bool MoveFocusToPreviousVisibleColumn( DataGridContext dataGridContext, Row targetRow, ColumnBase targetColumn )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return false;
+
+      var columnIndex = NavigationHelper.GetPreviousVisibleFocusableColumnIndex( dataGridContext, targetRow, targetColumn );
+      if( columnIndex < 0 )
+        return NavigationHelper.MoveFocusToLastVisibleColumn( dataGridContext, targetRow );
+
+      var columns = dataGridContext.VisibleColumns;
+      Debug.Assert( columns != null );
+
+      NavigationHelper.SetCurrentColumnAndChangeSelection( dataGridContext, columns[ columnIndex ] );
+
+      return true;
+    }
+
+    private static bool MoveFocusToFirstVisibleColumn( DataGridContext dataGridContext, Row targetRow )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return false;
+
+      var columnIndex = NavigationHelper.GetFirstVisibleFocusableColumnIndex( dataGridContext, targetRow );
+      if( columnIndex < 0 )
+        return false;
+
+      var columns = dataGridContext.VisibleColumns;
+      Debug.Assert( columns != null );
+
+      NavigationHelper.SetCurrentColumnAndChangeSelection( dataGridContext, columns[ columnIndex ] );
+
+      return true;
+    }
+
+    private static bool MoveFocusToLastVisibleColumn( DataGridContext dataGridContext, Row targetRow )
+    {
+      if( ( dataGridContext == null ) || ( targetRow == null ) )
+        return false;
+
+      var columnIndex = NavigationHelper.GetLastVisibleFocusableColumnIndex( dataGridContext, targetRow );
+      if( columnIndex < 0 )
+        return false;
+
+      var columns = dataGridContext.VisibleColumns;
+      Debug.Assert( columns != null );
+
+      NavigationHelper.SetCurrentColumnAndChangeSelection( dataGridContext, columns[ columnIndex ] );
+
+      return true;
+    }
+
+    private static DataGridControl GetDataGridControl( DataGridContext dataGridContext )
+    {
+      if( dataGridContext != null )
+        return dataGridContext.DataGridControl;
+
+      return null;
+    }
+
+    private static DependencyObject PredictNextElement( FrameworkElement source, KeyboardDevice device )
+    {
+      foreach( var direction in NavigationHelper.GetFocusNavigationDirections( source, device ) )
+      {
+        var target = source.PredictFocus( direction );
+        if( target != null )
+          return target;
+      }
+
+      return null;
+    }
+
+    private static IEnumerable<FocusNavigationDirection> GetFocusNavigationDirections( FrameworkElement source, KeyboardDevice device )
+    {
+      if( source == null )
+        yield break;
+
+      //In the case of a ListBox set with Cycle or Contained navigation mode, we must move in the other direction if on the first or last item,
+      //since PredictFocus will throw is we use FocusNavigationDirection.First/Last.
+      if( ( device.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
+      {
+        yield return FocusNavigationDirection.Left;
+        yield return FocusNavigationDirection.Up;
+
+        var navigationMode = ( KeyboardNavigationMode )source.GetValue( KeyboardNavigation.TabNavigationProperty );
+        if( navigationMode == KeyboardNavigationMode.Cycle || navigationMode == KeyboardNavigationMode.Contained )
+        {
+          yield return FocusNavigationDirection.Right;
+          yield return FocusNavigationDirection.Down;
+        }
+      }
+      else
+      {
+        yield return FocusNavigationDirection.Right;
+        yield return FocusNavigationDirection.Down;
+
+        var navigationMode = ( KeyboardNavigationMode )source.GetValue( KeyboardNavigation.TabNavigationProperty );
+        if( navigationMode == KeyboardNavigationMode.Cycle || navigationMode == KeyboardNavigationMode.Contained )
+        {
+          yield return FocusNavigationDirection.Left;
+          yield return FocusNavigationDirection.Up;
+        }
+      }
+    }
+
+    private static void SetCurrentColumnAndChangeSelection( DataGridContext dataGridContext, ColumnBase column )
+    {
+      Debug.Assert( dataGridContext != null );
+      Debug.Assert( column != null );
+
+      try
+      {
+        dataGridContext.SetCurrentColumnAndChangeSelection( column );
+      }
+      catch( DataGridException )
+      {
+        // We swallow the exception if it occurs because of a validation error or Cell was read-only or
+        // any other GridException.
+      }
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollViewerTemplateHelper.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollViewerTemplateHelper.cs
new file mode 100644
index 00000000..8db9777e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollViewerTemplateHelper.cs
@@ -0,0 +1,186 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal class ScrollViewerTemplateHelper : IDisposable
+  {
+
+    public ScrollViewerTemplateHelper(
+      ScrollViewer scrollViewer,
+      Action<Orientation> dragScrollBeginCallback,
+      Action<Orientation> dragScrollEndCallback )
+    {
+      if( scrollViewer == null )
+        throw new ArgumentNullException( "scrollViewer" );
+
+      m_scrollViewer = scrollViewer;
+      m_dragScrollBeginCallback = dragScrollBeginCallback;
+      m_dragScrollEndCallback = dragScrollEndCallback;
+    }
+
+    #region VerticalScrollBar Property
+
+    public ScrollBar VerticalScrollBar
+    {
+      get;
+      private set;
+    }
+
+    #endregion
+
+    #region HorizontalScrollBar Property
+
+    public ScrollBar HorizontalScrollBar
+    {
+      get;
+      private set;
+    }
+
+    #endregion
+
+    public ScrollBar GetScrollBar( Orientation orientation )
+    {
+      return ( orientation == Orientation.Vertical )
+        ? this.VerticalScrollBar
+        : this.HorizontalScrollBar;
+    }
+
+    public void RefreshTemplate()
+    {
+      this.UnregisterEvents();
+
+      var template = m_scrollViewer.Template;
+      if( template != null )
+      {
+        this.HorizontalScrollBar = template.FindName( "PART_HorizontalScrollBar", m_scrollViewer ) as ScrollBar;
+        this.VerticalScrollBar = template.FindName( "PART_VerticalScrollBar", m_scrollViewer ) as ScrollBar;
+      }
+
+      if( m_dragScrollBeginCallback != null || m_dragScrollEndCallback != null )
+      {
+        this.RegisterEvents();
+      }
+    }
+
+    public void Dispose()
+    {
+      this.UnregisterEvents();
+
+      m_dragScrollBeginCallback = null;
+      m_dragScrollEndCallback = null;
+    }
+
+    private void RegisterEvents()
+    {
+      if( this.VerticalScrollBar != null )
+      {
+        this.VerticalScrollBar.IsMouseCaptureWithinChanged += ScrollBar_IsMouseCaptureWithinChanged;
+      }
+
+      if( this.HorizontalScrollBar != null )
+      {
+        this.HorizontalScrollBar.IsMouseCaptureWithinChanged += ScrollBar_IsMouseCaptureWithinChanged;
+      }
+    }
+
+    private void UnregisterEvents()
+    {
+      if( this.VerticalScrollBar != null )
+      {
+        this.VerticalScrollBar.IsMouseCaptureWithinChanged -= ScrollBar_IsMouseCaptureWithinChanged;
+      }
+
+      if( this.HorizontalScrollBar != null )
+      {
+        this.HorizontalScrollBar.IsMouseCaptureWithinChanged -= ScrollBar_IsMouseCaptureWithinChanged;
+      }
+    }
+
+    private void ScrollBar_IsMouseCaptureWithinChanged( object sender, DependencyPropertyChangedEventArgs e )
+    {
+      var scrollBar = sender as ScrollBar;
+
+      if( scrollBar == null )
+        return;
+
+      if( scrollBar != this.HorizontalScrollBar
+        && scrollBar != this.VerticalScrollBar )
+      {
+        Debug.Fail( "Unknown scrollbar" );
+        return;
+      }
+
+      var scrollThumb = Mouse.Captured as Thumb;
+
+      if( scrollThumb == null )
+        return;
+
+      if( scrollBar.Track == null )
+        return;
+
+      if( scrollBar.Track.Thumb != scrollThumb )
+        return;
+
+      m_currentScrollOrientation = ( scrollBar == this.VerticalScrollBar ) ? Orientation.Vertical : Orientation.Horizontal;
+
+      if( m_dragScrollEndCallback != null )
+      {
+        // Register to LostMouseCapture to be sure to hide the ScrollTip when the ScrollThumb lost the focus
+        scrollThumb.LostMouseCapture += new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
+      }
+
+      if( m_dragScrollBeginCallback != null )
+      {
+
+        m_dragScrollBeginCallback( m_currentScrollOrientation );
+      }
+
+    }
+
+
+    private void ScrollThumb_LostMouseCapture( object sender, MouseEventArgs e )
+    {
+      Thumb scrollBarThumb = sender as Thumb;
+
+      Debug.Assert( scrollBarThumb != null );
+
+      if( scrollBarThumb != null )
+        scrollBarThumb.LostMouseCapture -= new MouseEventHandler( this.ScrollThumb_LostMouseCapture );
+
+      if( m_dragScrollEndCallback != null )
+      {
+        m_dragScrollEndCallback( m_currentScrollOrientation );
+      }
+    }
+
+    #region Fields
+
+    private ScrollViewer m_scrollViewer;
+    private Action<Orientation> m_dragScrollBeginCallback;
+    private Action<Orientation> m_dragScrollEndCallback;
+    private Orientation m_currentScrollOrientation;
+    #endregion
+
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollingCellsDecorator.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollingCellsDecorator.cs
index e01b87bf..d4e616cc 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollingCellsDecorator.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ScrollingCellsDecorator.cs
@@ -15,14 +15,11 @@
   ***********************************************************************************/
 
 using System;
+using System.Windows;
 using System.Windows.Controls;
+using System.Windows.Data;
 using System.Windows.Input;
-using System.Windows;
-using System.ComponentModel;
 using System.Windows.Media;
-using System.Windows.Threading;
-using System.Windows.Data;
-using System.Diagnostics;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
@@ -147,7 +144,9 @@ namespace Xceed.Wpf.DataGrid.Views
       // We need to take ScrollingCellsDecoratorClipOffset into consideration
       // in case an animated column reordering is in progress
       double clipOffset = this.SplitterOffset;
-      double widthOffset = arrangeSize.Width - clipOffset;
+
+      //Width of Rect cannot be less then 0.
+      double widthOffset = Math.Max( 0, arrangeSize.Width - clipOffset );
 
       // Try to get the RectangleGeometry from the Clip
       // to avoid recreating one per call
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/SynchronizedScrollViewer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/SynchronizedScrollViewer.cs
index 7017aa80..3f6c8ce4 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/SynchronizedScrollViewer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/SynchronizedScrollViewer.cs
@@ -157,8 +157,6 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected override void OnScrollChanged( ScrollChangedEventArgs e )
     {
-      //case 117456: Because the event is routed (bubble) we have to kill the event here so that other classes ( more particularly the
-      // DataGridScrollViewer) does not get confused by the event.
       e.Handled = true;
 
       base.OnScrollChanged( e );
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableView.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableView.cs
index 1dbe73dd..56ac5357 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableView.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableView.cs
@@ -15,31 +15,21 @@
   ***********************************************************************************/
 
 using System;
-using System.Windows;
-using System.Windows.Media;
-using System.Windows.Controls;
 using System.ComponentModel;
-using System.Windows.Data;
-using System.Collections.Generic;
-using System.Security;
-using System.Security.Permissions;
 using System.Diagnostics;
-using System.Windows.Resources;
+using System.Security;
+using System.Windows;
 using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Resources;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
   public class TableView : UIViewBase
   {
-    #region Static Fields
-
     internal static Cursor DefaultRowSelectorResizeNorthSouthCursor = Cursors.SizeNS;
     internal static Cursor DefaultRowSelectorResizeWestEastCursor = Cursors.SizeWE;
 
-    #endregion
-
-    #region Contructors
-
     static TableView()
     {
       FrameworkContentElement.DefaultStyleKeyProperty.OverrideMetadata(
@@ -63,8 +53,6 @@ namespace Xceed.Wpf.DataGrid.Views
     {
     }
 
-    #endregion
-
     #region AutoFillLastPage Property
 
     [EditorBrowsable( EditorBrowsableState.Never )]
@@ -120,20 +108,19 @@ namespace Xceed.Wpf.DataGrid.Views
     private static void OnCanScrollHorizontallyChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
     {
       // This property makes sense (only works) for potentially visible element; UIElement.
-      UIElement element = sender as UIElement;
+      var element = sender as FrameworkElement;
+      if( element == null )
+        return;
 
-      if( element != null )
-      {
-        TableViewScrollViewer.SetFixedTranslateTransform( element, ( bool )e.NewValue );
-      }
+      TableViewScrollViewer.SetFixedTranslateTransform( element, ( bool )e.NewValue );
     }
 
     #endregion CanScrollHorizontally Attached Property
 
     #region CompensationOffset Attached Property
 
-    internal static readonly DependencyPropertyKey CompensationOffsetPropertyKey = DependencyProperty.RegisterAttachedReadOnly( 
-      "CompensationOffset", typeof( double ), typeof( TableView ), 
+    internal static readonly DependencyPropertyKey CompensationOffsetPropertyKey = DependencyProperty.RegisterAttachedReadOnly(
+      "CompensationOffset", typeof( double ), typeof( TableView ),
       new FrameworkPropertyMetadata( 0d, FrameworkPropertyMetadataOptions.Inherits ) );
 
     internal static readonly DependencyProperty CompensationOffsetProperty;
@@ -349,7 +336,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region FixedColumnCount Property
 
-    [ViewProperty( ViewPropertyMode.RoutedNoFallback )]
+    [ViewProperty( ViewPropertyMode.RoutedNoFallback, FlattenDetailBindingMode.MasterOneWay )]
     public static readonly DependencyProperty FixedColumnCountProperty =
       DependencyProperty.RegisterAttached( "FixedColumnCount", typeof( int ), typeof( TableView ),
       new UIPropertyMetadata( 0 ),
@@ -674,7 +661,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region IsColumnVirtualizationEnabled Property
 
-    [ViewProperty( ViewPropertyMode.Routed )]
+    [ViewProperty( ViewPropertyMode.Routed, FlattenDetailBindingMode.MasterOneWay )]
     public static readonly DependencyProperty IsColumnVirtualizationEnabledProperty =
         DependencyProperty.RegisterAttached( "IsColumnVirtualizationEnabled",
           typeof( bool ),
@@ -707,7 +694,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region IsAlternatingRowStyleEnabled Property
 
-    [ViewProperty( ViewPropertyMode.Routed )]
+    [ViewProperty( ViewPropertyMode.Routed, FlattenDetailBindingMode.MasterOneWay )]
     public static readonly DependencyProperty IsAlternatingRowStyleEnabledProperty =
       DependencyProperty.RegisterAttached( "IsAlternatingRowStyleEnabled", typeof( bool ), typeof( TableView ), new UIPropertyMetadata( false ) );
 
@@ -823,32 +810,20 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #endregion
 
-    #region Internal Methods
-
-    internal override ColumnVirtualizationManager CreateColumnVirtualizationManager( DataGridContext dataGridContext )
-    {
-      Debug.Assert( dataGridContext != null );
-
-      return new TableViewColumnVirtualizationManager( dataGridContext );
-    }
-
-    #endregion
-
-    #region Protected Methods
-
     protected override void AddDefaultHeadersFooters()
     {
       this.FixedHeaders.Insert( 0, TableView.DefaultColumnManagerRowTemplate );
       this.FixedHeaders.Insert( 0, TableView.DefaultGroupByControlTemplate );
     }
 
-    #endregion
+    internal override ColumnVirtualizationManager CreateColumnVirtualizationManager( DataGridContext dataGridContext )
+    {
+      Debug.Assert( dataGridContext != null );
 
-    #region Private Fields
+      return new TableViewColumnVirtualizationManager( dataGridContext );
+    }
 
     private static readonly DataTemplate DefaultColumnManagerRowTemplate;
     private static readonly DataTemplate DefaultGroupByControlTemplate;
-
-    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewEndPageInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewEndPageInfo.cs
new file mode 100644
index 00000000..5fea2421
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewEndPageInfo.cs
@@ -0,0 +1,89 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal sealed class TableViewEndPageInfo : TableViewPartialPageInfo
+  {
+    #region Constructor
+
+    internal TableViewEndPageInfo( int value )
+    {
+      if( value < 0 )
+        throw new ArgumentException( "value must be greater than or equal to zero.", "value" );
+
+      m_value = value;
+    }
+
+    #endregion
+
+    #region Start Property
+
+    public override int Start
+    {
+      get
+      {
+        throw new NotSupportedException();
+      }
+    }
+
+    #endregion
+
+    #region End Property
+
+    public override int End
+    {
+      get
+      {
+        return m_value;
+      }
+    }
+
+    private readonly int m_value;
+
+    #endregion
+
+    protected override int GetHashCodeImpl()
+    {
+      return m_value;
+    }
+
+    protected override bool EqualsImpl( TableViewPageInfo obj )
+    {
+      var page = obj as TableViewEndPageInfo;
+      if( object.ReferenceEquals( page, null ) )
+        return false;
+
+      return ( page.m_value == m_value );
+    }
+
+    public override bool TryGetStart( out int value )
+    {
+      value = 0;
+
+      return false;
+    }
+
+    public override bool TryGetEnd( out int value )
+    {
+      value = m_value;
+
+      return true;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewFullPageInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewFullPageInfo.cs
new file mode 100644
index 00000000..5a673fdc
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewFullPageInfo.cs
@@ -0,0 +1,130 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal sealed class TableViewFullPageInfo : TableViewPageInfo
+  {
+    #region Constructor
+
+    internal TableViewFullPageInfo( int start, int end, double size )
+    {
+      if( start < 0 )
+        throw new ArgumentException( "start must be greater than or equal to zero.", "start" );
+
+      if( end < 0 )
+        throw new ArgumentException( "end must be greater than or equal to zero.", "end" );
+
+      if( end < start )
+        throw new ArgumentException( "end must be greater than or equal to start.", "end" );
+
+      if( size < 0 )
+        throw new ArgumentException( "size must be greater than or equal to zero.", "size" );
+
+      m_start = start;
+      m_end = end;
+      m_size = size;
+    }
+
+    #endregion
+
+    #region Start Property
+
+    public override int Start
+    {
+      get
+      {
+        return m_start;
+      }
+    }
+
+    private readonly int m_start;
+
+    #endregion
+
+    #region End Property
+
+    public override int End
+    {
+      get
+      {
+        return m_end;
+      }
+    }
+
+    private readonly int m_end;
+
+    #endregion
+
+    #region Length Property
+
+    public override int Length
+    {
+      get
+      {
+        return m_end - m_start + 1;
+      }
+    }
+
+    #endregion
+
+    #region Size Property
+
+    public override double Size
+    {
+      get
+      {
+        return m_size;
+      }
+    }
+
+    private readonly double m_size;
+
+    #endregion
+
+    public override bool TryGetStart( out int value )
+    {
+      value = m_start;
+
+      return true;
+    }
+
+    public override bool TryGetEnd( out int value )
+    {
+      value = m_end;
+
+      return true;
+    }
+
+    protected override int GetHashCodeImpl()
+    {
+      return ( m_start ^ m_end );
+    }
+
+    protected override bool EqualsImpl( TableViewPageInfo obj )
+    {
+      var page = obj as TableViewFullPageInfo;
+      if( object.ReferenceEquals( page, null ) )
+        return false;
+
+      return ( page.m_start == m_start )
+          && ( page.m_end == m_end )
+          && ( page.m_size == m_size );
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewHeaderFooterPanel.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewHeaderFooterPanel.cs
index 6563cb8e..25506c84 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewHeaderFooterPanel.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewHeaderFooterPanel.cs
@@ -15,14 +15,303 @@
   ***********************************************************************************/
 
 using System;
-using System.Windows.Controls;
+using System.Diagnostics;
 using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
 using System.Windows.Media;
+using Xceed.Utils.Wpf;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
   public class TableViewHeaderFooterPanel : StackPanel
   {
+    #region Constructor
+
+    public TableViewHeaderFooterPanel()
+    {
+      this.AddHandler( FrameworkElement.RequestBringIntoViewEvent, new RequestBringIntoViewEventHandler( this.OnRequestBringIntoView ) );
+    }
+
+    #endregion
+
+    #region ParentDataGridControl Private Property
+
+    private DataGridControl ParentDataGridControl
+    {
+      get
+      {
+        var dataGridContext = DataGridControl.GetDataGridContext( this );
+        if( dataGridContext == null )
+          return null;
+
+        return dataGridContext.DataGridControl;
+      }
+    }
+
+    #endregion
+
+    #region PreviewKeyDown and KeyDown handling overrides
+
+    protected override void OnPreviewKeyDown( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      switch( e.Key )
+      {
+        case Key.Tab:
+          this.HandlePreviewTabKey( e );
+          break;
+
+        case Key.Home:
+          this.HandlePreviewHomeKey( e );
+          break;
+
+        case Key.End:
+          this.HandlePreviewEndKey( e );
+          break;
+
+        case Key.Left:
+          this.HandlePreviewLeftKey( e );
+          break;
+
+        case Key.Right:
+          this.HandlePreviewRightKey( e );
+          break;
+
+        default:
+          base.OnPreviewKeyDown( e );
+          break;
+      }
+    }
+
+    protected virtual void HandlePreviewTabKey( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      var dataGridContext = dataGridControl.CurrentContext;
+      if( dataGridContext == null )
+        return;
+
+      var container = dataGridContext.GetContainerFromItem( dataGridContext.InternalCurrentItem );
+      if( container == null )
+        return;
+
+      var tabbingMode = KeyboardNavigation.GetTabNavigation( container );
+      if( tabbingMode == KeyboardNavigationMode.None )
+        return;
+
+      if( ( Keyboard.Modifiers == ModifierKeys.None ) || ( Keyboard.Modifiers == ModifierKeys.Shift ) )
+      {
+        DataGridItemsHost.BringIntoViewKeyboardFocusedElement();
+
+        //Force the "inline" relayout of the panel
+        //This has no effect if the panel do not have to be updated.
+        this.UpdateLayout();
+      }
+    }
+
+    protected virtual void HandlePreviewLeftKey( KeyEventArgs e )
+    {
+      DataGridItemsHost.BringIntoViewKeyboardFocusedElement();
+      this.UpdateLayout();
+    }
+
+    protected virtual void HandlePreviewRightKey( KeyEventArgs e )
+    {
+      DataGridItemsHost.BringIntoViewKeyboardFocusedElement();
+      this.UpdateLayout();
+    }
+
+    protected virtual void HandlePreviewHomeKey( KeyEventArgs e )
+    {
+    }
+
+    protected virtual void HandlePreviewEndKey( KeyEventArgs e )
+    {
+    }
+
+    protected override void OnKeyDown( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      switch( e.Key )
+      {
+        case Key.Tab:
+          this.HandleTabKey( e );
+          break;
+
+        case Key.Home:
+          this.HandleHomeKey( e );
+          break;
+
+        case Key.End:
+          this.HandleEndKey( e );
+          break;
+
+        case Key.Left:
+          this.HandleLeftKey( e );
+          break;
+
+        case Key.Right:
+          this.HandleRightKey( e );
+          break;
+
+        default:
+          base.OnKeyDown( e );
+          break;
+      }
+    }
+
+    protected virtual void HandleTabKey( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      var dataGridContext = dataGridControl.CurrentContext;
+      if( dataGridContext == null )
+        return;
+
+      e.Handled = NavigationHelper.HandleTabKey( dataGridControl, dataGridContext, e.OriginalSource as FrameworkElement, e.KeyboardDevice );
+    }
+
+    protected virtual void HandleHomeKey( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      bool ctrlPressed = ( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control );
+      if( !ctrlPressed )
+        return;
+
+      var dataGridControl = this.ParentDataGridControl;
+      if( ( dataGridControl == null ) || ( dataGridControl.NavigationBehavior != NavigationBehavior.CellOnly ) )
+        return;
+
+      NavigationHelper.MoveFocusToFirstVisibleColumn( dataGridControl.CurrentContext );
+
+      e.Handled = true;
+    }
+
+    protected virtual void HandleEndKey( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      bool ctrlPressed = ( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control );
+      if( !ctrlPressed )
+        return;
+
+      var dataGridControl = this.ParentDataGridControl;
+      if( ( dataGridControl == null ) || ( dataGridControl.NavigationBehavior != NavigationBehavior.CellOnly ) )
+        return;
+
+      NavigationHelper.MoveFocusToLastVisibleColumn( dataGridControl.CurrentContext );
+
+      e.Handled = true;
+    }
+
+    protected virtual void HandleLeftKey( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusLeft( dataGridControl.CurrentContext );
+    }
+
+    protected virtual void HandleRightKey( KeyEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusRight( dataGridControl.CurrentContext );
+    }
+
+    #endregion
+
+    #region BringIntoView Methods
+
+    private void OnRequestBringIntoView( object sender, RequestBringIntoViewEventArgs e )
+    {
+      if( e.Handled )
+        return;
+
+      Debug.Assert( this == sender );
+
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      // Prevent a BringIntoView to be requested twice when setting the focus on a cell.
+      if( dataGridControl.SettingFocusOnCell )
+      {
+        e.Handled = true;
+        return;
+      }
+
+      // Let the ScrollViewer handle this if the grid isn't virtualized.
+      var scrollViewer = TreeHelper.FindParent<ScrollViewer>( this );
+      if( ( scrollViewer == null ) || !scrollViewer.CanContentScroll )
+        return;
+
+      var targetVisual = e.TargetObject as Visual;
+      if( targetVisual == null )
+        return;
+
+      // Let the ScrollViewer handle this if the target is the container (i.e. HeaderFooterItem).
+      var container = this.GetContainerFromElement( targetVisual );
+      if( ( container == null ) || ( container == targetVisual ) )
+        return;
+
+      Debug.Assert( this.Children.Contains( container ) );
+
+      e.Handled = true;
+
+      var targetRect = e.TargetRect;
+      if( targetRect.IsEmpty )
+      {
+        var uiElement = TreeHelper.FindParent<UIElement>( targetVisual, true );
+
+        // If we have a container, we surely have a UIElement.
+        Debug.Assert( uiElement != null );
+
+        targetVisual = uiElement;
+        targetRect = new Rect( 0d, 0d, Math.Min( uiElement.RenderSize.Width, scrollViewer.ViewportWidth ), 0d );
+      }
+
+      var area = targetVisual.TransformToAncestor( container ).TransformBounds( targetRect );
+
+      if( area.Left < scrollViewer.HorizontalOffset )
+      {
+        scrollViewer.ScrollToHorizontalOffset( area.Left );
+      }
+      else if( area.Right > scrollViewer.HorizontalOffset + scrollViewer.ViewportWidth )
+      {
+        scrollViewer.ScrollToHorizontalOffset( Math.Min( area.Left, ( area.Right - scrollViewer.ViewportWidth ) ) );
+      }
+    }
+
+    #endregion
+
     protected override Size ArrangeOverride( Size arrangeSize )
     {
       Size finalSize = base.ArrangeOverride( arrangeSize );
@@ -100,5 +389,26 @@ namespace Xceed.Wpf.DataGrid.Views
 
       return base.MeasureOverride( availableSize );
     }
+
+    private UIElement GetContainerFromElement( DependencyObject element )
+    {
+      if( element == null )
+        return null;
+
+      var uiElement = TreeHelper.FindParent<UIElement>( element, true );
+      if( uiElement == null )
+        return null;
+
+      if( this.Children.Contains( uiElement ) )
+        return uiElement;
+
+      foreach( UIElement container in this.Children )
+      {
+        if( container.IsAncestorOf( uiElement ) )
+          return container;
+      }
+
+      return null;
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewItemsHost.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewItemsHost.cs
index a9f6196c..0f3d23a3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewItemsHost.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewItemsHost.cs
@@ -16,32 +16,21 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq;
-using System.Text;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
+using System.Windows.Input;
 using System.Windows.Media;
-using System.Windows.Controls;
-using Xceed.Utils.Math;
-using System.Windows.Threading;
-using System.Diagnostics;
-using System.Windows.Media.Animation;
+using Xceed.Utils.Collections;
 using Xceed.Utils.Wpf;
-using System.Windows.Input;
-using System.Collections;
-using System.Collections.ObjectModel;
-using System.Collections.Specialized;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
   public class TableViewItemsHost : DataGridItemsHost, IScrollInfo, IDeferableScrollInfoRefresh
   {
-    #region Static Members
-
-    private const int MaxDataRowFailFocusCount = 50;
-
-    #endregion
-
     #region Constructors
 
     static TableViewItemsHost()
@@ -85,11 +74,15 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
+#pragma warning disable 618
         return ( Orientation )this.GetValue( TableViewItemsHost.OrientationProperty );
+#pragma warning restore 618
       }
       set
       {
+#pragma warning disable 618
         this.SetValue( TableViewItemsHost.OrientationProperty, value );
+#pragma warning restore 618
       }
     }
 
@@ -106,11 +99,15 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
+#pragma warning disable 618
         return ( bool )this.GetValue( TableViewItemsHost.StableScrollingEnabledProperty );
+#pragma warning restore 618
       }
       set
       {
+#pragma warning disable 618
         this.SetValue( TableViewItemsHost.StableScrollingEnabledProperty, value );
+#pragma warning restore 618
       }
     }
 
@@ -127,11 +124,15 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
+#pragma warning disable 618
         return ( double )this.GetValue( TableViewItemsHost.StableScrollingProportionProperty );
+#pragma warning restore 618
       }
       set
       {
+#pragma warning disable 618
         this.SetValue( TableViewItemsHost.StableScrollingProportionProperty, value );
+#pragma warning restore 618
       }
     }
 
@@ -195,30 +196,36 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
-        TableViewScrollViewer tableViewScrollViewer = this.ScrollInfo.ScrollOwner as TableViewScrollViewer;
-        return ( tableViewScrollViewer == null ) ? null : tableViewScrollViewer.RowSelectorPane;
+        var scrollViewer = this.ScrollInfo.ScrollOwner as TableViewScrollViewer;
+        if( scrollViewer == null )
+          return null;
+
+        return scrollViewer.RowSelectorPane;
       }
     }
 
+    private bool IsRowSelectorPaneVisible()
+    {
+      var rowSelectorPane = this.RowSelectorPane;
+
+      return ( rowSelectorPane != null )
+          && ( rowSelectorPane.Visibility == Visibility.Visible );
+    }
+
     #endregion RowSelectorPane Property
 
     #region Measure/Arrange Methods
 
     protected override Size MeasureOverride( Size availableSize )
     {
-      this.InvalidateAutomationPeerChildren();
-
       m_cachedContainerDesiredWidth.Clear();
       m_cachedContainerRealDesiredWidth.Clear();
       m_autoWidthCalculatedDataGridContextList.Clear();
       m_lastMeasureAvailableSize = availableSize;
 
-      double availableHeight = availableSize.Height;
-      double viewportHeight = availableHeight;
-
-      this.GeneratePageAndUpdateIScrollInfoValues( availableSize, true, ref viewportHeight );
+      var generatedPage = this.GeneratePageAndUpdateIScrollInfoValues( availableSize, true );
 
-      return this.GetNewDesiredSize( viewportHeight );
+      return this.GetNewDesiredSize( generatedPage );
     }
 
     private void MeasureContainer( UIElement container )
@@ -250,8 +257,8 @@ namespace Xceed.Wpf.DataGrid.Views
         // We invalidate the CellsHostPanel of the row and all is parent to ensure the
         // size is correctly evaluated when we have some auto stretching column.
         container.InvalidateMeasure();
-        Row row = this.ExtractRowFromContainer( container );
 
+        var row = Row.FromContainer( container );
         if( row != null )
         {
           UIElement itemToInvalidate = row.CellsHostPanel;
@@ -285,71 +292,116 @@ namespace Xceed.Wpf.DataGrid.Views
         m_cachedContainerDesiredWidth.Add( dataGridContextName, desiredSize );
       }
 
-      HeaderFooterItem headerFooterItem = container as HeaderFooterItem;
-
-      if( headerFooterItem != null )
+      PassiveLayoutDecorator decorator = this.GetPassiveLayoutDecorator( container as HeaderFooterItem );
+      if( decorator != null )
       {
-        PassiveLayoutDecorator passiveLayoutDecorator = null;
+        desiredSize = decorator.RealDesiredSize.Width;
 
-        if( VisualTreeHelper.GetChildrenCount( headerFooterItem ) > 0 )
+        if( m_cachedContainerRealDesiredWidth.TryGetValue( dataGridContextName, out cachedSize ) )
         {
-          DependencyObject child = VisualTreeHelper.GetChild( headerFooterItem, 0 );
-          passiveLayoutDecorator = child as PassiveLayoutDecorator;
-
-          if( ( passiveLayoutDecorator == null ) && ( VisualTreeHelper.GetChildrenCount( child ) > 0 ) )
-          {
-            passiveLayoutDecorator = VisualTreeHelper.GetChild( child, 0 ) as PassiveLayoutDecorator;
-          }
-
-          if( passiveLayoutDecorator != null )
+          // Keep the largest size!
+          if( cachedSize < desiredSize )
           {
-            desiredSize = passiveLayoutDecorator.RealDesiredSize.Width;
-
-            if( m_cachedContainerRealDesiredWidth.TryGetValue( dataGridContextName, out cachedSize ) )
-            {
-              // Keep the largest size!
-              if( cachedSize < desiredSize )
-              {
-                m_cachedContainerRealDesiredWidth[ dataGridContextName ] = desiredSize;
-              }
-            }
-            else
-            {
-              // Cache the size for the context.
-              m_cachedContainerRealDesiredWidth.Add( dataGridContextName, desiredSize );
-            }
+            m_cachedContainerRealDesiredWidth[ dataGridContextName ] = desiredSize;
           }
         }
+        else
+        {
+          // Cache the size for the context.
+          m_cachedContainerRealDesiredWidth.Add( dataGridContextName, desiredSize );
+        }
       }
     }
 
     protected override Size ArrangeOverride( Size finalSize )
     {
-      // Never call InvalidateScrollInfo() in there, that can cause infinit invalidation loop.
-      m_lastArrangeFinalSize = finalSize;
+      HashSet<UIElement> layoutedContainers = new HashSet<UIElement>();
+
+      if( m_lastGeneratedPage != TableViewPage.Empty )
+      {
+        var showRowSelector = this.IsRowSelectorPaneVisible();
+        var innerPage = m_lastGeneratedPage.InnerPage;
+        var startIndex = innerPage.Start;
+        var endIndex = innerPage.End;
+        var verticalOffset = 0d;
+
+        foreach( var container in ( from ci in m_layoutedContainers
+                                    let realizedIndex = ci.RealizedIndex
+                                    where ( realizedIndex >= startIndex )
+                                       && ( realizedIndex <= endIndex )
+                                    select ci.Container ) )
+        {
+          layoutedContainers.Add( container );
+
+          this.ArrangeContainer( container, -m_horizontalOffset, verticalOffset, showRowSelector );
+
+          verticalOffset += container.RenderSize.Height;
+        }
+      }
+
+      // Hide the containers that are not visible in the viewport.
+      foreach( var container in this.Children )
+      {
+        if( layoutedContainers.Contains( container ) )
+          continue;
+
+        this.ArrangeContainerOutOfView( container );
+      }
 
-      this.LayoutContainers();
+      CommandManager.InvalidateRequerySuggested();
+
+      // We must not call Mouse.Synchronize if we are currently dragging rows. 
+      // Update the mouse status to make sure no container has invalid mouse over status.
+      // Only do this when the mouse is over the panel, to prevent unescessary update when scrolling with thumb
+      if( ( this.ParentDataGridControl.DragDataObject == null ) && ( this.IsMouseOver ) )
+      {
+        Mouse.Synchronize();
+      }
 
       m_lastLayoutedPage = m_lastGeneratedPage;
-      m_indexToBringIntoView = -1;
+      m_indexToBringIntoView = TableViewItemsHost.NullIndex;
 
       return finalSize;
     }
 
-    private void ArrangeContainer( UIElement container, Point translationPoint, bool rowSelectorPaneVisible )
+    private void ArrangeContainer( UIElement container, double horizontalOffset, double verticalOffset, bool showRowSelector )
     {
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( container );
-      string dataGridContextName = this.GetDataGridContextName( container, dataGridContext );
+      var origin = new Point( horizontalOffset, verticalOffset );
+      var dataGridContext = DataGridControl.GetDataGridContext( container );
+      var dataGridContextName = this.GetDataGridContextName( container, dataGridContext );
+      var containerSize = new Size( this.GetContainerWidth( dataGridContextName ), container.DesiredSize.Height );
 
-      Size containerSize = new Size(
-        this.GetContainerWidth( dataGridContextName ),
-        container.DesiredSize.Height );
+      container.Arrange( new Rect( origin, containerSize ) );
 
-      container.Arrange( new Rect( translationPoint, containerSize ) );
       this.SetCompensationOffset( dataGridContext, container, containerSize.Width );
 
-      if( rowSelectorPaneVisible )
-        this.SetRowSelector( container, translationPoint, containerSize );
+      if( showRowSelector )
+      {
+        this.SetRowSelector( container, origin, containerSize );
+      }
+    }
+
+    private void ArrangeContainerOutOfView( UIElement container )
+    {
+      container.Arrange( TableViewItemsHost.OutOfViewRect );
+
+      this.FreeRowSelector( container );
+    }
+
+    private PassiveLayoutDecorator GetPassiveLayoutDecorator( HeaderFooterItem item )
+    {
+      if( ( item == null ) || ( VisualTreeHelper.GetChildrenCount( item ) == 0 ) )
+        return null;
+
+      DependencyObject firstChild = VisualTreeHelper.GetChild( item, 0 );
+      PassiveLayoutDecorator decorator = firstChild as PassiveLayoutDecorator;
+
+      if( ( decorator == null ) && ( VisualTreeHelper.GetChildrenCount( firstChild ) > 0 ) )
+      {
+        decorator = VisualTreeHelper.GetChild( firstChild, 0 ) as PassiveLayoutDecorator;
+      }
+
+      return decorator;
     }
 
     private double GetContainerWidth( string dataGridContextName )
@@ -358,7 +410,6 @@ namespace Xceed.Wpf.DataGrid.Views
       double desiredWidth = 0;
 
       bool sizeCached = m_cachedContainerDesiredWidth.TryGetValue( dataGridContextName, out desiredWidth );
-
       if( !sizeCached )
       {
         desiredWidth = synchronizedWidth;
@@ -380,12 +431,11 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private double GetSynchronizedExtentWidth()
     {
-      DataGridScrollViewer dgScrollViewer = this.ScrollInfo.ScrollOwner as DataGridScrollViewer;
-
-      if( dgScrollViewer != null )
-        return dgScrollViewer.SynchronizedScrollViewersWidth;
+      var scrollViewer = this.ScrollInfo.ScrollOwner as DataGridScrollViewer;
+      if( scrollViewer == null )
+        return 0d;
 
-      return 0;
+      return scrollViewer.SynchronizedScrollViewersWidth;
     }
 
     private void SetCompensationOffset( DataGridContext dataGridContext, UIElement container, double desiredWidth )
@@ -403,21 +453,16 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void SetRowSelector( UIElement container, Point translationPoint, Size size )
     {
-      RowSelectorPane rowSelectorPane = this.RowSelectorPane;
-
+      var rowSelectorPane = this.RowSelectorPane;
       if( rowSelectorPane == null )
         return;
 
-      rowSelectorPane.SetRowSelectorPosition(
-        container,
-        new Rect( translationPoint, size ),
-        this );
+      rowSelectorPane.SetRowSelectorPosition( container, new Rect( translationPoint, size ), this );
     }
 
     private void FreeRowSelector( UIElement container )
     {
-      RowSelectorPane rowSelectorPane = this.RowSelectorPane;
-
+      var rowSelectorPane = this.RowSelectorPane;
       if( rowSelectorPane == null )
         return;
 
@@ -430,72 +475,76 @@ namespace Xceed.Wpf.DataGrid.Views
 
       foreach( var item in m_cachedContainerDesiredWidth )
       {
-        double desiredWidth = item.Value;
-
+        var desiredWidth = item.Value;
         if( desiredWidth == 0 )
         {
           m_cachedContainerRealDesiredWidth.TryGetValue( item.Key, out desiredWidth );
         }
 
         if( desiredWidth > maxDesiredWidth )
+        {
           maxDesiredWidth = desiredWidth;
+        }
       }
 
       return maxDesiredWidth;
     }
 
-    private Size GetNewDesiredSize( double viewportHeight )
+    private Size GetNewDesiredSize( TableViewPage pageInfo )
     {
+      double desiredHeight;
       double availableHeight = m_lastMeasureAvailableSize.Height;
 
-      if( m_lastGeneratedPage.Length < this.ScrollInfo.ExtentHeight )
-        return new Size( m_viewportWidth, availableHeight );
+      if( pageInfo == TableViewPage.Empty )
+      {
+        desiredHeight = 0d;
+      }
+      // The current generated page displays only a subset of the data source. 
+      else if( pageInfo.InnerPage.Length < this.ScrollInfo.ExtentHeight )
+      {
+        if( double.IsPositiveInfinity( availableHeight ) )
+        {
+          desiredHeight = pageInfo.InnerPage.Size;
+        }
+        else
+        {
+          desiredHeight = availableHeight;
+        }
+      }
+      // The current generated page displays all containers.
+      else
+      {
+        var pageHeight = pageInfo.OuterPage.Size;
+
+        if( double.IsPositiveInfinity( availableHeight ) )
+        {
+          desiredHeight = pageHeight;
+        }
+        else
+        {
+          desiredHeight = Math.Min( availableHeight, pageHeight );
+        }
+      }
 
-      return new Size( m_viewportWidth, ( double.IsInfinity( availableHeight ) ? viewportHeight : Math.Min( availableHeight, viewportHeight ) ) );
+      return new Size( m_viewportWidth, desiredHeight );
     }
 
     #endregion Measure/Arrange Methods
 
     #region Containers Methods
 
-    private Row ExtractRowFromContainer( UIElement container )
-    {
-      Row row = container as Row;
-
-      if( row != null )
-        return row;
-
-      HeaderFooterItem headerFooterItem = container as HeaderFooterItem;
-
-      if( headerFooterItem != null )
-      {
-        // Until the first measure is called, this will always return null.
-        row = HeaderFooterItem.FindIDataGridItemContainerInChildren( headerFooterItem, headerFooterItem.AsVisual() ) as Row;
-      }
-
-      return row;
-    }
-
     private bool ContainerIsRow( UIElement container )
     {
       if( container is Row )
         return true;
 
-      HeaderFooterItem headerFooterItem = container as HeaderFooterItem;
-
+      var headerFooterItem = container as HeaderFooterItem;
       if( headerFooterItem != null )
         return typeof( Row ).IsAssignableFrom( headerFooterItem.VisualRootElementType );
 
       return false;
     }
 
-    private string GetDataGridContextName( UIElement container )
-    {
-      DataGridContext dataGridContext = DataGridControl.GetDataGridContext( container );
-
-      return this.GetDataGridContextName( container, dataGridContext );
-    }
-
     private string GetDataGridContextName( UIElement container, DataGridContext dataGridContext )
     {
       return ( dataGridContext.SourceDetailConfiguration != null )
@@ -503,470 +552,233 @@ namespace Xceed.Wpf.DataGrid.Views
         : string.Empty;
     }
 
-    private void GeneratePage(
-      double availableHeight,
-      bool measureInvalidated,
-      ref PageIndexes generatedPage,
-      out double containersHeight )
+    private TableViewPage GeneratePage( TableViewStartPageInfo pageInfo, double availableHeight, bool forceMeasure )
     {
-      containersHeight = 0d;
-      ICustomItemContainerGenerator generator = this.CustomItemContainerGenerator;
-
       // The generator can be null if we're in design mode.
+      var generator = this.CustomItemContainerGenerator;
       if( generator == null )
-        return;
-
-      // Make sure that container recycling is currently enabled on the generator.
-      generator.IsRecyclingEnabled = true;
+        return m_lastGeneratedPage;
 
-      bool pageChanged =
-        ( generatedPage.StartIndex != m_lastGeneratedPage.StartIndex )
-        || ( m_lastGeneratedPageViewPortHeight != availableHeight );
+      var generatePage = ( forceMeasure )
+                      || ( m_lastGeneratedPage == TableViewPage.Empty )
+                      || ( m_lastGeneratedPage.InnerPage.Start != pageInfo.Start )
+                      || ( Math.Abs( m_lastGeneratedPage.ViewportHeight - availableHeight ) < 1d );
 
-      if( ( pageChanged ) || ( measureInvalidated ) )
-      {
-        UIElement focusedContainer = DataGridItemsHost.GetItemsHostContainerFromElement( this, Keyboard.FocusedElement as DependencyObject );
-        HashSet<UIElement> layoutedContainersToRecycle = new HashSet<UIElement>();
-        int newPageLengthApproximation = Math.Max( 1, m_lastGeneratedPage.Length );
-
-        foreach( LayoutedContainerInfo containerInfo in m_layoutedContainers )
-        {
-          int realizedIndex = containerInfo.RealizedIndex;
-          UIElement container = containerInfo.Container;
-          bool waitForRecycle = ( ( generatedPage.StartIndex != -1 ) && ( realizedIndex >= generatedPage.StartIndex ) && ( realizedIndex <= generatedPage.StartIndex + newPageLengthApproximation ) )
-                             || ( ( generatedPage.EndIndex != -1 ) && ( realizedIndex >= generatedPage.EndIndex - newPageLengthApproximation ) && ( realizedIndex <= generatedPage.EndIndex ) );
+      if( !generatePage )
+        return m_lastGeneratedPage;
 
-          // Mark the container has a candidate for recycling.
-          if( ( waitForRecycle ) || ( container == focusedContainer ) )
-          {
-            layoutedContainersToRecycle.Add( container );
-          }
-          // The element will probably not be on the generated page.  Recycle its container immediatly
-          // to minimize the number of new containers created.
-          else
-          {
-            this.TrySafeRecycleContainer( generator, realizedIndex, container );
+      var pageGenerator = new TopBottomPageGenerator( this, pageInfo.Start, availableHeight, forceMeasure );
 
-            m_layoutedContainersToRecycle.Add( container );
-          }
-        }
+      return this.GeneratePage( pageGenerator );
+    }
 
-        m_layoutedContainers.Clear();
+    private TableViewPage GeneratePage( TableViewEndPageInfo pageInfo, double availableHeight, bool forceMeasure )
+    {
+      // The generator can be null if we're in design mode.
+      var generator = this.CustomItemContainerGenerator;
+      if( generator == null )
+        return m_lastGeneratedPage;
 
-        this.GenerateContainers( generator, availableHeight, layoutedContainersToRecycle, measureInvalidated, ref generatedPage, out containersHeight );
+      var pageGenerator = new BottomTopPageGenerator( this, pageInfo.End, availableHeight, forceMeasure );
 
-        // We do not recycle the focused element!
-        if( layoutedContainersToRecycle.Contains( focusedContainer ) )
-        {
-          layoutedContainersToRecycle.Remove( focusedContainer );
-          m_layoutedContainersToRecycle.Remove( focusedContainer );
-          m_layoutedContainers.Add( new LayoutedContainerInfo( generator.GetRealizedIndexForContainer( focusedContainer ), focusedContainer ) );
-        }
+      return this.GeneratePage( pageGenerator );
+    }
 
-        // Recycle the containers for the current page.
-        this.RecycleContainers( layoutedContainersToRecycle, generator );
+    private TableViewPage GeneratePage( PageGenerator pageGenerator )
+    {
+      var pageResult = pageGenerator.Generate( m_layoutedContainers, m_lastGeneratedPage );
 
-        foreach( UIElement container in layoutedContainersToRecycle )
-        {
-          m_layoutedContainersToRecycle.Add( container );
-        }
+      // Replace the layouted containers.
+      m_layoutedContainers.Clear();
+      m_layoutedContainers.AddRange( pageResult.LayoutedContainers );
+      m_layoutedContainers.Sort();
 
-        m_lastGeneratedPage = generatedPage;
-        m_lastGeneratedPageViewPortHeight = availableHeight;
-        m_lastGeneratedPageContainersHeight = containersHeight;
-      }
-      else
-      {
-        generatedPage = m_lastGeneratedPage;
-        containersHeight = m_lastGeneratedPageContainersHeight;
-      }
-    }
+      m_lastGeneratedPage = pageResult.PageInfo;
 
-    private void RecycleContainers(
-      HashSet<UIElement> layoutedContainersToRecycle,
-      ICustomItemContainerGenerator generator )
-    {
-      foreach( UIElement containerToRecycle in layoutedContainersToRecycle )
-      {
-        this.RecycleContainer( generator, generator.GetRealizedIndexForContainer( containerToRecycle ), containerToRecycle );
-      }
+      return m_lastGeneratedPage;
     }
 
-    private void RecycleContainer( UIElement container )
+    private void RecycleContainer( ICustomItemContainerGenerator generator, LayoutedContainerInfo containerInfo )
     {
-      this.RecycleContainer( null, -1, container );
-    }
+      Debug.Assert( containerInfo != null );
 
-    private void RecycleContainer( ICustomItemContainerGenerator generator, int containerIndex, UIElement container )
-    {
-      if( ( generator != null ) && ( containerIndex != -1 ) )
+      var index = containerInfo.RealizedIndex;
+      if( ( generator != null ) && ( index >= 0 ) )
       {
         try
         {
-          GeneratorPosition position = generator.GeneratorPositionFromIndex( containerIndex );
+          var position = generator.GeneratorPositionFromIndex( index );
           generator.Remove( position, 1 );
         }
         catch
         {
-          Debug.Fail( "Unable to remove container for containerIndex " + containerIndex );
+          Debug.Fail( "Unable to remove container for containerIndex " + index );
         }
       }
 
-      this.DisableElementNavigation( container );
-      this.FreeRowSelector( container );
+      this.ClearContainer( containerInfo.Container );
     }
 
-    private void TrySafeRecycleContainer( ICustomItemContainerGenerator generator, int containerIndex, UIElement container )
+    private UIElement GenerateContainer( ICustomItemContainerGenerator generator, int index, bool forceMeasure )
     {
-      int newIndex = -1;
+      bool isNewlyRealized;
+      var container = ( UIElement )generator.GenerateNext( out isNewlyRealized );
+      if( container == null )
+        return null;
 
-      if( ( generator != null ) && ( containerIndex != -1 ) )
+      if( isNewlyRealized )
       {
-        GeneratorPosition position = generator.GeneratorPositionFromIndex( containerIndex );
-        if( ( position.Index != -1 ) && ( position.Offset == 0 ) )
+        var collection = this.Children;
+        if( !collection.Contains( container ) )
         {
-          newIndex = containerIndex;
+          collection.Add( container );
         }
+
+        this.EnableElementNavigation( container );
+        KeyboardNavigation.SetTabIndex( container, index );
+        this.PrepareContainer( container );
+        this.MeasureContainer( container );
+      }
+      else if( forceMeasure )
+      {
+        this.MeasureContainer( container );
       }
 
-      this.RecycleContainer( generator, newIndex, container );
+      return container;
     }
 
-    private void GenerateContainers(
-      ICustomItemContainerGenerator generator,
-      double pageHeight,
-      HashSet<UIElement> layoutedContainersToRecycle,
-      bool measureInvalidated,
-      ref PageIndexes pageIndexes,
-      out double containersHeight )
+    private void DisableElementNavigation( UIElement child )
     {
-      int currentIndex = pageIndexes.StartIndex;
-      GeneratorDirection direction;
+      //get previous values and store them on the container (attached)
+      TableViewItemsHost.SetPreviousDirectionalNavigationMode( child, KeyboardNavigation.GetDirectionalNavigation( child ) );
+      TableViewItemsHost.SetPreviousTabNavigationMode( child, KeyboardNavigation.GetTabNavigation( child ) );
 
-      if( currentIndex == -1 )
-      {
-        currentIndex = pageIndexes.EndIndex;
-        Debug.Assert( currentIndex != -1 );
-        direction = GeneratorDirection.Backward;
-      }
-      else
+      KeyboardNavigation.SetDirectionalNavigation( child, KeyboardNavigationMode.None );
+      KeyboardNavigation.SetTabNavigation( child, KeyboardNavigationMode.None );
+    }
+
+    private void EnableElementNavigation( UIElement child )
+    {
+      //checking only one of the 2 properties... This is because they are set together.
+      if( child.ReadLocalValue( TableViewItemsHost.PreviousDirectionalNavigationModeProperty ) != DependencyProperty.UnsetValue )
       {
-        direction = GeneratorDirection.Forward;
+        KeyboardNavigation.SetDirectionalNavigation( child, TableViewItemsHost.GetPreviousDirectionalNavigationMode( child ) );
+        KeyboardNavigation.SetTabNavigation( child, TableViewItemsHost.GetPreviousTabNavigationMode( child ) );
       }
+      //If unset, then nothing to do in this method!
+    }
 
-      int startIndex = currentIndex;
-      int endIndex = currentIndex;
-      containersHeight = 0d;
-      GeneratorPosition position;
+    private void PrepareContainer( UIElement container )
+    {
+      container.ClearValue( UIElement.VisibilityProperty );
 
-      position = generator.GeneratorPositionFromIndex( currentIndex );
-      int itemCount = generator.ItemCount;
+      var dataItemStore = Xceed.Wpf.DataGrid.CustomItemContainerGenerator.GetDataItemProperty( container );
+      if( ( dataItemStore == null ) || dataItemStore.IsEmpty )
+        return;
 
-      using( generator.StartAt( position, direction, true ) )
-      {
-        while( ( ( direction == GeneratorDirection.Forward )
-          ? ( currentIndex < itemCount ) : ( currentIndex >= 0 ) ) && ( pageHeight > 0 ) )
-        {
-          UIElement container = this.GenerateContainer( generator, currentIndex, measureInvalidated );
+      var dataItem = dataItemStore.Data;
+      if( dataItem == null )
+        return;
 
-          if( container == null )
-            break;
+      // Prepare the container.
+      this.ParentDataGridControl.PrepareItemContainer( container, dataItem );
+    }
 
-          double containerHeight = container.DesiredSize.Height;
+    private void ClearContainer( UIElement container )
+    {
+      this.DisableElementNavigation( container );
+      this.FreeRowSelector( container );
 
-          m_layoutedContainers.Add( new LayoutedContainerInfo( currentIndex, container ) );
-          layoutedContainersToRecycle.Remove( container );
-          m_layoutedContainersToRecycle.Remove( container );
+      container.Visibility = Visibility.Collapsed;
 
-          if( ( direction == GeneratorDirection.Backward ) && ( ( pageHeight - containerHeight ) < 0 ) )
-          {
-            // We do not want to recycle the container since it will cause a re-invalidation of the measure and 
-            // may cause an infinit loop.  This case has been observed with a MaxHeight set on the DataGridControl.
-            break;
-          }
+    }
 
-          pageHeight -= containerHeight;
-          containersHeight += containerHeight;
-          endIndex = currentIndex;
-          currentIndex += ( direction == GeneratorDirection.Forward ) ? 1 : -1;
-        }
-      }
+    #endregion Containers Methods
+
+    #region Scrolling Management
+
+    internal void InvalidateScrollInfo()
+    {
+      var scrollOwner = this.ScrollInfo.ScrollOwner;
+      if( scrollOwner == null )
+        return;
+
+      scrollOwner.InvalidateScrollInfo();
+    }
 
-      if( pageHeight > 0 )
+    private void GeneratePageAndUpdateIScrollInfoValues()
+    {
+      if( this.CachedRootDataGridContext != null )
       {
-        if( direction == GeneratorDirection.Forward )
+        var generatedPage = this.GeneratePageAndUpdateIScrollInfoValues( m_lastMeasureAvailableSize, false );
+        var newDesiredSize = this.GetNewDesiredSize( generatedPage );
+
+        if( newDesiredSize != this.DesiredSize )
         {
-          direction = GeneratorDirection.Backward;
+          this.InvalidateMeasure();
         }
         else
         {
-          direction = GeneratorDirection.Forward;
-        }
-
-        DataGridContext dataGridContext = DataGridControl.GetDataGridContext( this );
-
-        if( ( direction == GeneratorDirection.Forward ) || ( ( dataGridContext == null ) || ( TableView.GetAutoFillLastPage( dataGridContext ) ) ) )
-        {
-          currentIndex = ( direction == GeneratorDirection.Forward ) ? startIndex + 1 : startIndex - 1;
-
-          if( ( direction == GeneratorDirection.Forward ) ? ( currentIndex < itemCount ) : ( currentIndex >= 0 ) )
-          {
-            position = generator.GeneratorPositionFromIndex( currentIndex );
-
-            using( generator.StartAt( position, direction, true ) )
-            {
-              // If we still have more space, try to get more container to fill up the page.
-              while( ( ( direction == GeneratorDirection.Forward ) ?
-                ( currentIndex < itemCount ) : ( currentIndex >= 0 ) ) && ( pageHeight > 0 ) )
-              {
-                UIElement container = this.GenerateContainer( generator, currentIndex, measureInvalidated );
-
-                if( container == null )
-                  break;
-
-                double containerHeight = container.DesiredSize.Height;
-                pageHeight -= containerHeight;
-
-                m_layoutedContainers.Add( new LayoutedContainerInfo( currentIndex, container ) );
-                layoutedContainersToRecycle.Remove( container );
-                m_layoutedContainersToRecycle.Remove( container );
-
-                if( ( direction == GeneratorDirection.Backward ) && ( pageHeight < 0 ) )
-                {
-                  // We do not want to recycle the container since it will cause a re-invalidation of the measure and 
-                  // may cause an infinit loop.  This case has been observed with a MaxHeight set on the DataGridControl.
-                  break;
-                }
-
-                containersHeight += containerHeight;
-                startIndex = currentIndex;
-                currentIndex += ( direction == GeneratorDirection.Forward ) ? 1 : -1;
-              }
-            }
-          }
+          this.InvalidateArrange();
         }
       }
-
-      m_layoutedContainers.Sort();
-
-      if( startIndex > endIndex )
-      {
-        pageIndexes = new PageIndexes( endIndex, startIndex );
-      }
       else
       {
-        pageIndexes = new PageIndexes( startIndex, endIndex );
+        this.InvalidateAutomationPeerChildren();
       }
     }
 
-    private UIElement GenerateContainer( ICustomItemContainerGenerator generator, int index, bool measureInvalidated )
+    private TableViewPage GeneratePageAndUpdateIScrollInfoValues( Size availableSize, bool forceMeasure )
     {
-      bool isNewlyRealized;
-      UIElement container = ( UIElement )generator.GenerateNext( out isNewlyRealized );
+      // We must ensure the VerticalOffset is valid according
+      // to the actual viewport height in case the VerticalOffset
+      // is greater than the new viewportHeight.
+      var scrollInfo = this.ScrollInfo;
 
-      if( container != null )
+      double maxOffset = Math.Max( 0d, scrollInfo.ExtentHeight - 1 );
+      double offset = Math.Max( Math.Min( m_verticalOffset, maxOffset ), 0d );
+
+      if( offset != m_verticalOffset )
       {
-        if( isNewlyRealized )
-        {
-          if( !this.Children.Contains( container ) )
-          {
-            this.Children.Add( container );
-          }
+        this.SetVerticalOffsetCore( offset );
+      }
 
-          this.EnableElementNavigation( container );
-          KeyboardNavigation.SetTabIndex( container, index );
-          this.PrepareContainer( container );
-        }
+      int verticalOffset = ( int )m_verticalOffset;
+      TableViewPage generatedPage;
+
+      if( m_indexToBringIntoView >= 0 )
+      {
+        int intOffset = Math.Min( m_indexToBringIntoView, ( int )maxOffset );
 
-        if( ( isNewlyRealized ) || ( measureInvalidated ) )
+        if( ( m_lastLayoutedPage == TableViewPage.Empty ) || ( intOffset < m_lastLayoutedPage.InnerPage.Start ) )
         {
-          this.MeasureContainer( container );
+          generatedPage = this.GeneratePage( new TableViewStartPageInfo( intOffset ), availableSize.Height, forceMeasure );
         }
+        else
+        {
+          generatedPage = this.GeneratePage( new TableViewEndPageInfo( intOffset ), availableSize.Height, forceMeasure );
+        }
+      }
+      else
+      {
+        generatedPage = this.GeneratePage( new TableViewStartPageInfo( verticalOffset ), availableSize.Height, forceMeasure );
       }
 
-      return container;
-    }
+      // CALCULATE THE EXTENT WIDTH
+      m_extentWidth = Math.Max( this.GetMaxDesiredWidth(), this.GetSynchronizedExtentWidth() );
 
-    private bool IsRowSelectorPaneVisible()
-    {
-      DataGridControl parentDataGridControl = this.ParentDataGridControl;
+      // CALCULATE THE VIEWPORT WIDTH
+      m_viewportWidth = Double.IsInfinity( availableSize.Width ) ? m_extentWidth : Math.Min( m_extentWidth, availableSize.Width );
 
-      if( parentDataGridControl != null )
+      if( generatedPage != TableViewPage.Empty )
       {
-        TableViewScrollViewer scrollViewer = parentDataGridControl.ScrollViewer as TableViewScrollViewer;
-        RowSelectorPane rowSelectorPane = ( scrollViewer != null ) ? scrollViewer.RowSelectorPane : null;
-
-        if( rowSelectorPane != null )
-          return ( rowSelectorPane.Visibility == Visibility.Visible );
+        this.SetVerticalOffsetCore( generatedPage.InnerPage.Start );
       }
 
-      return false;
-    }
-
-    private void LayoutContainers()
-    {
-      bool rowSelectorPaneVisible = this.IsRowSelectorPaneVisible();
-      this.LayoutContainers( rowSelectorPaneVisible );
-      CommandManager.InvalidateRequerySuggested();
-
-      // We must not call Mouse.Synchronize if we are currently dragging rows. 
-      // Update the mouse status to make sure no container has invalid mouse over status.
-      // Only do this when the mouse is over the panel, to prevent unescessary update when scrolling with thumb
-      if( ( this.ParentDataGridControl.DragDataObject == null ) && ( this.IsMouseOver ) )
-      {
-        Mouse.Synchronize();
-      }
-    }
-
-    private void LayoutContainers( bool rowSelectorPaneVisible )
-    {
-      int count = m_layoutedContainers.Count;
-      double currentOffset = 0;
-
-      // Layout out of view the recycled containers.
-      foreach( UIElement container in m_layoutedContainersToRecycle )
-      {
-        this.ArrangeContainer( container, TableViewItemsHost.OutOfViewPoint, false );
-      }
-
-      m_layoutedContainersToRecycle.Clear();
-      m_layoutedContainersToRecycle.TrimExcess();
-
-      for( int i = 0; i < count; i++ )
-      {
-        LayoutedContainerInfo layoutedContainerInfo = m_layoutedContainers[ i ];
-        UIElement container = layoutedContainerInfo.Container;
-        Point translationPoint;
-
-        if( ( layoutedContainerInfo.RealizedIndex < m_lastGeneratedPage.StartIndex )
-          || ( layoutedContainerInfo.RealizedIndex > m_lastGeneratedPage.EndIndex ) )
-        {
-          translationPoint = new Point( -m_horizontalOffset, TableViewItemsHost.OutOfViewPoint.Y );
-          this.ArrangeContainer( container, translationPoint, rowSelectorPaneVisible );
-        }
-        else
-        {
-          translationPoint = new Point( -m_horizontalOffset, currentOffset );
-          this.ArrangeContainer( container, translationPoint, rowSelectorPaneVisible );
-          currentOffset += container.RenderSize.Height;
-        }
-      }
-    }
-
-    private void DisableElementNavigation( UIElement child )
-    {
-      //get previous values and store them on the container (attached)
-      TableViewItemsHost.SetPreviousDirectionalNavigationMode( child, KeyboardNavigation.GetDirectionalNavigation( child ) );
-      TableViewItemsHost.SetPreviousTabNavigationMode( child, KeyboardNavigation.GetTabNavigation( child ) );
-
-      KeyboardNavigation.SetDirectionalNavigation( child, KeyboardNavigationMode.None );
-      KeyboardNavigation.SetTabNavigation( child, KeyboardNavigationMode.None );
-    }
-
-    private void EnableElementNavigation( UIElement child )
-    {
-      //checking only one of the 2 properties... This is because they are set together.
-      if( child.ReadLocalValue( TableViewItemsHost.PreviousDirectionalNavigationModeProperty ) != DependencyProperty.UnsetValue )
-      {
-        KeyboardNavigation.SetDirectionalNavigation( child, TableViewItemsHost.GetPreviousDirectionalNavigationMode( child ) );
-        KeyboardNavigation.SetTabNavigation( child, TableViewItemsHost.GetPreviousTabNavigationMode( child ) );
-      }
-      //If unset, then nothing to do in this method!
-    }
-
-    private void PrepareContainer( UIElement container )
-    {
-      object dataItem = container.GetValue( Xceed.Wpf.DataGrid.CustomItemContainerGenerator.DataItemPropertyProperty );
-
-      if( dataItem != null )
-      {
-        // Prepare the container.
-        this.ParentDataGridControl.PrepareItemContainer( container, dataItem );
-      }
-    }
-
-    #endregion Containers Methods
-
-    #region Scrolling Management
-
-    internal void InvalidateScrollInfo()
-    {
-      ScrollViewer scrollOwner = this.ScrollInfo.ScrollOwner;
-
-      if( scrollOwner != null )
-      {
-        scrollOwner.InvalidateScrollInfo();
-      }
-    }
-
-    private void GeneratePageAndUpdateIScrollInfoValues()
-    {
-      Size availableSize = m_lastMeasureAvailableSize;
-      double viewportHeight = availableSize.Height;
-
-      this.GeneratePageAndUpdateIScrollInfoValues( availableSize, false, ref viewportHeight );
-
-      Size newDesiredSize = this.GetNewDesiredSize( viewportHeight );
-      if( newDesiredSize != this.DesiredSize )
-      {
-        this.InvalidateMeasure();
-      }
-      else
-      {
-        this.InvalidateArrange();
-      }
-    }
-
-    private void GeneratePageAndUpdateIScrollInfoValues(
-      Size availableSize,
-      bool measureInvalidated,
-      ref double viewportHeight )
-    {
-      PageIndexes generatedPage;
-
-      // We must ensure the VerticalOffset is valid according
-      // to the actual viewport height in case the VerticalOffset
-      // is greater than the new viewportHeight.
-      IScrollInfo scrollInfo = this as IScrollInfo;
-
-      double maxOffset = Math.Max( 0d, scrollInfo.ExtentHeight - 1 );
-      double offset = Math.Max( Math.Min( m_verticalOffset, maxOffset ), 0d );
-
-      if( offset != m_verticalOffset )
-        this.SetVerticalOffsetCore( offset );
-
-      int verticalOffset = ( int )m_verticalOffset;
-
-      if( m_indexToBringIntoView != -1 )
-      {
-        int intOffset = Math.Min( m_indexToBringIntoView, ( int )maxOffset );
-
-        if( intOffset < m_lastLayoutedPage.StartIndex )
-        {
-          generatedPage = new PageIndexes( intOffset, -1 );
-        }
-        else
-        {
-          generatedPage = new PageIndexes( -1, intOffset );
-        }
-      }
-      else
-      {
-        generatedPage = new PageIndexes( verticalOffset, -1 );
-      }
-
-      // CALCULATE THE VIEWPORT HEIGHT AND GENERATE CONTAINERS
-      this.GeneratePage( availableSize.Height, measureInvalidated, ref generatedPage, out viewportHeight );
-
-      // CALCULATE THE EXTENT WIDTH
-      m_extentWidth = Math.Max( this.GetMaxDesiredWidth(), this.GetSynchronizedExtentWidth() );
-
-      // CALCULATE THE VIEWPORT WIDTH
-      m_viewportWidth = Double.IsInfinity( availableSize.Width )
-        ? m_extentWidth : Math.Min( m_extentWidth, availableSize.Width );
-
-      this.SetVerticalOffsetCore( generatedPage.StartIndex );
       this.InvalidateScrollInfo();
+      this.InvalidateAutomationPeerChildren();
+
+      return generatedPage;
     }
 
     private void ScrollByHorizontalOffset( double offset )
@@ -1042,24 +854,24 @@ namespace Xceed.Wpf.DataGrid.Views
           m_layoutedContainers.Add( new LayoutedContainerInfo( index, container ) );
         }
 
-        DataGridContext dataGridContext = DataGridControl.GetDataGridContext( container );
-        ColumnBase column = ( changeColumn ) ? dataGridContext.CurrentColumn : null;
+        var dataGridContext = DataGridControl.GetDataGridContext( container );
+        var column = ( changeColumn ) ? dataGridContext.CurrentColumn : null;
 
         // if the current column is null or is (for an unknown reason) set to current but is readOnly, 
         // try to set a new current column
         if( ( isDataRow )
           && ( ( changeColumn ) && ( ( column == null ) || ( !column.CanBeCurrentWhenReadOnly && column.ReadOnly ) ) ) )
         {
-          int focusableIndex = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( dataGridContext );
-
+          var focusableIndex = NavigationHelper.GetFirstVisibleFocusableColumnIndex( dataGridContext );
           if( focusableIndex >= 0 )
+          {
             column = dataGridContext.VisibleColumns[ focusableIndex ];
+          }
         }
 
         try
         {
-          DataGridContext currentContext = dataGridContext.DataGridControl.CurrentContext;
-
+          var currentContext = dataGridContext.DataGridControl.CurrentContext;
           if( currentContext != null )
           {
             currentContext.EndEdit();
@@ -1105,7 +917,6 @@ namespace Xceed.Wpf.DataGrid.Views
       if( desiredIndex != focusedIndex )
       {
         DataGridControl dataGridControl = this.ParentDataGridControl;
-
         int cannotFocusCount = 0;
 
         // We want to find the first element that can receive focus upward.
@@ -1128,25 +939,28 @@ namespace Xceed.Wpf.DataGrid.Views
             }
           }
 
-          // We succeded in changing the current or we're already 
-          // at the first index? Then nothing we can do.
-          if( ( currentChanged )
-            || ( desiredIndex == firstIndex ) )
+          // We succeded in changing the current.
+          if( currentChanged )
+            break;
+
+          // We already are at the first index and still not focused on a new container.
+          if( desiredIndex == firstIndex )
           {
+            //Let's keep the focus on the last focused container.
+            currentChanged = this.SetCurrent( focusedIndex, changeColumn, out isDataRow );
             break;
           }
 
           desiredIndex--;
         }
 
-        LayoutedContainerInfo layoutedContainer = m_layoutedContainers[ focusedContainer ];
-
-        // We will use MoveFocus if the focused index is currently in view.
-        if( ( !currentChanged )
-          && ( focusedIndex >= m_lastGeneratedPage.StartIndex )
-          && ( focusedIndex <= m_lastGeneratedPage.EndIndex ) )
+        if( m_lastGeneratedPage != TableViewPage.Empty )
         {
-          currentChanged = this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Up ) );
+          // We will use MoveFocus if the focused index is currently in view.
+          if( ( !currentChanged ) && ( focusedIndex >= m_lastGeneratedPage.InnerPage.Start ) && ( focusedIndex <= m_lastGeneratedPage.InnerPage.End ) )
+          {
+            currentChanged = this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Up ) );
+          }
         }
       }
 
@@ -1156,9 +970,7 @@ namespace Xceed.Wpf.DataGrid.Views
     private bool FocusIndexOrPreviousFocusable( int desiredIndex, int minimumIndex, bool changeColumn )
     {
       bool currentChanged = false;
-
       DataGridControl dataGridControl = this.ParentDataGridControl;
-
       int cannotFocusCount = 0;
 
       // We want to find the first element that can receive focus upward.
@@ -1181,13 +993,9 @@ namespace Xceed.Wpf.DataGrid.Views
           }
         }
 
-        // We succeded in changing the current or we're already 
-        // at the first index? Then nothing we can do.
-        if( ( currentChanged )
-          || ( desiredIndex == minimumIndex ) )
-        {
+        // We succeded in changing the current or we're already at the first index? Then nothing we can do.
+        if( ( currentChanged ) || ( desiredIndex == minimumIndex ) )
           break;
-        }
 
         desiredIndex--;
       }
@@ -1208,7 +1016,6 @@ namespace Xceed.Wpf.DataGrid.Views
       if( desiredIndex != focusedIndex )
       {
         DataGridControl dataGridControl = this.ParentDataGridControl;
-
         int cannotFocusCount = 0;
 
         // We want to find the first element that can receive focus downward.
@@ -1231,25 +1038,27 @@ namespace Xceed.Wpf.DataGrid.Views
             }
           }
 
-          // We succeded in changing the current or we're already 
-          // at the first index? Then nothing we can do.
-          if( ( currentChanged )
-            || ( desiredIndex == lastIndex ) )
-          {
+          // We succeded in changing the current.
+          if( currentChanged )
             break;
+
+          // We already are at the last index and still not focused on a new container.
+          if( desiredIndex == lastIndex )
+          {
+            //Let's keep the focus on the last focused container.
+            currentChanged = this.SetCurrent( focusedIndex, changeColumn, out isDataRow );
           }
 
           desiredIndex++;
         }
 
-        LayoutedContainerInfo layoutedContainer = m_layoutedContainers[ focusedContainer ];
-
-        // We will use MoveFocus if the focused index is currently in view.
-        if( ( !currentChanged )
-          && ( focusedIndex >= m_lastGeneratedPage.StartIndex )
-          && ( focusedIndex <= m_lastGeneratedPage.EndIndex ) )
+        if( m_lastGeneratedPage != TableViewPage.Empty )
         {
-          currentChanged = this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Down ) );
+          // We will use MoveFocus if the focused index is currently in view.
+          if( ( !currentChanged ) && ( focusedIndex >= m_lastGeneratedPage.InnerPage.Start ) && ( focusedIndex <= m_lastGeneratedPage.InnerPage.End ) )
+          {
+            currentChanged = this.MoveFocus( new TraversalRequest( FocusNavigationDirection.Down ) );
+          }
         }
       }
 
@@ -1259,9 +1068,7 @@ namespace Xceed.Wpf.DataGrid.Views
     private bool FocusIndexOrNextFocusable( int desiredIndex, int maximumIndex, bool changeColumn )
     {
       bool currentChanged = false;
-
       DataGridControl dataGridControl = this.ParentDataGridControl;
-
       int cannotFocusCount = 0;
 
       // We want to find the first element that can receive focus downward.
@@ -1284,13 +1091,9 @@ namespace Xceed.Wpf.DataGrid.Views
           }
         }
 
-        // We succeded in changing the current or we're already 
-        // at the first index? Then nothing we can do.
-        if( ( currentChanged )
-          || ( desiredIndex == maximumIndex ) )
-        {
+        // We succeded in changing the current or we're already at the first index? Then nothing we can do.
+        if( ( currentChanged ) || ( desiredIndex == maximumIndex ) )
           break;
-        }
 
         desiredIndex++;
       }
@@ -1364,19 +1167,18 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected override void OnContainersRemoved( IList<DependencyObject> removedContainers )
     {
-      foreach( UIElement element in removedContainers )
+      foreach( UIElement container in removedContainers )
       {
-        this.RecycleContainer( element );
+        this.ClearContainer( container );
 
         // Avoid checking if Children already contains
         // the element. No exception will be thrown
         // if the item is not found. This ensure to
         // at parse all the children only 1 time as
         // worst scenario
-        this.Children.Remove( element );
-
-        int index = m_layoutedContainers.IndexOfContainer( element );
+        this.Children.Remove( container );
 
+        int index = m_layoutedContainers.IndexOfContainer( container );
         if( index > -1 )
         {
           m_layoutedContainers.RemoveAt( index );
@@ -1393,155 +1195,15 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
+      var dataGridControl = this.ParentDataGridControl;
       if( dataGridControl == null )
         return;
 
-      DataGridContext currentDataGridContext = dataGridControl.CurrentContext;
-
-      if( currentDataGridContext == null )
-        return;
-
-      // Only process tab in a special way when the grid has focus and is
-      // being edited
-      if( !dataGridControl.IsKeyboardFocusWithin || !dataGridControl.IsBeingEdited )
+      var dataGridContext = dataGridControl.CurrentContext;
+      if( dataGridContext == null )
         return;
 
-      DependencyObject predictedNextVisual = null;
-
-      //If the original source is not a control (e.g. the cells panel instead of a cell), columns will be used to move focus.
-      Control originalSource = e.OriginalSource as Control;
-      if( originalSource != null )
-      {
-        if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-        {
-          predictedNextVisual = ( e.OriginalSource as Control ).PredictFocus( FocusNavigationDirection.Left );
-        }
-        else
-        {
-          predictedNextVisual = ( e.OriginalSource as Control ).PredictFocus( FocusNavigationDirection.Right );
-        }
-      }
-
-      if( predictedNextVisual != null )
-      {
-        Cell ownerCell = Cell.FindFromChild( predictedNextVisual );
-
-        if( ( ownerCell != null ) && ( ownerCell.ParentColumn == dataGridControl.CurrentColumn ) )
-        {
-          if( object.Equals( ownerCell.ParentRow.DataContext, dataGridControl.CurrentItemInEdition ) )
-            return;
-        }
-      }
-
-      int visibleColumnCount = currentDataGridContext.VisibleColumns.Count;
-      ReadOnlyObservableCollection<ColumnBase> visibleColumns = currentDataGridContext.VisibleColumns;
-
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
-
-      if( currentColumn == null )
-      {
-        int firstFocusableColumn = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( currentDataGridContext );
-
-        if( firstFocusableColumn < 0 )
-          throw new DataGridException( "Trying to edit while no cell is focusable. " );
-
-        try
-        {
-          currentDataGridContext.SetCurrentColumnAndChangeSelection( currentDataGridContext.VisibleColumns[ firstFocusableColumn ] );
-        }
-        catch( DataGridException )
-        {
-          // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-          // any other GridException.
-        }
-
-        e.Handled = true;
-      }
-      else
-      {
-        if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Shift ) == ModifierKeys.Shift )
-        {
-          int previousColumnVisiblePosition = DataGridScrollViewer.GetPreviousVisibleFocusableColumnIndex( currentDataGridContext );
-
-          if( previousColumnVisiblePosition < visibleColumnCount )
-          {
-            if( previousColumnVisiblePosition >= 0 )
-            {
-              try
-              {
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ previousColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-            else
-            {
-              previousColumnVisiblePosition = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( currentDataGridContext );
-
-              if( previousColumnVisiblePosition < 0 )
-                throw new DataGridException( "Trying to edit while no cell is focusable. " );
-
-              try
-              {
-                // Wrap around to the last column
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ previousColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-            e.Handled = true;
-          }
-        }
-        else
-        {
-          int nextColumnVisiblePosition = DataGridScrollViewer.GetNextVisibleFocusableColumnIndex( currentDataGridContext );
-
-          // If previous Column VisiblePosition is greater than 0 and
-          // less than the total VisibleColumn count, affect it
-          if( nextColumnVisiblePosition >= 0 )
-          {
-            if( nextColumnVisiblePosition < visibleColumnCount )
-            {
-              try
-              {
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ nextColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-            else
-            {
-              nextColumnVisiblePosition = DataGridScrollViewer.GetFirstVisibleFocusableColumnIndex( currentDataGridContext );
-
-              if( nextColumnVisiblePosition < 0 )
-                throw new DataGridException( "Trying to edit while no cell is focusable. " );
-
-              try
-              {
-                currentDataGridContext.SetCurrentColumnAndChangeSelection( visibleColumns[ nextColumnVisiblePosition ] );
-              }
-              catch( DataGridException )
-              {
-                // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-                // any other GridException.
-              }
-            }
-
-            e.Handled = true;
-          }
-        }
-      }
+      e.Handled = NavigationHelper.HandleTabKey( dataGridControl, dataGridContext, e.OriginalSource as FrameworkElement, e.KeyboardDevice );
     }
 
     protected override void HandleLeftKey( KeyEventArgs e )
@@ -1549,7 +1211,11 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      e.Handled = this.MoveFocusLeft();
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusLeft( dataGridControl.CurrentContext );
     }
 
     protected override void HandleRightKey( KeyEventArgs e )
@@ -1557,7 +1223,11 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      e.Handled = this.MoveFocusRight();
+      var dataGridControl = this.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusRight( dataGridControl.CurrentContext );
     }
 
     protected override void HandleUpKey( KeyEventArgs e )
@@ -1589,9 +1259,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
       if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
       {
-        // Simply scroll to top and set first index as current
-        this.ScrollInfo.ScrollOwner.ScrollToTop();
-        this.SetCurrent( 0, changeCurrentColumn );
+        this.MoveToFirstOverallUIElement( changeCurrentColumn );
         return;
       }
 
@@ -1613,46 +1281,45 @@ namespace Xceed.Wpf.DataGrid.Views
       else
       {
         this.InvalidateMeasure();
-        double containersHeight;
-        PageIndexes generatedPage = new PageIndexes( -1, focusedContainerRealizedIndex );
-        this.GeneratePage( this.RenderSize.Height, false, ref generatedPage, out containersHeight );
-        this.SetVerticalOffsetCore( generatedPage.StartIndex );
-        int initialDesiredIndex = generatedPage.StartIndex;
 
-        if( focusedContainerRealizedIndex != initialDesiredIndex )
-        {
-          int desiredPageUpIndex = initialDesiredIndex;
+        var generatedPage = this.GeneratePage( new TableViewEndPageInfo( focusedContainerRealizedIndex ), this.RenderSize.Height, false );
 
-          bool isDataRow = false;
+        if( generatedPage != TableViewPage.Empty )
+        {
+          int initialDesiredIndex = generatedPage.InnerPage.Start;
+          this.SetVerticalOffsetCore( initialDesiredIndex );
 
-          // SetCurrent on the index or down to a focusable index
-          while( ( !dataGridControl.HasValidationError )
-              && ( !isDataRow )
-              && ( desiredPageUpIndex < focusedContainerRealizedIndex ) )
+          if( focusedContainerRealizedIndex != initialDesiredIndex )
           {
-            if( this.SetCurrent( desiredPageUpIndex, changeCurrentColumn, out isDataRow ) )
-              return;
+            int desiredPageUpIndex = initialDesiredIndex;
+            bool isDataRow = false;
 
-            desiredPageUpIndex++;
-          }
-
-          if( ( dataGridControl.HasValidationError ) || ( isDataRow ) )
-            return;
+            // SetCurrent on the desired index or down until BEFORE the focused container.
+            while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageUpIndex < focusedContainerRealizedIndex ) )
+            {
+              if( this.SetCurrent( desiredPageUpIndex, changeCurrentColumn, out isDataRow ) )
+                return;
 
-          // No container were focused while processing indexes from focused to 
-          // initialDesiredIndex, try SetCurrent on indexes lower than
-          // the initial up to 0
-          desiredPageUpIndex = initialDesiredIndex - 1;
-          isDataRow = false;
+              desiredPageUpIndex++;
+            }
 
-          while( ( !dataGridControl.HasValidationError )
-              && ( !isDataRow )
-              && ( desiredPageUpIndex > 0 ) )
-          {
-            if( this.SetCurrent( desiredPageUpIndex, changeCurrentColumn, out isDataRow ) )
+            if( ( dataGridControl.HasValidationError ) || ( isDataRow ) )
               return;
 
-            desiredPageUpIndex--;
+            // No container were focused while processing indexes from focused to initialDesiredIndex, try SetCurrent on indexes samller than the initial up to 0
+            desiredPageUpIndex = initialDesiredIndex - 1;
+            isDataRow = false;
+
+            while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageUpIndex > 0 ) )
+            {
+              if( this.SetCurrent( desiredPageUpIndex, changeCurrentColumn, out isDataRow ) )
+                return;
+
+              desiredPageUpIndex--;
+            }
+
+            // If not container was successfuly focused, set focus back to the current UIElement.
+            this.SetCurrent( focusedContainerRealizedIndex, changeCurrentColumn, out isDataRow );
           }
         }
       }
@@ -1664,16 +1331,14 @@ namespace Xceed.Wpf.DataGrid.Views
         return;
 
       e.Handled = true;
+
       DataGridControl dataGridControl = this.ParentDataGridControl;
       NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
       bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
 
-      // CTRL + PageDown
       if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
       {
-        // Simply scroll to bottom and set last index as current
-        this.ScrollInfo.ScrollOwner.ScrollToBottom();
-        this.SetCurrent( this.CustomItemContainerGenerator.ItemCount - 1, changeCurrentColumn );
+        this.MoveToLastOverallUIElement( changeCurrentColumn );
         return;
       }
 
@@ -1687,9 +1352,8 @@ namespace Xceed.Wpf.DataGrid.Views
         return;
       }
 
-      int generatorItemCount = this.CustomItemContainerGenerator.ItemCount;
       int focusedContainerRealizedIndex = this.CustomItemContainerGenerator.GetRealizedIndexForContainer( focusedContainer );
-      int maxIndex = generatorItemCount - 1;
+      int maxIndex = this.CustomItemContainerGenerator.ItemCount - 1;
 
       if( focusedContainerRealizedIndex == maxIndex )
       {
@@ -1698,58 +1362,55 @@ namespace Xceed.Wpf.DataGrid.Views
       else
       {
         this.InvalidateMeasure();
-        double containersHeight;
-        PageIndexes generatedPage = new PageIndexes( focusedContainerRealizedIndex, -1 );
-        this.GeneratePage( this.RenderSize.Height, false, ref generatedPage, out containersHeight );
-        this.SetVerticalOffsetCore( generatedPage.StartIndex );
-        int initialDesiredIndex;
 
-        // Last row not totally visible, take the one before the last
-        if( ( containersHeight > this.RenderSize.Height ) && ( generatedPage.Length > 1 ) )
-        {
-          initialDesiredIndex = generatedPage.EndIndex - 1;
-        }
-        else
-        {
-          initialDesiredIndex = generatedPage.EndIndex;
-        }
+        var generatedPage = this.GeneratePage( new TableViewStartPageInfo( focusedContainerRealizedIndex ), this.RenderSize.Height, false );
 
-        if( focusedContainerRealizedIndex != initialDesiredIndex )
+        if( generatedPage != TableViewPage.Empty )
         {
-          int desiredPageDownIndex = initialDesiredIndex;
+          this.SetVerticalOffsetCore( generatedPage.InnerPage.Start );
+          int initialDesiredIndex;
 
-          bool isDataRow = false;
-
-          // SetCurrent on the index or up to focusedContainerRealizedIndex to a focusable index 
-
-          while( ( !dataGridControl.HasValidationError )
-              && ( !isDataRow )
-              && ( desiredPageDownIndex > focusedContainerRealizedIndex ) )
+          // Last row not totally visible, take the one before the last
+          if( ( generatedPage.InnerPage.Size > this.RenderSize.Height ) && ( generatedPage.InnerPage.Length > 1 ) )
           {
-            if( this.SetCurrent( desiredPageDownIndex, changeCurrentColumn, out isDataRow ) )
-              return;
-
-            desiredPageDownIndex--;
+            initialDesiredIndex = generatedPage.InnerPage.End - 1;
           }
+          else
+          {
+            initialDesiredIndex = generatedPage.InnerPage.End;
+          }
+
+          if( focusedContainerRealizedIndex != initialDesiredIndex )
+          {
+            int desiredPageDownIndex = initialDesiredIndex;
+            bool isDataRow = false;
 
-          if( ( dataGridControl.HasValidationError ) || ( isDataRow ) )
-            return;
+            // SetCurrent on the desired index or up until BEFORE the focused container.
+            while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageDownIndex > focusedContainerRealizedIndex ) )
+            {
+              if( this.SetCurrent( desiredPageDownIndex, changeCurrentColumn, out isDataRow ) )
+                return;
 
-          //Debug.Assert( false, "When this will occur???" );
-          desiredPageDownIndex = initialDesiredIndex + 1;
-          isDataRow = false;
+              desiredPageDownIndex--;
+            }
 
-          // No container were focused while processing indexes from focused to 
-          // initialDesiredIndex, try SetCurrent on indexes higher than
-          // the initial down to maxIndex
-          while( ( !dataGridControl.HasValidationError )
-              && ( !isDataRow )
-              && ( desiredPageDownIndex <= maxIndex ) )
-          {
-            if( this.SetCurrent( desiredPageDownIndex, changeCurrentColumn, out isDataRow ) )
+            if( ( dataGridControl.HasValidationError ) || ( isDataRow ) )
               return;
 
-            desiredPageDownIndex++;
+            desiredPageDownIndex = initialDesiredIndex + 1;
+            isDataRow = false;
+
+            // No container were focused while processing indexes from focused to initialDesiredIndex, try SetCurrent on indexes higher than the initial down to maxIndex
+            while( ( !dataGridControl.HasValidationError ) && ( !isDataRow ) && ( desiredPageDownIndex <= maxIndex ) )
+            {
+              if( this.SetCurrent( desiredPageDownIndex, changeCurrentColumn, out isDataRow ) )
+                return;
+
+              desiredPageDownIndex++;
+            }
+
+            // If not container was successfuly focused, set focus back to the current UIElement.
+            this.SetCurrent( focusedContainerRealizedIndex, changeCurrentColumn, out isDataRow );
           }
         }
       }
@@ -1760,28 +1421,16 @@ namespace Xceed.Wpf.DataGrid.Views
       if( e.Handled )
         return;
 
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-      IScrollInfo scrollInfo = this.ScrollInfo;
-      ICustomItemContainerGenerator generator = this.CustomItemContainerGenerator;
-
-      NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
-      bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
-
       if( ( e.KeyboardDevice.Modifiers & ModifierKeys.Control ) == ModifierKeys.Control )
       {
+        DataGridControl dataGridControl = this.ParentDataGridControl;
+        IScrollInfo scrollInfo = this.ScrollInfo;
+        NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
+        bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
+
         if( navigationBehavior != NavigationBehavior.None )
         {
-          int currentIndex = generator.GetCurrentIndex();
-          int itemCount = generator.ItemCount;
-
-          // If the current index is different than the CurrentIndex
-          // force the first focusable from index 0 to become Current
-          if( ( currentIndex != 0 ) && ( itemCount > 0 ) )
-          {
-            // We have to find the first index that can get keyboard focus
-            // from 0 to currentIndex
-            this.FocusIndexOrNextFocusable( 0, currentIndex, changeCurrentColumn );
-          }
+          this.MoveToFirstOverallUIElement( changeCurrentColumn );
 
           if( navigationBehavior == NavigationBehavior.CellOnly )
           {
@@ -1805,14 +1454,6 @@ namespace Xceed.Wpf.DataGrid.Views
       e.Handled = true;
     }
 
-    private void ResetHorizontalOffset()
-    {
-      ScrollViewer parentScrollViewer = this.m_scrollOwner;
-
-      if( parentScrollViewer != null )
-        parentScrollViewer.ScrollToHorizontalOffset( 0d );
-    }
-
     protected override void HandleEndKey( KeyEventArgs e )
     {
       if( e.Handled )
@@ -1822,26 +1463,12 @@ namespace Xceed.Wpf.DataGrid.Views
       {
         DataGridControl dataGridControl = this.ParentDataGridControl;
         IScrollInfo scrollInfo = this.ScrollInfo;
-        ICustomItemContainerGenerator generator = this.CustomItemContainerGenerator;
-
-        FlowDirection flowDirection = dataGridControl.FlowDirection;
         NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
         bool changeCurrentColumn = ( navigationBehavior == NavigationBehavior.CellOnly );
 
         if( navigationBehavior != NavigationBehavior.None )
         {
-          int currentIndex = generator.GetCurrentIndex();
-          int itemCount = generator.ItemCount;
-          int lastItemIndex = itemCount - 1;
-
-          // If the current index is different than the CurrentIndex
-          // force the last focusable from index itemCount to become Current
-          if( ( currentIndex != lastItemIndex ) && ( itemCount > 0 ) )
-          {
-            // We have to find the last index that can get keyboard focus
-            // from lastItemIndex to currentIndex
-            this.FocusIndexOrPreviousFocusable( lastItemIndex, currentIndex, changeCurrentColumn );
-          }
+          this.MoveToLastOverallUIElement( changeCurrentColumn );
 
           if( navigationBehavior == NavigationBehavior.CellOnly )
           {
@@ -1865,144 +1492,35 @@ namespace Xceed.Wpf.DataGrid.Views
       e.Handled = true;
     }
 
-    private bool MoveToNextColumn()
+    private void MoveToFirstOverallUIElement( bool changeCurrentColumn )
     {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
-      if( dataGridControl == null )
-        return false;
-
-      DataGridContext currentDataGridContext = dataGridControl.CurrentContext;
+      // Simply scroll to top.
+      this.ScrollInfo.ScrollOwner.ScrollToTop();
 
-      if( currentDataGridContext == null )
-        return false;
-
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-      int visibleColumnsCollectionCount = visibleColumnsCollection.Count;
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
-
-      if( currentColumn == null )
+      //Try to focus on first UIElement.
+      if( !this.SetCurrent( 0, changeCurrentColumn ) )
       {
-        if( visibleColumnsCollectionCount > 0 )
-        {
-          this.MoveToFirstVisibleColumn();
-          return true;
-        }
+        //If not focusable, find the next one downward.
+        CustomItemContainerGenerator generator = this.CustomItemContainerGenerator as CustomItemContainerGenerator;
+        this.FocusIndexOrNextFocusable( 1, generator.RealizedContainers.Count - 1, changeCurrentColumn );
       }
-      Row currentRow = currentDataGridContext.CurrentRow;
-
-      int currentColumnIndex = visibleColumnsCollection.IndexOf( currentColumn );
-
-      int nextFocusableVisibleColumn = 0;
-
-      bool focusableColumnFound = false;
-
-      if( currentRow != null )
-      {
-        for( nextFocusableVisibleColumn = currentColumnIndex + 1; nextFocusableVisibleColumn < visibleColumnsCollectionCount; nextFocusableVisibleColumn++ )
-        {
-          if( currentRow.Cells[ visibleColumnsCollection[ nextFocusableVisibleColumn ] ].GetCalculatedCanBeCurrent() )
-          {
-            focusableColumnFound = true;
-            break;
-          }
-        }
-
-        if( focusableColumnFound )
-        {
-          try
-          {
-            currentDataGridContext.SetCurrentColumnAndChangeSelection(
-              currentDataGridContext.VisibleColumns[ nextFocusableVisibleColumn ] );
-          }
-          catch( DataGridException )
-          {
-            // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-            // any other GridException.
-          }
-
-          return true;
-        }
-        // If the column is other than last Column or than the last current column
-        else
-        {
-          this.MoveToLastVisibleColumn();
-        }
-      }
-      return false;
     }
 
-    private bool MoveToPreviousColumn()
+    private void MoveToLastOverallUIElement( bool changeCurrentColumn )
     {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
-      if( dataGridControl == null )
-        return false;
-
-      DataGridContext currentDataGridContext = dataGridControl.CurrentContext;
-
-      if( currentDataGridContext == null )
-        return false;
-
-      ReadOnlyColumnCollection visibleColumnsCollection = ( ReadOnlyColumnCollection )currentDataGridContext.VisibleColumns;
-      int visibleColumnsCollectionCount = visibleColumnsCollection.Count;
+      // Simply scroll to end
+      this.ScrollInfo.ScrollOwner.ScrollToBottom();
 
-      ColumnBase currentColumn = currentDataGridContext.CurrentColumn;
+      CustomItemContainerGenerator generator = this.CustomItemContainerGenerator as CustomItemContainerGenerator;
+      int lastItemIndex = generator.ItemCount - 1;
 
-      if( currentColumn == null )
+      //Try to focus on last UIElement.
+      if( !this.SetCurrent( lastItemIndex, changeCurrentColumn ) )
       {
-        if( visibleColumnsCollectionCount > 0 )
-        {
-          this.MoveToFirstVisibleColumn();
-          return true;
-        }
+        //If not focusable, find the next one upward.
+        int minimumIndex = lastItemIndex - generator.RealizedContainers.Count;
+        this.FocusIndexOrPreviousFocusable( lastItemIndex, minimumIndex, changeCurrentColumn );
       }
-      else
-      {
-        Row currentRow = currentDataGridContext.CurrentRow;
-
-        int currentColumnIndex = visibleColumnsCollection.IndexOf( currentColumn );
-        bool focusableColumnFound = false;
-
-        // If the column is other than first Column
-        if( currentColumnIndex > 0 )
-        {
-          int previousFocusableVisibleColumn = 0;
-          if( currentRow != null )
-          {
-            for( previousFocusableVisibleColumn = currentColumnIndex - 1; previousFocusableVisibleColumn >= 0; previousFocusableVisibleColumn-- )
-            {
-              if( currentRow.Cells[ visibleColumnsCollection[ previousFocusableVisibleColumn ] ].GetCalculatedCanBeCurrent() )
-              {
-                focusableColumnFound = true;
-                break;
-              }
-            }
-          }
-
-          if( focusableColumnFound )
-          {
-            try
-            {
-              currentDataGridContext.SetCurrentColumnAndChangeSelection(
-                 currentDataGridContext.VisibleColumns[ previousFocusableVisibleColumn ] );
-            }
-            catch( DataGridException )
-            {
-              // We swallow the exception if it occurs because of a validation error or Cell was read-only or
-              // any other GridException.
-            }
-
-            return true;
-          }
-          else
-          {
-            this.MoveToFirstVisibleColumn();
-          }
-        }
-      }
-
-      return false;
     }
 
     private void MoveToFirstVisibleColumn()
@@ -2111,7 +1629,11 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected override void BringIntoViewCore( int index )
     {
-      if( ( index >= m_lastGeneratedPage.StartIndex ) && ( index < m_lastGeneratedPage.EndIndex ) )
+      if( m_lastGeneratedPage == TableViewPage.Empty )
+        return;
+
+      var pageInfo = m_lastGeneratedPage.InnerPage;
+      if( ( index >= pageInfo.Start ) && ( index < pageInfo.End ) )
         return;
 
       this.InvalidateMeasure();
@@ -2165,7 +1687,6 @@ namespace Xceed.Wpf.DataGrid.Views
       if( offset == m_horizontalOffset )
         return;
 
-      DataGridScrollViewer scrollViewer = this.ScrollInfo.ScrollOwner as DataGridScrollViewer;
       this.ScrollToHorizontalOffset( offset );
     }
 
@@ -2196,7 +1717,6 @@ namespace Xceed.Wpf.DataGrid.Views
       if( offset == m_verticalOffset )
         return;
 
-      DataGridScrollViewer scrollViewer = this.ScrollInfo.ScrollOwner as DataGridScrollViewer;
       this.ScrollToVerticalOffset( offset );
     }
 
@@ -2204,14 +1724,16 @@ namespace Xceed.Wpf.DataGrid.Views
     {
       get
       {
-        if( m_lastGeneratedPageContainersHeight > m_lastGeneratedPageViewPortHeight )
-        {
-          return Math.Max( 1, m_lastGeneratedPage.Length - 1 );
-        }
-        else
-        {
-          return Math.Max( 1, m_lastGeneratedPage.Length );
-        }
+        if( m_lastGeneratedPage == TableViewPage.Empty )
+          return 0d;
+
+        var pageInfo = m_lastGeneratedPage.InnerPage;
+        var viewportHeight = m_lastGeneratedPage.ViewportHeight;
+
+        if( pageInfo.Size > viewportHeight )
+          return Math.Max( 1, pageInfo.Length - 1 );
+
+        return Math.Max( 1, pageInfo.Length );
       }
     }
 
@@ -2266,10 +1788,15 @@ namespace Xceed.Wpf.DataGrid.Views
 
     void IScrollInfo.PageDown()
     {
-      int newOffset = m_lastGeneratedPage.EndIndex;
+      if( m_lastGeneratedPage == TableViewPage.Empty )
+        return;
+
+      var pageInfo = m_lastGeneratedPage.InnerPage;
+      var viewportHeight = m_lastGeneratedPage.ViewportHeight;
+      var newOffset = pageInfo.End;
 
       // We only have one row and it is bigger than the view port.
-      if( ( m_lastGeneratedPage.Length == 1 ) && ( m_lastGeneratedPageContainersHeight > m_lastGeneratedPageViewPortHeight ) )
+      if( ( pageInfo.Length == 1 ) && ( pageInfo.Size > viewportHeight ) )
       {
         int itemCount = ( int )( ( IScrollInfo )this ).ExtentHeight;
 
@@ -2295,10 +1822,16 @@ namespace Xceed.Wpf.DataGrid.Views
 
     void IScrollInfo.PageUp()
     {
-      m_indexToBringIntoView = m_lastGeneratedPage.StartIndex;
+      if( m_lastGeneratedPage == TableViewPage.Empty )
+        return;
+
+      var pageInfo = m_lastGeneratedPage.InnerPage;
+      var viewportHeight = m_lastGeneratedPage.ViewportHeight;
+
+      m_indexToBringIntoView = pageInfo.Start;
 
       // We only have one row and it is bigger than the view port.
-      if( ( m_lastGeneratedPage.Length == 1 ) && ( m_lastGeneratedPageContainersHeight > m_lastGeneratedPageViewPortHeight ) )
+      if( ( pageInfo.Length == 1 ) && ( pageInfo.Size > viewportHeight ) )
       {
         if( m_indexToBringIntoView > 0 )
         {
@@ -2360,9 +1893,7 @@ namespace Xceed.Wpf.DataGrid.Views
     IDisposable IDeferableScrollInfoRefresh.DeferScrollInfoRefresh( Orientation orientation )
     {
       if( orientation == Orientation.Vertical )
-      {
-        return new LayoutSuspendedHelper( this, orientation );
-      }
+        return new LayoutSuspendedHelper( this );
 
       return null;
     }
@@ -2522,16 +2053,16 @@ namespace Xceed.Wpf.DataGrid.Views
       // and/or GroupLevelIndicators present in the Container.
       // This extra space must be taken into consideration, not
       // only the offset between the target and the ItemsHost.
-      Point targetToParentContainer = TableViewItemsHost.EmptyPoint;
+      Point targetToParentContainer = TableViewItemsHost.OriginPoint;
       FrameworkElement targetParentContainer = DataGridItemsHost.GetItemsHostContainerFromElement( itemsHost, target ) as FrameworkElement;
 
       if( ( targetParentContainer != null ) && ( target != targetParentContainer ) )
       {
-        targetToParentContainer = target.TranslatePoint( TableViewItemsHost.EmptyPoint,
+        targetToParentContainer = target.TranslatePoint( TableViewItemsHost.OriginPoint,
                                                          targetParentContainer );
       }
 
-      Point targetToItemsHostPosition = target.TranslatePoint( TableViewItemsHost.EmptyPoint, itemsHost );
+      Point targetToItemsHostPosition = target.TranslatePoint( TableViewItemsHost.OriginPoint, itemsHost );
       double acceptableThreshold;
       double actualVisibleValue;
 
@@ -2735,7 +2266,12 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private static void MoveFocusForwardExecuted( object sender, ExecutedRoutedEventArgs e )
     {
-      e.Handled = ( ( TableViewItemsHost )sender ).MoveFocusRight();
+      var itemsHost = ( TableViewItemsHost )sender;
+      var dataGridControl = itemsHost.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusRight( dataGridControl.CurrentContext );
     }
 
     private static void MoveFocusForwardCanExecute( object sender, CanExecuteRoutedEventArgs e )
@@ -2746,7 +2282,12 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private static void MoveFocusBackExecuted( object sender, ExecutedRoutedEventArgs e )
     {
-      e.Handled = ( ( TableViewItemsHost )sender ).MoveFocusLeft();
+      var itemsHost = ( TableViewItemsHost )sender;
+      var dataGridControl = itemsHost.ParentDataGridControl;
+      if( dataGridControl == null )
+        return;
+
+      e.Handled = NavigationHelper.MoveFocusLeft( dataGridControl.CurrentContext );
     }
 
     private static void MoveFocusBackCanExecute( object sender, CanExecuteRoutedEventArgs e )
@@ -2777,78 +2318,6 @@ namespace Xceed.Wpf.DataGrid.Views
       e.Handled = true;
     }
 
-    private bool MoveFocusLeft()
-    {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
-      if( dataGridControl == null )
-        return false;
-
-      bool dataGridControlFocusWithin = dataGridControl.IsKeyboardFocusWithin;
-
-      // Process Left key even if NavigationBehavior is RowOnly
-      // when the grid is being edited 
-      bool dataGridControlIsBeingEdited =
-        dataGridControlFocusWithin && dataGridControl.IsBeingEdited;
-
-      FlowDirection flowDirection = dataGridControl.FlowDirection;
-      NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
-
-      if( ( navigationBehavior == NavigationBehavior.CellOnly )
-        || ( ( navigationBehavior == NavigationBehavior.RowOnly ) && dataGridControlIsBeingEdited )
-        || ( ( navigationBehavior == NavigationBehavior.RowOrCell )
-              && dataGridControlFocusWithin
-              && dataGridControl.CurrentContext.CurrentColumn != null ) )
-      {
-        if( flowDirection == FlowDirection.LeftToRight )
-        {
-          return this.MoveToPreviousColumn();
-        }
-        else
-        {
-          return this.MoveToNextColumn();
-        }
-      }
-
-      return false;
-    }
-
-    private bool MoveFocusRight()
-    {
-      DataGridControl dataGridControl = this.ParentDataGridControl;
-
-      if( dataGridControl == null )
-        return false;
-
-      bool dataGridControlFocusWithin = dataGridControl.IsKeyboardFocusWithin;
-
-      // Process Right key even if NavigationBehavior is RowOnly
-      // when the grid is being edited 
-      bool dataGridControlIsBeingEdited =
-        dataGridControlFocusWithin && dataGridControl.IsBeingEdited;
-
-      FlowDirection flowDirection = dataGridControl.FlowDirection;
-      NavigationBehavior navigationBehavior = dataGridControl.NavigationBehavior;
-
-      if( ( navigationBehavior == NavigationBehavior.CellOnly )
-        || ( ( navigationBehavior == NavigationBehavior.RowOnly ) && dataGridControlIsBeingEdited )
-        || ( ( navigationBehavior == NavigationBehavior.RowOrCell )
-              && dataGridControlFocusWithin
-              && dataGridControl.CurrentContext.CurrentColumn != null ) )
-      {
-        if( flowDirection == FlowDirection.LeftToRight )
-        {
-          return this.MoveToNextColumn();
-        }
-        else
-        {
-          return this.MoveToPreviousColumn();
-        }
-      }
-
-      return false;
-    }
-
     private bool MoveFocusUp()
     {
       DataGridControl dataGridControl = this.ParentDataGridControl;
@@ -2895,7 +2364,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void InvalidateLayoutFromScrollingHelper()
     {
-      if( m_layoutSuspended )
+      if( m_layoutSuspended.IsSet )
       {
         m_layoutInvalidatedDuringSuspend = true;
         return;
@@ -2908,8 +2377,12 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region CONSTANTS
 
-    private static readonly Point OutOfViewPoint = new Point( -999999, -999999 );
-    private static readonly Point EmptyPoint = new Point( 0, 0 );
+    private const int MaxDataRowFailFocusCount = 50;
+    private const int NullIndex = int.MinValue;
+
+    private static readonly Point OriginPoint = new Point( 0d, 0d );
+    private static readonly Size EmptySize = new Size( 0d, 0d );
+    private static readonly Rect OutOfViewRect = new Rect( new Point( -999999d, -999999d ), TableViewItemsHost.EmptySize );
 
     #endregion CONSTANTS
 
@@ -2917,68 +2390,156 @@ namespace Xceed.Wpf.DataGrid.Views
 
 
 
-    private LayoutedContainerInfoList m_layoutedContainers = new LayoutedContainerInfoList();
-    private HashSet<UIElement> m_layoutedContainersToRecycle = new HashSet<UIElement>();
+    private readonly LayoutedContainerInfoList m_layoutedContainers = new LayoutedContainerInfoList();
 
-    private PageIndexes m_lastGeneratedPage = PageIndexes.Empty;
-    private PageIndexes m_lastLayoutedPage = PageIndexes.Empty;
-    private double m_lastGeneratedPageContainersHeight;
-    private double m_lastGeneratedPageViewPortHeight;
+    private TableViewPage m_lastGeneratedPage = TableViewPage.Empty;
+    private TableViewPage m_lastLayoutedPage = TableViewPage.Empty;
 
-    private Dictionary<string, double> m_cachedContainerDesiredWidth = new Dictionary<string, double>();
-    private Dictionary<string, double> m_cachedContainerRealDesiredWidth = new Dictionary<string, double>();
+    private readonly Dictionary<string, double> m_cachedContainerDesiredWidth = new Dictionary<string, double>();
+    private readonly Dictionary<string, double> m_cachedContainerRealDesiredWidth = new Dictionary<string, double>();
 
-    private HashSet<string> m_autoWidthCalculatedDataGridContextList = new HashSet<string>();
+    private readonly HashSet<string> m_autoWidthCalculatedDataGridContextList = new HashSet<string>();
 
-    private Size m_lastMeasureAvailableSize = Size.Empty;
-    private Size m_lastArrangeFinalSize = Size.Empty;
-    private int m_indexToBringIntoView = -1;
+    private Size m_lastMeasureAvailableSize = TableViewItemsHost.EmptySize;
+    private int m_indexToBringIntoView = TableViewItemsHost.NullIndex;
 
-    private bool m_layoutSuspended;
+    private AutoResetFlag m_layoutSuspended = AutoResetFlagFactory.Create( false );
     private bool m_layoutInvalidatedDuringSuspend;
 
     #endregion PRIVATE FIELDS
 
-    #region PageIndexes Private Struct
+    #region LayoutSuspendedHelper Private Class
 
-    private struct PageIndexes
+    private sealed class LayoutSuspendedHelper : IDisposable
     {
-      public PageIndexes( int startIndex, int endIndex )
+      public LayoutSuspendedHelper( TableViewItemsHost owner )
       {
-        if( ( startIndex > endIndex ) && ( endIndex != -1 ) && ( startIndex != -1 ) )
-          throw new ArgumentException( "startIndex must be less than or equal to endIndex.", "startIndex" );
+        if( owner == null )
+          throw new ArgumentNullException( "owner" );
 
-        m_startIndex = startIndex;
-        m_endIndex = endIndex;
+        m_owner = owner;
+        m_disposable = owner.m_layoutSuspended.Set();
+      }
+
+      void IDisposable.Dispose()
+      {
+        this.Dispose( true );
+        GC.SuppressFinalize( this );
+      }
+
+      private void Dispose( bool disposing )
+      {
+        m_disposable.Dispose();
+
+        if( !m_owner.m_layoutSuspended.IsSet && m_owner.m_layoutInvalidatedDuringSuspend )
+        {
+          m_owner.InvalidateMeasure();
+        }
+      }
+
+      ~LayoutSuspendedHelper()
+      {
+        this.Dispose( false );
+      }
+
+      private readonly TableViewItemsHost m_owner;
+      private readonly IDisposable m_disposable;
+    }
+
+    #endregion
+
+    #region TableViewPageResult Private Class
+
+    private sealed class TableViewPageResult
+    {
+      internal TableViewPageResult( TableViewPage pageInfo, IEnumerable<LayoutedContainerInfo> layoutedContainers )
+      {
+        if( pageInfo == null )
+          throw new ArgumentNullException( "pageInfo" );
+
+        if( layoutedContainers == null )
+          throw new ArgumentNullException( "layoutedContainers" );
+
+        m_pageInfo = pageInfo;
+        m_layoutedContainers = layoutedContainers;
       }
 
-      public static readonly PageIndexes Empty = new PageIndexes( -1, -1 );
+      internal TableViewPage PageInfo
+      {
+        get
+        {
+          return m_pageInfo;
+        }
+      }
 
-      private int m_startIndex;
-      public int StartIndex
+      internal IEnumerable<LayoutedContainerInfo> LayoutedContainers
       {
         get
         {
-          return m_startIndex;
+          return m_layoutedContainers;
         }
+      }
+
+      private readonly TableViewPage m_pageInfo;
+      private readonly IEnumerable<LayoutedContainerInfo> m_layoutedContainers;
+    }
+
+    #endregion
+
+    #region Range Private Struct
 
-        set
+    private struct Range
+    {
+      internal static readonly Range Empty = new Range( true );
+
+      private Range( bool isEmpty )
+      {
+        m_start = -1;
+        m_end = -1;
+      }
+
+      internal Range( int start, int end )
+      {
+        if( start < 0 )
+          throw new ArgumentException( "The value must be greater than or equal to zero.", "start" );
+
+        if( end < 0 )
+          throw new ArgumentException( "The value must be greater than or equal to zero.", "end" );
+
+        if( start > end )
+          throw new ArgumentException( "The start value must be lesser than or equal to the end value.", "start" );
+
+        m_start = start;
+        m_end = end;
+      }
+
+      public int Start
+      {
+        get
         {
-          m_startIndex = value;
+          if( m_start < 0 )
+            return 0;
+
+          return m_start;
         }
       }
 
-      private int m_endIndex;
-      public int EndIndex
+      public int End
       {
         get
         {
-          return m_endIndex;
+          if( m_end < 0 )
+            return 0;
+
+          return m_end;
         }
+      }
 
-        set
+      public bool IsEmpty
+      {
+        get
         {
-          m_endIndex = value;
+          return ( m_start < 0 );
         }
       }
 
@@ -2986,66 +2547,476 @@ namespace Xceed.Wpf.DataGrid.Views
       {
         get
         {
-          if( this.EndIndex == -1 )
+          if( this.IsEmpty )
             return 0;
 
-          return this.EndIndex - this.StartIndex + 1;
+          return ( m_end - m_start + 1 );
         }
       }
 
-      public override bool Equals( object obj )
+      public static bool operator ==( Range x, Range y )
       {
-        if( !( obj is PageIndexes ) )
-          return false;
+        return object.Equals( x, y );
+      }
 
-        return ( this == ( PageIndexes )obj );
+      public static bool operator !=( Range x, Range y )
+      {
+        return !( x == y );
       }
 
       public override int GetHashCode()
       {
-        return ( this.StartIndex ^ this.EndIndex );
+        return this.Start ^ this.End;
+      }
+
+      public override bool Equals( object obj )
+      {
+        if( !( obj is Range ) )
+          return false;
+
+        var range = ( Range )obj;
+
+        if( this.IsEmpty )
+          return range.IsEmpty;
+
+        return ( !range.IsEmpty )
+            && ( range.m_start == m_start )
+            && ( range.m_end == m_end );
       }
 
-      public static bool operator ==( PageIndexes objA, PageIndexes objB )
+      internal Range SetStart( int value )
       {
-        return ( objA.StartIndex == objB.StartIndex )
-          && ( objA.EndIndex == objB.EndIndex );
+        if( this.IsEmpty )
+          throw new InvalidOperationException();
+
+        if( value > m_end )
+          return Range.Empty;
+
+        return new Range( value, m_end );
       }
 
-      public static bool operator !=( PageIndexes objA, PageIndexes objB )
+      internal Range SetEnd( int value )
       {
-        return !( objA == objB );
+        if( this.IsEmpty )
+          throw new InvalidOperationException();
+
+        if( value < m_start )
+          return Range.Empty;
+
+        return new Range( m_start, value );
       }
+
+      private readonly int m_start;
+      private readonly int m_end;
     }
 
-    #endregion PageIndexes Private Struct
+    #endregion
 
-    #region LayoutSuspendedHelper Private Class
+    #region PageGenerator Private Class
 
-    private sealed class LayoutSuspendedHelper : IDisposable
+    private abstract class PageGenerator
     {
-      public LayoutSuspendedHelper( TableViewItemsHost panel, Orientation orientation )
+      protected PageGenerator( TableViewItemsHost itemsHost, int startIndex, double availableHeight, bool forceMeasure )
       {
-        if( panel == null )
-          throw new ArgumentNullException( "panel" );
+        if( itemsHost == null )
+          throw new ArgumentNullException( "itemsHost" );
+
+        m_itemsHost = itemsHost;
+        m_startIndex = startIndex;
+        m_availableHeight = availableHeight;
+        m_forceMeasure = forceMeasure;
+      }
+
+      protected abstract TableViewPage GenerateContainers( int startIndex, int itemCount, double availableHeight, double extendedHeight, bool fillLastPage );
+
+      protected LayoutedContainerInfo CreateContainer( int realizedIndex )
+      {
+        if( ( realizedIndex < 0 ) || ( realizedIndex >= m_itemCount ) )
+          return null;
+
+        this.RecycleCandidates( realizedIndex );
+
+        var position = m_generator.GeneratorPositionFromIndex( realizedIndex );
+        using( m_generator.StartAt( position, GeneratorDirection.Forward, true ) )
+        {
+          var container = m_itemsHost.GenerateContainer( m_generator, realizedIndex, m_forceMeasure );
+          if( container == null )
+            return null;
+
+          m_remainingViewportHeight -= container.DesiredSize.Height;
+          m_oldLayoutedContainers.Remove( container );
+
+          var containerInfo = new LayoutedContainerInfo( realizedIndex, container );
+          m_newLayoutedContainers.Add( containerInfo );
+
+          return containerInfo;
+        }
+      }
+
+      internal TableViewPageResult Generate( IEnumerable<LayoutedContainerInfo> layoutedContainers, TableViewPage lastGeneratedPage )
+      {
+        m_generator = m_itemsHost.CustomItemContainerGenerator;
+        Debug.Assert( m_generator != null );
+
+        m_generator.IsRecyclingEnabled = true;
+
+        m_itemCount = m_generator.ItemCount;
+        m_focusedContainer = DataGridItemsHost.GetItemsHostContainerFromElement( m_itemsHost, Keyboard.FocusedElement as DependencyObject );
+
+        var lastGeneratedPageSize = lastGeneratedPage.OuterPage.Length;
+        m_oldLayoutedContainers = new Dictionary<UIElement, int>( lastGeneratedPageSize );
+        m_newLayoutedContainers = null;
+
+        // Figure out the realized index of all currently layouted containers.
+        foreach( var container in layoutedContainers.Select( item => item.Container ) )
+        {
+          var newRealizedIndex = m_generator.GetRealizedIndexForContainer( container );
+
+          if( ( newRealizedIndex >= 0 ) || ( container == m_focusedContainer ) )
+          {
+            m_oldLayoutedContainers.Add( container, newRealizedIndex );
+          }
+          // The container is lost, recycle it.
+          else
+          {
+            m_itemsHost.RecycleContainer( m_generator, new LayoutedContainerInfo( newRealizedIndex, container ) );
+          }
+        }
+
+        TableViewPageResult result;
+
+        if( m_itemCount > 0 )
+        {
+          m_newLayoutedContainers = new List<LayoutedContainerInfo>( lastGeneratedPageSize );
+
+          var extendedHeight = Math.Max( m_availableHeight, lastGeneratedPage.ViewportHeight );
+
+          this.PrepareRecycleCandidates( extendedHeight );
+
+          var dataGridContext = DataGridControl.GetDataGridContext( m_itemsHost );
+          var fillLastPage = ( dataGridContext != null ) && TableView.GetAutoFillLastPage( dataGridContext );
+          var pageInfo = this.GenerateContainers( m_startIndex, m_itemCount, m_availableHeight, extendedHeight, fillLastPage );
+
+          // Keep the focused container active by putting it in the layouted containers collection.
+          if( m_focusedContainer != null )
+          {
+            int newRealizedIndex;
+            if( m_oldLayoutedContainers.TryGetValue( m_focusedContainer, out newRealizedIndex ) )
+            {
+              m_oldLayoutedContainers.Remove( m_focusedContainer );
+              m_newLayoutedContainers.Add( new LayoutedContainerInfo( newRealizedIndex, m_focusedContainer ) );
+            }
+          }
 
-        m_panel = panel;
-        m_panel.m_layoutSuspended = true;
+          result = new TableViewPageResult( pageInfo, m_newLayoutedContainers );
+        }
+        else
+        {
+          result = new TableViewPageResult( TableViewPage.Empty, Enumerable.Empty<LayoutedContainerInfo>() );
+        }
+
+        // Recycle the containers that have not been reused.
+        foreach( var entry in m_oldLayoutedContainers )
+        {
+          m_itemsHost.RecycleContainer( m_generator, new LayoutedContainerInfo( entry.Value, entry.Key ) );
+        }
+
+        return result;
       }
 
-      public void Dispose()
+      private void PrepareRecycleCandidates( double extendedHeight )
       {
-        m_panel.m_layoutSuspended = false;
+        m_recycleCandidates = ( from entry in m_oldLayoutedContainers
+                                orderby entry.Value
+                                select entry.Key ).ToArray();
+
+        var count = m_recycleCandidates.Length;
 
-        if( m_panel.m_layoutInvalidatedDuringSuspend )
+        m_recycleCandidatesRealizedIndex = new int[ count ];
+        m_recycleCandidatesHeight = new DoubleFenwickTree( count );
+
+        for( int i = 0; i < count; i++ )
         {
-          m_panel.InvalidateMeasure();
+          var container = m_recycleCandidates[ i ];
+
+          m_recycleCandidatesRealizedIndex[ i ] = m_oldLayoutedContainers[ container ];
+          m_recycleCandidatesHeight[ i ] = container.DesiredSize.Height;
         }
+
+        if( count > 0 )
+        {
+          m_lowerRecycleCandidatesRange = new Range( 0, count - 1 );
+          m_upperRecycleCandidatesRange = new Range( 0, count - 1 );
+        }
+        else
+        {
+          m_lowerRecycleCandidatesRange = Range.Empty;
+          m_upperRecycleCandidatesRange = Range.Empty;
+        }
+
+        m_remainingViewportHeight = extendedHeight;
       }
 
-      private TableViewItemsHost m_panel; // = null
+      private void RecycleCandidates( int realizedIndex )
+      {
+        if( m_lowerRecycleCandidatesRange.IsEmpty && m_upperRecycleCandidatesRange.IsEmpty )
+          return;
+
+        var pivot = Array.BinarySearch( m_recycleCandidatesRealizedIndex, realizedIndex );
+        if( pivot < 0 )
+        {
+          pivot = ~pivot;
+
+          if( !m_upperRecycleCandidatesRange.IsEmpty && ( m_upperRecycleCandidatesRange.Start < pivot ) )
+          {
+            m_upperRecycleCandidatesRange = m_upperRecycleCandidatesRange.SetStart( pivot );
+          }
+        }
+        else
+        {
+          if( !m_upperRecycleCandidatesRange.IsEmpty && ( m_upperRecycleCandidatesRange.Start <= pivot ) )
+          {
+            m_upperRecycleCandidatesRange = m_upperRecycleCandidatesRange.SetStart( pivot + 1 );
+          }
+        }
+
+        if( !m_lowerRecycleCandidatesRange.IsEmpty && ( m_lowerRecycleCandidatesRange.End >= pivot ) )
+        {
+          m_lowerRecycleCandidatesRange = m_lowerRecycleCandidatesRange.SetEnd( pivot - 1 );
+        }
+
+        while( !m_lowerRecycleCandidatesRange.IsEmpty )
+        {
+          var index = m_lowerRecycleCandidatesRange.Start;
+          var container = m_recycleCandidates[ index ];
+
+          // The container may no longer be a candidate if it has been reused already.
+          if( m_oldLayoutedContainers.ContainsKey( container ) )
+          {
+            var distance = ( m_lowerRecycleCandidatesRange.Length > 1 )
+                             ? m_recycleCandidatesHeight.GetRunningSum( index + 1, m_lowerRecycleCandidatesRange.End )
+                             : 0d;
+
+            if( distance < m_remainingViewportHeight )
+              break;
+
+            this.RecycleCandidate( container );
+          }
+
+          m_lowerRecycleCandidatesRange = m_lowerRecycleCandidatesRange.SetStart( index + 1 );
+        }
+
+        while( !m_upperRecycleCandidatesRange.IsEmpty )
+        {
+          var index = m_upperRecycleCandidatesRange.End;
+          var container = m_recycleCandidates[ index ];
+
+          // The container may no longer be a candidate if it has been reused already.
+          if( m_oldLayoutedContainers.ContainsKey( container ) )
+          {
+            var distance = ( m_upperRecycleCandidatesRange.Length > 1 )
+                             ? m_recycleCandidatesHeight.GetRunningSum( m_upperRecycleCandidatesRange.Start, index - 1 )
+                             : 0d;
+
+            if( distance < m_remainingViewportHeight )
+              break;
+
+            this.RecycleCandidate( container );
+          }
+
+          m_upperRecycleCandidatesRange = m_upperRecycleCandidatesRange.SetEnd( index - 1 );
+        }
+      }
+
+      private void RecycleCandidate( UIElement container )
+      {
+        int realizedIndex;
+        if( !m_oldLayoutedContainers.TryGetValue( container, out realizedIndex ) )
+          return;
+
+        m_oldLayoutedContainers.Remove( container );
+
+        var containerInfo = new LayoutedContainerInfo( realizedIndex, container );
+
+        // Keep the focused container active by putting it in the layouted containers collection.
+        if( container == m_focusedContainer )
+        {
+          m_newLayoutedContainers.Add( containerInfo );
+        }
+        else
+        {
+          m_itemsHost.RecycleContainer( m_generator, containerInfo );
+        }
+      }
+
+      private readonly TableViewItemsHost m_itemsHost;
+      private readonly int m_startIndex;
+      private readonly double m_availableHeight;
+      private readonly bool m_forceMeasure;
+
+      private ICustomItemContainerGenerator m_generator;
+      private int m_itemCount;
+      private UIElement m_focusedContainer;
+      private Dictionary<UIElement, int> m_oldLayoutedContainers;
+      private List<LayoutedContainerInfo> m_newLayoutedContainers;
+
+      private UIElement[] m_recycleCandidates;
+      private int[] m_recycleCandidatesRealizedIndex;
+      private DoubleFenwickTree m_recycleCandidatesHeight;
+      private Range m_lowerRecycleCandidatesRange;
+      private Range m_upperRecycleCandidatesRange;
+      private double m_remainingViewportHeight;
     }
 
-    #endregion LayoutSuspendedHelper Private Class
+    #endregion
+
+    #region TopBottomPageGenerator Private Class
+
+    private sealed class TopBottomPageGenerator : PageGenerator
+    {
+      internal TopBottomPageGenerator( TableViewItemsHost itemsHost, int startIndex, double availableHeight, bool forceMeasure )
+        : base( itemsHost, startIndex, availableHeight, forceMeasure )
+      {
+      }
+
+      protected override TableViewPage GenerateContainers( int startIndex, int itemCount, double availableHeight, double extendedHeight, bool fillLastPage )
+      {
+        var innerStartIndex = startIndex;
+        var innerEndIndex = startIndex;
+        var innerContainersHeight = 0d;
+        var outerStartIndex = startIndex;
+        var outerEndIndex = startIndex;
+        var outerContainersHeight = 0d;
+        var remainingInnerContainersHeight = availableHeight;
+        var remainingOuterContainersHeight = extendedHeight;
+
+        Debug.Assert( remainingInnerContainersHeight <= remainingOuterContainersHeight );
+
+        for( int i = innerStartIndex; ( remainingOuterContainersHeight > 0d ) && ( i < itemCount ); i++ )
+        {
+          var containerInfo = this.CreateContainer( i );
+          if( containerInfo == null )
+            break;
+
+          var containerHeight = containerInfo.Container.DesiredSize.Height;
+
+          if( remainingInnerContainersHeight > 0d )
+          {
+            innerEndIndex = i;
+            innerContainersHeight += containerHeight;
+            remainingInnerContainersHeight -= containerHeight;
+          }
+
+          outerEndIndex = i;
+          outerContainersHeight += containerHeight;
+          remainingOuterContainersHeight -= containerHeight;
+        }
+
+        if( fillLastPage )
+        {
+          for( int i = innerStartIndex - 1; ( remainingOuterContainersHeight > 0d ) && ( i >= 0 ); i-- )
+          {
+            var containerInfo = this.CreateContainer( i );
+            if( containerInfo == null )
+              break;
+
+            var containerHeight = containerInfo.Container.DesiredSize.Height;
+
+            if( containerHeight <= remainingInnerContainersHeight )
+            {
+              innerStartIndex = i;
+              innerContainersHeight += containerHeight;
+              remainingInnerContainersHeight -= containerHeight;
+            }
+
+            outerStartIndex = i;
+            outerContainersHeight += containerHeight;
+            remainingOuterContainersHeight -= containerHeight;
+          }
+        }
+
+        return new TableViewPage(
+          new TableViewFullPageInfo( innerStartIndex, innerEndIndex, innerContainersHeight ),
+          new TableViewFullPageInfo( outerStartIndex, outerEndIndex, outerContainersHeight ),
+          availableHeight );
+      }
+    }
+
+    #endregion
+
+    #region BottomTopPageGenerator Private Class
+
+    private sealed class BottomTopPageGenerator : PageGenerator
+    {
+      internal BottomTopPageGenerator( TableViewItemsHost itemsHost, int startIndex, double availableHeight, bool forceMeasure )
+        : base( itemsHost, startIndex, availableHeight, forceMeasure )
+      {
+      }
+
+      protected override TableViewPage GenerateContainers( int startIndex, int itemCount, double availableHeight, double extendedHeight, bool fillLastPage )
+      {
+        var innerStartIndex = startIndex;
+        var innerEndIndex = startIndex;
+        var innerContainersHeight = 0d;
+        var outerStartIndex = startIndex;
+        var outerEndIndex = startIndex;
+        var outerContainersHeight = 0d;
+        var remainingInnerContainersHeight = availableHeight;
+        var remainingOuterContainersHeight = extendedHeight;
+
+        Debug.Assert( remainingInnerContainersHeight <= remainingOuterContainersHeight );
+
+        for( int i = innerEndIndex; ( remainingOuterContainersHeight > 0d ) && ( i >= 0 ); i-- )
+        {
+          var containerInfo = this.CreateContainer( i );
+          if( containerInfo == null )
+            break;
+
+          var containerHeight = containerInfo.Container.DesiredSize.Height;
+
+          outerStartIndex = i;
+          outerContainersHeight += containerHeight;
+
+          if( containerHeight > remainingInnerContainersHeight )
+          {
+            // The inner page must at least contain one container before we consider layouting in the other direction.
+            if( innerContainersHeight != 0d )
+              break;
+          }
+
+          innerStartIndex = i;
+          innerContainersHeight += containerHeight;
+          remainingInnerContainersHeight -= containerHeight;
+          remainingOuterContainersHeight -= containerHeight;
+        }
+
+        for( int i = innerEndIndex + 1; ( remainingOuterContainersHeight > 0d ) && ( i < itemCount ); i++ )
+        {
+          var containerInfo = this.CreateContainer( i );
+          if( containerInfo == null )
+            break;
+
+          var containerHeight = containerInfo.Container.DesiredSize.Height;
+
+          if( remainingInnerContainersHeight > 0d )
+          {
+            innerEndIndex = i;
+            innerContainersHeight += containerHeight;
+            remainingInnerContainersHeight -= containerHeight;
+          }
+
+          outerEndIndex = i;
+          outerContainersHeight += containerHeight;
+          remainingOuterContainersHeight -= containerHeight;
+        }
+
+        return new TableViewPage(
+          new TableViewFullPageInfo( innerStartIndex, innerEndIndex, innerContainersHeight ),
+          new TableViewFullPageInfo( outerStartIndex, outerEndIndex, outerContainersHeight ),
+          availableHeight );
+      }
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPage.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPage.cs
new file mode 100644
index 00000000..c8602144
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPage.cs
@@ -0,0 +1,103 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal sealed class TableViewPage
+  {
+    #region Static Fields
+
+    internal static readonly TableViewPage Empty = new TableViewPage();
+
+    #endregion
+
+    #region Constructors
+
+    internal TableViewPage( TableViewFullPageInfo innerPage, TableViewFullPageInfo outerPage, double viewportHeight )
+    {
+      if( innerPage == null )
+        throw new ArgumentNullException( "innerPage" );
+
+      if( outerPage == null )
+        throw new ArgumentNullException( "outerPage" );
+
+      if( innerPage.Start < outerPage.Start )
+        throw new ArgumentException("The inner page must be a subset of the outer page.", "innerPage");
+
+      if( innerPage.End > outerPage.End )
+        throw new ArgumentException( "The inner page must be a subset of the outer page.", "innerPage" );
+
+      if( viewportHeight < 0d )
+        throw new ArgumentException( "viewportHeight must be greater than to equal to zero.", "viewportHeight" );
+
+      m_innerPage = innerPage;
+      m_outerPage = outerPage;
+      m_viewportHeight = viewportHeight;
+    }
+
+    private TableViewPage()
+    {
+      m_innerPage = TableViewPageInfo.Empty;
+      m_outerPage = TableViewPageInfo.Empty;
+    }
+
+    #endregion
+
+    #region InnerPage Property
+
+    public TableViewPageInfo InnerPage
+    {
+      get
+      {
+        return m_innerPage;
+      }
+    }
+
+    private readonly TableViewPageInfo m_innerPage;
+
+    #endregion
+
+    #region OuterPage Property
+
+    public TableViewPageInfo OuterPage
+    {
+      get
+      {
+        return m_outerPage;
+      }
+    }
+
+    private readonly TableViewPageInfo m_outerPage;
+
+    #endregion
+
+    #region ViewportHeight Property
+
+    public double ViewportHeight
+    {
+      get
+      {
+        return m_viewportHeight;
+      }
+    }
+
+    private readonly double m_viewportHeight; //0d
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPageInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPageInfo.cs
new file mode 100644
index 00000000..729a0b03
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPageInfo.cs
@@ -0,0 +1,179 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal abstract class TableViewPageInfo : IEquatable<TableViewPageInfo>
+  {
+    #region Static Fields
+
+    internal static readonly TableViewPageInfo Empty = new EmptyPageInfo();
+
+    #endregion
+
+    #region Constructor
+
+    protected TableViewPageInfo()
+    {
+    }
+
+    #endregion
+
+    #region Start Property
+
+    public abstract int Start
+    {
+      get;
+    }
+
+    #endregion
+
+    #region End Property
+
+    public abstract int End
+    {
+      get;
+    }
+
+    #endregion
+
+    #region Length Property
+
+    public abstract int Length
+    {
+      get;
+    }
+
+    #endregion
+
+    #region Size Property
+
+    public abstract double Size
+    {
+      get;
+    }
+
+    #endregion
+
+    public static bool operator ==( TableViewPageInfo objA, TableViewPageInfo objB )
+    {
+      if( object.ReferenceEquals( objA, null ) )
+        return object.ReferenceEquals( objB, null );
+
+      return objA.Equals( objB );
+    }
+
+    public static bool operator !=( TableViewPageInfo objA, TableViewPageInfo objB )
+    {
+      return !( objA == objB );
+    }
+
+    public sealed override int GetHashCode()
+    {
+      return this.GetHashCodeImpl();
+    }
+
+    public sealed override bool Equals( object obj )
+    {
+      return this.Equals( obj as TableViewPageInfo );
+    }
+
+    public bool Equals( TableViewPageInfo obj )
+    {
+      if( object.ReferenceEquals( obj, null ) )
+        return false;
+
+      if( object.ReferenceEquals( obj, this ) )
+        return true;
+
+      if( obj.GetHashCode() != this.GetHashCode() )
+        return false;
+
+      return this.EqualsImpl( obj );
+    }
+
+    public abstract bool TryGetStart( out int value );
+    public abstract bool TryGetEnd( out int value );
+
+    protected abstract int GetHashCodeImpl();
+    protected abstract bool EqualsImpl( TableViewPageInfo obj );
+
+    #region EmptyPageInfo Private Class
+
+    private sealed class EmptyPageInfo : TableViewPageInfo
+    {
+      public override int Start
+      {
+        get
+        {
+          throw new NotSupportedException();
+        }
+      }
+
+      public override int End
+      {
+        get
+        {
+          throw new NotSupportedException();
+        }
+      }
+
+      public override int Length
+      {
+        get
+        {
+          return 0;
+        }
+      }
+
+      public override double Size
+      {
+        get
+        {
+          return 0d;
+        }
+      }
+
+      protected override int GetHashCodeImpl()
+      {
+        return 0;
+      }
+
+      protected override bool EqualsImpl( TableViewPageInfo obj )
+      {
+        return object.ReferenceEquals( obj, this );
+      }
+
+      public override bool TryGetStart( out int value )
+      {
+        value = 0;
+
+        return false;
+      }
+
+      public override bool TryGetEnd( out int value )
+      {
+        value = 0;
+
+        return false;
+      }
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPartialPageInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPartialPageInfo.cs
new file mode 100644
index 00000000..8bcd9e34
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewPartialPageInfo.cs
@@ -0,0 +1,47 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal abstract class TableViewPartialPageInfo : TableViewPageInfo
+  {
+    #region Length Property
+
+    public sealed override int Length
+    {
+      get
+      {
+        throw new NotSupportedException();
+      }
+    }
+
+    #endregion
+
+    #region Size Property
+
+    public sealed override double Size
+    {
+      get
+      {
+        throw new NotSupportedException();
+      }
+    }
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewScrollViewer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewScrollViewer.cs
index f1ebc7ba..ac781167 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewScrollViewer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewScrollViewer.cs
@@ -15,15 +15,15 @@
   ***********************************************************************************/
 
 using System;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Windows;
-using System.Windows.Media;
-using System.Windows.Controls.Primitives;
 using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Data;
 using System.Windows.Input;
+using System.Windows.Media;
 using Xceed.Utils.Wpf;
-using System.Windows.Data;
-using Xceed.Wpf.DataGrid.Converters;
-using System.Diagnostics;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
@@ -33,7 +33,9 @@ namespace Xceed.Wpf.DataGrid.Views
     static TableViewScrollViewer()
     {
       DefaultStyleKeyProperty.OverrideMetadata( typeof( TableViewScrollViewer ), new FrameworkPropertyMetadata( typeof( TableViewScrollViewer ) ) );
-      StoredFixedTransformProperty = StoredFixedTransformPropertyKey.DependencyProperty;
+
+      TableViewScrollViewer.HorizontalScrollBarVisibilityHintProperty = TableViewScrollViewer.HorizontalScrollBarVisibilityHintPropertyKey.DependencyProperty;
+      TableViewScrollViewer.StoredFixedTransformProperty = TableViewScrollViewer.StoredFixedTransformPropertyKey.DependencyProperty;
     }
 
     public TableViewScrollViewer()
@@ -54,22 +56,21 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region RowSelectorPaneWidth Property
 
-    public static readonly DependencyProperty RowSelectorPaneWidthProperty =
-        DependencyProperty.Register(
-          "RowSelectorPaneWidth",
-          typeof( double ),
-          typeof( TableViewScrollViewer ),
-          new FrameworkPropertyMetadata( 20d ) );
+    public static readonly DependencyProperty RowSelectorPaneWidthProperty = DependencyProperty.Register(
+      "RowSelectorPaneWidth",
+      typeof( double ),
+      typeof( TableViewScrollViewer ),
+      new FrameworkPropertyMetadata( 20d ) );
 
     public double RowSelectorPaneWidth
     {
       get
       {
-        return ( double )this.GetValue( RowSelectorPaneWidthProperty );
+        return ( double )this.GetValue( TableViewScrollViewer.RowSelectorPaneWidthProperty );
       }
       set
       {
-        this.SetValue( RowSelectorPaneWidthProperty, value );
+        this.SetValue( TableViewScrollViewer.RowSelectorPaneWidthProperty, value );
       }
     }
 
@@ -77,34 +78,66 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region ShowRowSelectorPane Property
 
-    public static readonly DependencyProperty ShowRowSelectorPaneProperty =
-        DependencyProperty.Register(
-          "ShowRowSelectorPane",
-          typeof( bool ),
-          typeof( TableViewScrollViewer ),
-          new FrameworkPropertyMetadata( true ) );
+    public static readonly DependencyProperty ShowRowSelectorPaneProperty = DependencyProperty.Register(
+      "ShowRowSelectorPane",
+      typeof( bool ),
+      typeof( TableViewScrollViewer ),
+      new FrameworkPropertyMetadata( true ) );
 
     public bool ShowRowSelectorPane
     {
       get
       {
-        return ( bool )this.GetValue( ShowRowSelectorPaneProperty );
+        return ( bool )this.GetValue( TableViewScrollViewer.ShowRowSelectorPaneProperty );
       }
       set
       {
-        this.SetValue( ShowRowSelectorPaneProperty, value );
+        this.SetValue( TableViewScrollViewer.ShowRowSelectorPaneProperty, value );
       }
     }
 
     #endregion ShowRowSelectorPane Property
 
+    #region HorizontalScrollBarVisibilityHint Property
+
+    private static readonly DependencyPropertyKey HorizontalScrollBarVisibilityHintPropertyKey = DependencyProperty.RegisterReadOnly(
+      "HorizontalScrollBarVisibilityHint",
+      typeof( ScrollBarVisibility ),
+      typeof( TableViewScrollViewer ),
+      new FrameworkPropertyMetadata( ScrollBarVisibility.Auto ) );
+
+    [Browsable( false )]
+    [EditorBrowsable( EditorBrowsableState.Never )]
+    public static readonly DependencyProperty HorizontalScrollBarVisibilityHintProperty;
+
+    [Browsable( false )]
+    [EditorBrowsable( EditorBrowsableState.Never )]
+    public ScrollBarVisibility HorizontalScrollBarVisibilityHint
+    {
+      get
+      {
+        return ( ScrollBarVisibility )this.GetValue( TableViewScrollViewer.HorizontalScrollBarVisibilityHintProperty );
+      }
+    }
+
+    private void SetHorizontalScrollBarVisibilityHint( ScrollBarVisibility value )
+    {
+      this.SetValue( TableViewScrollViewer.HorizontalScrollBarVisibilityHintPropertyKey, value );
+    }
+
+    private void ResetHorizontalScrollBarVisibilityHint()
+    {
+      this.ClearValue( TableViewScrollViewer.HorizontalScrollBarVisibilityHintPropertyKey );
+    }
+
+    #endregion HorizontalScrollBarVisibilityHint Property
+
     #region StoredFixedTransform Attached Property
 
-    internal static readonly DependencyPropertyKey StoredFixedTransformPropertyKey =
-        DependencyProperty.RegisterAttachedReadOnly( "StoredFixedTransform",
-        typeof( Transform ),
-        typeof( TableViewScrollViewer ),
-        new UIPropertyMetadata( null ) );
+    internal static readonly DependencyPropertyKey StoredFixedTransformPropertyKey = DependencyProperty.RegisterAttachedReadOnly( "StoredFixedTransform",
+      typeof( Transform ),
+      typeof( TableViewScrollViewer ),
+      new UIPropertyMetadata( null ) );
 
     internal static readonly DependencyProperty StoredFixedTransformProperty;
 
@@ -138,6 +171,8 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
+    private RowSelectorPane m_rowSelectorPane;
+
     #endregion
 
     public override void OnApplyTemplate()
@@ -147,29 +182,26 @@ namespace Xceed.Wpf.DataGrid.Views
       m_rowSelectorPane = this.Template.FindName( "PART_RowSelectorPane", this ) as RowSelectorPane;
     }
 
-    internal static void SetFixedTranslateTransform( UIElement element, bool canScrollHorizontally )
+    protected override Size MeasureOverride( Size constraint )
+    {
+      this.UpdateHorizontalScrollBarVisibilityHint( constraint );
+
+      return base.MeasureOverride( constraint );
+    }
+
+    internal static void SetFixedTranslateTransform( FrameworkElement element, bool canScrollHorizontally )
     {
       if( element == null )
         throw new ArgumentNullException( "element" );
 
-      ScrollViewer parentScrollViewer = TableViewScrollViewer.GetParentScrollViewer( element ) as ScrollViewer;
-
-      if( parentScrollViewer != null )
+      if( !TableViewScrollViewer.SetFixedTranslateTransformCore( element, canScrollHorizontally ) )
       {
-        Transform fixedTransform = TableViewScrollViewer.GetStoredFixedTransform( parentScrollViewer );
-
-        Debug.Assert( fixedTransform != null );
-
-        if( canScrollHorizontally )
-        {
-          if( element.RenderTransform == fixedTransform )
-          {
-            element.ClearValue( UIElement.RenderTransformProperty );
-          }
-        }
-        else
+        if( !element.IsLoaded )
         {
-          element.RenderTransform = fixedTransform;
+          // The method failed to apply the translate transform because it could not find a ScrollViewer
+          // among its ancestors.  Try again when the element will be loaded in case it wasn't in the
+          // VisualTree.
+          element.Loaded += new RoutedEventHandler( TableViewScrollViewer.OnFixedElementLoaded );
         }
       }
     }
@@ -215,6 +247,43 @@ namespace Xceed.Wpf.DataGrid.Views
       return newTransform;
     }
 
+    private static bool SetFixedTranslateTransformCore( FrameworkElement element, bool canScrollHorizontally )
+    {
+      Debug.Assert( element != null );
+
+      var parentScrollViewer = TableViewScrollViewer.GetParentScrollViewer( element ) as ScrollViewer;
+      if( parentScrollViewer == null )
+        return false;
+
+      var fixedTransform = TableViewScrollViewer.GetStoredFixedTransform( parentScrollViewer );
+      Debug.Assert( fixedTransform != null );
+
+      if( canScrollHorizontally )
+      {
+        if( element.RenderTransform == fixedTransform )
+        {
+          element.ClearValue( UIElement.RenderTransformProperty );
+        }
+      }
+      else
+      {
+        element.RenderTransform = fixedTransform;
+      }
+
+      return true;
+    }
+
+    private static void OnFixedElementLoaded( object sender, RoutedEventArgs e )
+    {
+      var element = sender as FrameworkElement;
+      if( element == null )
+        return;
+
+      element.Loaded -= new RoutedEventHandler( TableViewScrollViewer.OnFixedElementLoaded );
+
+      TableViewScrollViewer.SetFixedTranslateTransformCore( element, TableView.GetCanScrollHorizontally( element ) );
+    }
+
     private void OnQueryScrollCommand( object sender, CanExecuteRoutedEventArgs e )
     {
       e.CanExecute = true;
@@ -226,7 +295,9 @@ namespace Xceed.Wpf.DataGrid.Views
       FixedCellPanel cellPanel = this.LocateFixedCellPanel( this );
 
       if( cellPanel != null )
+      {
         scrollingViewport -= cellPanel.GetFixedWidth();
+      }
 
       if( e.Command == ScrollBar.PageLeftCommand )
       {
@@ -278,7 +349,32 @@ namespace Xceed.Wpf.DataGrid.Views
       return null;
     }
 
+    private void UpdateHorizontalScrollBarVisibilityHint( Size viewport )
+    {
+      bool isContentLargerThanViewport = false;
+
+      var viewportWidth = viewport.Width;
+      if( !double.IsInfinity( viewportWidth ) )
+      {
+        var dataGridContext = DataGridControl.GetDataGridContext( this );
+        if( dataGridContext != null )
+        {
+          var columnVirtualizationManager = dataGridContext.GetColumnVirtualizationManagerOrNull() as TableViewColumnVirtualizationManagerBase;
+          if( columnVirtualizationManager != null )
+          {
+            isContentLargerThanViewport = ( columnVirtualizationManager.VisibleColumnsWidth > viewportWidth );
+          }
+        }
+      }
 
-    RowSelectorPane m_rowSelectorPane;
+      if( isContentLargerThanViewport )
+      {
+        this.SetHorizontalScrollBarVisibilityHint( ScrollBarVisibility.Visible );
+      }
+      else
+      {
+        this.ResetHorizontalScrollBarVisibilityHint();
+      }
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewStartPageInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewStartPageInfo.cs
new file mode 100644
index 00000000..14b2d4bd
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/TableViewStartPageInfo.cs
@@ -0,0 +1,89 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid.Views
+{
+  internal sealed class TableViewStartPageInfo : TableViewPartialPageInfo
+  {
+    #region Constructor
+
+    internal TableViewStartPageInfo( int value )
+    {
+      if( value < 0 )
+        throw new ArgumentException( "value must be greater than or equal to zero.", "value" );
+
+      m_value = value;
+    }
+
+    #endregion
+
+    #region Start Property
+
+    public override int Start
+    {
+      get
+      {
+        return m_value;
+      }
+    }
+
+    private readonly int m_value;
+
+    #endregion
+
+    #region End Property
+
+    public override int End
+    {
+      get
+      {
+        throw new NotSupportedException();
+      }
+    }
+
+    #endregion
+
+    protected override int GetHashCodeImpl()
+    {
+      return m_value;
+    }
+
+    protected override bool EqualsImpl( TableViewPageInfo obj )
+    {
+      var page = obj as TableViewStartPageInfo;
+      if( object.ReferenceEquals( page, null ) )
+        return false;
+
+      return ( page.m_value == m_value );
+    }
+
+    public override bool TryGetStart( out int value )
+    {
+      value = m_value;
+
+      return true;
+    }
+
+    public override bool TryGetEnd( out int value )
+    {
+      value = 0;
+
+      return false;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/Theme.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/Theme.cs
index 04397f52..2f3c8576 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/Theme.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/Theme.cs
@@ -15,9 +15,7 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel;
-using System.Text;
 using System.Windows;
 using Xceed.Wpf.DataGrid.Markup;
 
@@ -43,6 +41,16 @@ namespace Xceed.Wpf.DataGrid.Views
 
       return false;
     }
+
+    protected virtual ThemeKey CreateDefaultStyleKey( Type viewType, Type elementType )
+    {
+      return new ThemeKey( viewType, this.GetType(), elementType );
+    }
+
+    internal ThemeKey GetDefaultStyleKey( Type viewType, Type elementType )
+    {
+      return this.CreateDefaultStyleKey( viewType, elementType );
+    }
   }
 
   [TargetView( typeof( TableflowView ) )]
@@ -93,7 +101,7 @@ namespace Xceed.Wpf.DataGrid.Views
   {
   }
 
-  [TargetView(typeof(TableflowView))]
+  [TargetView( typeof( TableflowView ) )]
   public class Windows8Theme : Theme
   {
   }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/UIViewBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/UIViewBase.cs
index b061f509..3dfecec0 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/UIViewBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/UIViewBase.cs
@@ -33,7 +33,7 @@ namespace Xceed.Wpf.DataGrid.Views
     #region Static Fields
 
     // We must add a setter since this value is used as default
-    // value of a DependencyObject which will be instantiated
+    // value of a DependencyObject which will be instanciated
     // before the static constructor is called
     internal static Cursor DefaultGroupDraggedOutsideCursor
     {
@@ -108,8 +108,8 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region DropMarkOrientation Attached Property
 
-    public static readonly DependencyProperty DropMarkOrientationProperty = DependencyProperty.RegisterAttached( 
-      "DropMarkOrientation", typeof( DropMarkOrientation ), typeof( UIViewBase ), 
+    public static readonly DependencyProperty DropMarkOrientationProperty = DependencyProperty.RegisterAttached(
+      "DropMarkOrientation", typeof( DropMarkOrientation ), typeof( UIViewBase ),
       new FrameworkPropertyMetadata( DropMarkOrientation.Default, FrameworkPropertyMetadataOptions.Inherits ) );
 
     public static DropMarkOrientation GetDropMarkOrientation( DependencyObject obj )
@@ -477,5 +477,6 @@ namespace Xceed.Wpf.DataGrid.Views
     }
 
     #endregion
+
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewBase.cs
index 2f175792..05ef4d67 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewBase.cs
@@ -15,15 +15,14 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
 using System.Windows;
-using System.Windows.Media;
 using Xceed.Wpf.DataGrid.Markup;
-using System.Collections;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Diagnostics;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
@@ -33,37 +32,15 @@ namespace Xceed.Wpf.DataGrid.Views
 
     internal static object GetDefaultStyleKey( Type viewType, Type elementType )
     {
-      return ViewBase.GetDefaultStyleKey( viewType, null, elementType );
+      return new ThemeKey( viewType, null, elementType );
     }
 
     private static object GetDefaultStyleKey( Type viewType, Theme theme, Type elementType )
     {
-      Type themeType = ( theme == null ) ? null : theme.GetType();
-
-      if( themeType != null )
-      {
-        Type metroThemeType = themeType.Assembly.GetType( "Xceed.Wpf.DataGrid.Themes.Metro.MetroTheme" );
-        if( ( metroThemeType != null ) && metroThemeType.IsAssignableFrom( themeType ) )
-        {
-          PropertyInfo trd = metroThemeType.GetProperty( "ThemeResourceDictionary" );
-          if( trd != null )
-          {
-            ResourceDictionary rd = ( ResourceDictionary )trd.GetValue( theme, null );
-            if( rd != null )
-            {
-              PropertyInfo ab = rd.GetType().GetProperty( "AccentBrush" );
-              if( ab != null )
-              {
-                Brush accentBrush = ( Brush )ab.GetValue( rd, null );
-                return new ThemeKey( viewType, themeType, elementType, accentBrush );
-              }
-            }
-          }
-          throw new InvalidOperationException( "MetroTheme found but AccentBrush was not found." );
-        }
-      }
+      if( theme == null )
+        return ViewBase.GetDefaultStyleKey( viewType, elementType );
 
-      return new ThemeKey( viewType, themeType, elementType );
+      return theme.GetDefaultStyleKey( viewType, elementType );
     }
 
     #endregion Static Members
@@ -122,8 +99,11 @@ namespace Xceed.Wpf.DataGrid.Views
 
     private void OnThemeChanged( DependencyPropertyChangedEventArgs e )
     {
-      if( this.ThemeChanged != null )
-        this.ThemeChanged( this, e );
+      var handler = this.ThemeChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, e );
     }
 
     private static void ThemeChangedCallback( DependencyObject sender, DependencyPropertyChangedEventArgs e )
@@ -292,7 +272,7 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    #endregion DescendingSortGlyph Property
+    #endregion SortOrderGlyph Property
 
     #region ExpandGroupGlyph Property
 
@@ -363,8 +343,8 @@ namespace Xceed.Wpf.DataGrid.Views
 
     #region IsLastItem Attached Property
 
-    public static readonly DependencyProperty IsLastItemProperty = DependencyProperty.RegisterAttached( 
-      "IsLastItem", typeof( bool ), typeof( ViewBase ), 
+    public static readonly DependencyProperty IsLastItemProperty = DependencyProperty.RegisterAttached(
+      "IsLastItem", typeof( bool ), typeof( ViewBase ),
       new FrameworkPropertyMetadata( false, FrameworkPropertyMetadataOptions.Inherits ) );
 
     public static bool GetIsLastItem( DependencyObject obj )
@@ -385,15 +365,13 @@ namespace Xceed.Wpf.DataGrid.Views
       "PreserveContainerSize",
       typeof( bool ),
       typeof( ViewBase ),
-      new FrameworkPropertyMetadata(
-        true,
-        new PropertyChangedCallback( ViewBase.OnPreserveContainerSizeChanged ) ) );
+      new FrameworkPropertyMetadata( true ) );
 
     internal bool PreserveContainerSize
     {
       get
       {
-        return m_preserveContainerSize;
+        return ( bool )this.GetValue( ViewBase.PreserveContainerSizeProperty );
       }
       set
       {
@@ -401,18 +379,6 @@ namespace Xceed.Wpf.DataGrid.Views
       }
     }
 
-    private static void OnPreserveContainerSizeChanged( DependencyObject sender, DependencyPropertyChangedEventArgs e )
-    {
-      ViewBase uiViewBase = sender as ViewBase;
-
-      if( uiViewBase == null )
-        return;
-
-      uiViewBase.m_preserveContainerSize = ( bool )e.NewValue;
-    }
-
-    private bool m_preserveContainerSize = true;
-
     #endregion
 
     #region ViewTypeForThemeKey Property
@@ -431,7 +397,7 @@ namespace Xceed.Wpf.DataGrid.Views
 
     protected virtual void AddDefaultHeadersFooters()
     {
-    } 
+    }
 
     #endregion
 
@@ -458,99 +424,135 @@ namespace Xceed.Wpf.DataGrid.Views
       return ViewBase.GetDefaultStyleKey( this.ViewTypeForThemeKey, this.Theme, elementType );
     }
 
-    internal IEnumerable<DependencyProperty> GetViewProperties()
+    internal IEnumerable<ViewPropertyStruct> GetViewProperties()
     {
       //This will ensure that the GetViewPropertiesCore will be called only once by instance of view (optimization to avoir re-doing it all the time ).
       if( m_viewProperties == null )
       {
-        List<DependencyProperty> viewProperties = new List<DependencyProperty>();
-
-        this.GetViewPropertiesCore( viewProperties, ViewPropertyMode.ViewOnly );
-
-        m_viewProperties = viewProperties;
+        m_viewProperties = this.GetViewPropertiesCore( ViewPropertyMode.ViewOnly ).ToArray();
       }
 
       return m_viewProperties;
     }
 
-    internal IEnumerable<DependencyProperty> GetSharedProperties()
+    internal IEnumerable<ViewPropertyStruct> GetSharedProperties()
     {
       //This will ensure that the GetViewPropertiesCore will be called only once by instance of view (optimization to avoir re-doing it all the time ).
       if( m_sharedProperties == null )
       {
-        List<DependencyProperty> sharedProperties = new List<DependencyProperty>();
-
-        this.GetViewPropertiesCore( sharedProperties, ViewPropertyMode.Routed );
-
-        m_sharedProperties = sharedProperties;
+        m_sharedProperties = this.GetViewPropertiesCore( ViewPropertyMode.Routed ).ToArray();
       }
 
       return m_sharedProperties;
     }
 
-    internal IEnumerable<DependencyProperty> GetSharedNoFallbackProperties()
+    internal IEnumerable<ViewPropertyStruct> GetSharedNoFallbackProperties()
     {
       //This will ensure that the GetViewPropertiesCore will be called only once by instance of view (optimization to avoir re-doing it all the time ).
       if( m_sharedNoFallbackProperties == null )
       {
-        List<DependencyProperty> sharedNoFallbackProperties = new List<DependencyProperty>();
-
-        this.GetViewPropertiesCore( sharedNoFallbackProperties, ViewPropertyMode.RoutedNoFallback );
-
-        m_sharedNoFallbackProperties = sharedNoFallbackProperties;
+        m_sharedNoFallbackProperties = this.GetViewPropertiesCore( ViewPropertyMode.RoutedNoFallback ).ToArray();
       }
 
       return m_sharedNoFallbackProperties;
-    } 
+    }
 
     #endregion
 
     #region Private Methods
 
-    private void GetViewPropertiesCore( List<DependencyProperty> viewProperties, ViewPropertyMode viewPropertyMode )
+    private static ViewPropertyAttribute GetViewPropertyAttribute( MemberInfo memberInfo )
     {
-      FieldInfo[] fields = this.GetType().GetFields( BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy );
+      if( memberInfo == null )
+        return null;
+
+      var attributes = memberInfo.GetCustomAttributes( typeof( ViewPropertyAttribute ), true );
+      if( ( attributes == null ) || ( attributes.GetLength( 0 ) != 1 ) )
+        return null;
 
+      return ( ViewPropertyAttribute )attributes[ 0 ];
+    }
+
+    private IEnumerable<ViewPropertyStruct> GetViewPropertiesCore( ViewPropertyMode viewPropertyMode )
+    {
+      var fields = this.GetType().GetFields( BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy );
       foreach( FieldInfo field in fields )
       {
-        //filter out any public static field that is not a DependencyProperty ( no examples )
-        if( field.FieldType == typeof( DependencyProperty ) )
-        {
-          object[] viewPropertyAttributes = field.GetCustomAttributes( typeof( ViewPropertyAttribute ), true );
-
-          //If there is no attribute set on the DP field.
-          if( viewPropertyAttributes.GetLength( 0 ) == 0 )
-          {
-            //Do nothing, the DP shall not be used as a ViewProperty
-          }
-          else if( viewPropertyAttributes.GetLength( 0 ) == 1 )
-          {
-            //The attribute has been set on the DP field.
-            ViewPropertyAttribute attrib = ( ViewPropertyAttribute )viewPropertyAttributes[ 0 ];
-
-            if( viewPropertyMode == attrib.ViewPropertyMode )
-            {
-              viewProperties.Add( ( DependencyProperty )field.GetValue( null ) ); // parameter is ignored for static fields.
-            }
-          }
-          else
-          {
-            //More than one ViewProperty attribute has been set on the same field.
-            throw new InvalidOperationException( "An attempt was made to the ViewProperty Attribute more than once on a single DependencyProperty field." );
-          }
-        } // end if: FieldType is DependencyProperty
-      } //end foreach: fields
-    } 
+        //Filter out any public static field that is not a DependencyProperty ( no examples )
+        if( field.FieldType != typeof( DependencyProperty ) )
+          continue;
+
+        //Filter out all DependencyProperty that doesn't match the ViewPropertyMode.
+        var attribute = ViewBase.GetViewPropertyAttribute( field );
+        if( ( attribute == null ) || ( attribute.ViewPropertyMode != viewPropertyMode ) )
+          continue;
+
+        var dependencyProperty = ( DependencyProperty )field.GetValue( null ); // parameter is ignored for static fields.
+        Debug.Assert( dependencyProperty != null );
+
+        if( dependencyProperty.ReadOnly )
+          throw new InvalidOperationException( "An attempt was made to return a read-only property. Dependency properties returned by ViewBase.GetViewPropertiesCore() cannot be read-only." );
+
+        yield return new ViewPropertyStruct( dependencyProperty, attribute.ViewPropertyMode, attribute.FlattenDetailBindingMode );
+      }
+    }
 
     #endregion
 
     #region Private Fields
 
-    private IEnumerable<DependencyProperty> m_viewProperties; // = null
-    private IEnumerable<DependencyProperty> m_sharedProperties; // = null
-    private IEnumerable<DependencyProperty> m_sharedNoFallbackProperties; // = null
+    private IEnumerable<ViewPropertyStruct> m_viewProperties; // = null
+    private IEnumerable<ViewPropertyStruct> m_sharedProperties; // = null
+    private IEnumerable<ViewPropertyStruct> m_sharedNoFallbackProperties; // = null
     private bool m_defaultHeadersFootersAdded; // = false 
 
     #endregion
+
+    #region ViewPropertyStruct Nested Type
+
+    internal struct ViewPropertyStruct
+    {
+      internal ViewPropertyStruct( DependencyProperty dependencyProperty )
+      {
+        if( dependencyProperty == null )
+          throw new ArgumentNullException( "dependencyProperty" );
+
+        this.DependencyProperty = dependencyProperty;
+        this.ViewPropertyMode = ViewPropertyMode.None;
+        this.FlattenDetailBindingMode = FlattenDetailBindingMode.Default;
+      }
+
+      internal ViewPropertyStruct(
+        DependencyProperty dependencyProperty,
+        ViewPropertyMode viewPropertyMode,
+        FlattenDetailBindingMode flattenDetailBindingMode )
+      {
+        if( dependencyProperty == null )
+          throw new ArgumentNullException( "dependencyProperty" );
+
+        this.DependencyProperty = dependencyProperty;
+        this.ViewPropertyMode = viewPropertyMode;
+        this.FlattenDetailBindingMode = flattenDetailBindingMode;
+      }
+
+      internal readonly DependencyProperty DependencyProperty;
+      internal readonly ViewPropertyMode ViewPropertyMode;
+      internal readonly FlattenDetailBindingMode FlattenDetailBindingMode;
+
+      public override bool Equals( object obj )
+      {
+        if( !( obj is ViewPropertyStruct ) )
+          return false;
+
+        return ( this.DependencyProperty == ( ( ViewPropertyStruct )obj ).DependencyProperty );
+      }
+
+      public override int GetHashCode()
+      {
+        return this.DependencyProperty.GetHashCode();
+      }
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewPropertyAttribute.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewPropertyAttribute.cs
index c54845b1..5e316b80 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewPropertyAttribute.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Views/ViewPropertyAttribute.cs
@@ -15,19 +15,29 @@
   ***********************************************************************************/
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace Xceed.Wpf.DataGrid.Views
 {
-  [AttributeUsage( AttributeTargets.Field )] // Applies only to the fields that store the DependencyProperties
+  [AttributeUsage( AttributeTargets.Field, AllowMultiple = false )] // Applies only to the fields that store the DependencyProperties
   public sealed class ViewPropertyAttribute : Attribute
   {
+    #region Constructors
+
     public ViewPropertyAttribute( ViewPropertyMode viewPropertyMode )
+      : this( viewPropertyMode, FlattenDetailBindingMode.Default )
+    {
+    }
+
+    internal ViewPropertyAttribute( ViewPropertyMode viewPropertyMode, FlattenDetailBindingMode flattenDetailBindingMode )
     {
       m_viewPropertyMode = viewPropertyMode;
+      m_flattenDetailBindingMode = flattenDetailBindingMode;
     }
 
+    #endregion
+
+    #region ViewPropertyMode Property
+
     public ViewPropertyMode ViewPropertyMode
     {
       get
@@ -35,6 +45,23 @@ namespace Xceed.Wpf.DataGrid.Views
         return m_viewPropertyMode;
       }
     }
-    private ViewPropertyMode m_viewPropertyMode = ViewPropertyMode.None;
+
+    private readonly ViewPropertyMode m_viewPropertyMode = ViewPropertyMode.None;
+
+    #endregion
+
+    #region FlattenDetailBindingMode Internal Property
+
+    internal FlattenDetailBindingMode FlattenDetailBindingMode
+    {
+      get
+      {
+        return m_flattenDetailBindingMode;
+      }
+    }
+
+    private readonly FlattenDetailBindingMode m_flattenDetailBindingMode = FlattenDetailBindingMode.Default;
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VirtualizingCellCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VirtualizingCellCollection.cs
index fa32e42a..90402e7e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VirtualizingCellCollection.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VirtualizingCellCollection.cs
@@ -32,6 +32,7 @@ namespace Xceed.Wpf.DataGrid
         throw new ArgumentNullException( "parentRow" );
 
       m_parentRow = parentRow;
+      m_cells = new CellSet( parentRow );
       m_readOnlyCellsCollection = new ReadOnlyCollection<Cell>( m_cells );
 
       // We must assign the VirtualizingCellCollection of the VirtualizingItemsList manually
@@ -68,7 +69,7 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region DataGridContext Property (Private)
+    #region DataGridContext Private Property
 
     private DataGridContext DataGridContext
     {
@@ -80,30 +81,38 @@ namespace Xceed.Wpf.DataGrid
 
     #endregion
 
-    #region ColumnManager Property (Private)
+    #region Columns Private Property
 
-    private ColumnVirtualizationManager ColumnManager
+    private ColumnCollection Columns
     {
       get
       {
-        DataGridContext context = this.DataGridContext;
-        if( context == null )
-          throw new DataGridInternalException();
+        if( this.DataGridContext == null )
+          return null;
 
-        return context.ColumnVirtualizationManager;
+        return this.DataGridContext.Columns;
       }
     }
 
     #endregion
 
-    #region NeedsNotification Property
+    #region IsUpdating Property
 
-    internal bool AlreadyUpdating
+    internal bool IsUpdating
     {
-      get;
-      set;
+      get
+      {
+        return m_isUpdating.IsSet;
+      }
     }
 
+    internal IDisposable SetIsUpdating()
+    {
+      return m_isUpdating.Set();
+    }
+
+    private readonly AutoResetFlag m_isUpdating = AutoResetFlagFactory.Create();
+
     #endregion
 
     #region CollectionChanged Event
@@ -112,10 +121,11 @@ namespace Xceed.Wpf.DataGrid
 
     private void NotifyCollectionChanged()
     {
-      if( this.CollectionChanged != null )
-      {
-        this.CollectionChanged( this, EventArgs.Empty );
-      }
+      var handler = this.CollectionChanged;
+      if( handler == null )
+        return;
+
+      handler.Invoke( this, EventArgs.Empty );
     }
 
     #endregion
@@ -124,7 +134,7 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return this.GetCell( column );
+        return this.GetCell( column, true );
       }
     }
 
@@ -132,7 +142,7 @@ namespace Xceed.Wpf.DataGrid
     {
       get
       {
-        return this.GetCell( fieldName );
+        return this.GetCell( this.GetColumn( fieldName ), true );
       }
     }
 
@@ -163,16 +173,11 @@ namespace Xceed.Wpf.DataGrid
 
     internal override void InternalClear()
     {
-      this.Unregister( m_bindedCells.Values );
+      m_recyclingBins = null;
+      m_freeCells = null;
 
       m_bindedCells.Clear();
-      m_recyclingBins.Clear();
-
-      m_freeCells.Clear();
-      m_freeCells.TrimExcess();
-
       m_cells.Clear();
-      m_cells.TrimExcess();
     }
 
     internal override void InternalInsert( int index, Cell cell )
@@ -187,7 +192,7 @@ namespace Xceed.Wpf.DataGrid
 
     internal override void InternalRemoveAt( int index )
     {
-      ColumnBase column = this.DataGridContext.Columns[ index ];
+      ColumnBase column = this.Columns[ index ];
       if( column == null )
         return;
 
@@ -206,7 +211,7 @@ namespace Xceed.Wpf.DataGrid
     internal void Release( Cell cell )
     {
       // Make sure the cell is allowed to be recycled.
-      if( ( cell == null ) || ( !this.IsRecyclableCell( cell ) ) )
+      if( ( cell == null ) || ( !VirtualizingCellCollection.IsRecyclableCell( cell ) ) )
         return;
 
       // Remove the target cell from the binded cells.
@@ -215,7 +220,46 @@ namespace Xceed.Wpf.DataGrid
       cell.Visibility = Visibility.Collapsed;
     }
 
+    internal Cell GetCell( string fieldName, bool prepareCell )
+    {
+      if( string.IsNullOrEmpty( fieldName ) )
+        return null;
+
+      Cell cell;
+      if( this.TryGetCell( fieldName, prepareCell, out cell ) )
+        return cell;
+
+      return this.CreateOrRecycleCell( fieldName );
+    }
+
+    internal Cell GetCell( ColumnBase column, bool prepareCell )
+    {
+      if( column == null )
+        return null;
+
+      Cell cell;
+      if( this.TryGetCell( column, prepareCell, out cell ) )
+        return cell;
+
+      return this.CreateOrRecycleCell( column, this.DataGridContext );
+    }
+
+    internal bool TryGetCell( string fieldName, out Cell cell )
+    {
+      return this.TryGetCell( fieldName, true, out cell );
+    }
+
     internal bool TryGetCell( ColumnBase column, out Cell cell )
+    {
+      return this.TryGetCell( column, true, out cell );
+    }
+
+    internal bool TryGetCell( string fieldName, bool prepareCell, out Cell cell )
+    {
+      return this.TryGetCell( this.GetColumn( fieldName ), prepareCell, out cell );
+    }
+
+    internal bool TryGetCell( ColumnBase column, bool prepareCell, out Cell cell )
     {
       cell = null;
       if( column == null )
@@ -226,24 +270,37 @@ namespace Xceed.Wpf.DataGrid
       if( !m_bindedCells.TryGetValue( column.FieldName, out cell ) )
         return false;
 
-      this.PrepareCell( cell, column, this.DataGridContext );
+      if( prepareCell )
+      {
+        this.PrepareCell( cell, column, this.DataGridContext );
+      }
 
       return true;
     }
 
-    internal void ClearUnusedRecycleBins( IEnumerable<ColumnBase> columns )
+    internal bool TryGetBindedCell( string fieldName, out Cell cell )
     {
-      if( m_recyclingBins.Count == 0 )
+      this.MergeFreeCells();
+
+      if( m_bindedCells.TryGetValue( fieldName, out cell ) )
+        return true;
+
+      return false;
+    }
+
+    internal void ClearUnusedRecycleBins( ColumnCollection columns )
+    {
+      if( m_recyclingBins == null )
         return;
 
-      HashSet<object> unusedRecyclingGroups = new HashSet<object>( m_recyclingBins.Keys );
+      var unusedRecyclingGroups = new HashSet<object>( m_recyclingBins.Keys );
 
       if( columns != null )
       {
         foreach( ColumnBase column in columns )
         {
           if( unusedRecyclingGroups.Count == 0 )
-            return;
+            break;
 
           unusedRecyclingGroups.Remove( this.GetRecyclingGroup( column ) );
         }
@@ -259,30 +316,10 @@ namespace Xceed.Wpf.DataGrid
           m_cells.Remove( cell );
         }
       }
-    }
-
-    private void OnCellRequestBringIntoView( object sender, RequestBringIntoViewEventArgs e )
-    {
-      Cell cell = e.Source as Cell;
-      if( cell == null )
-        return;
-
-      // Make sure the the current row if the cell's parent row.
-      Row parentRow = cell.ParentRow;
-      if( parentRow != m_parentRow )
-      {
-        this.Unregister( cell );
-        return;
-      }
-
-      // Do not process the bring into view for a templated cell.
-      if( this.IsTemplatedCell( cell ) )
-        return;
 
-      IVirtualizingCellsHost cellsHost = parentRow.CellsHostPanel as IVirtualizingCellsHost;
-      if( cellsHost != null )
+      if( m_recyclingBins.Count == 0 )
       {
-        e.Handled = cellsHost.BringIntoView( cell );
+        m_recyclingBins = null;
       }
     }
 
@@ -291,7 +328,7 @@ namespace Xceed.Wpf.DataGrid
       if( cell == null )
         throw new ArgumentNullException( "cell" );
 
-      if( !this.IsFreeCell( cell ) )
+      if( !VirtualizingCellCollection.IsFreeCell( cell ) )
       {
         string fieldName = cell.FieldName;
 
@@ -311,11 +348,14 @@ namespace Xceed.Wpf.DataGrid
       }
       else
       {
+        if( m_freeCells == null )
+        {
+          m_freeCells = new List<Cell>( 1 );
+        }
+
         m_freeCells.Add( cell );
       }
 
-      this.Register( cell );
-
       m_cells.Add( cell );
     }
 
@@ -324,7 +364,7 @@ namespace Xceed.Wpf.DataGrid
       if( cell == null )
         throw new ArgumentNullException( "cell" );
 
-      if( !this.IsFreeCell( cell ) )
+      if( !VirtualizingCellCollection.IsFreeCell( cell ) )
       {
         m_bindedCells.Remove( cell.FieldName );
       }
@@ -333,13 +373,11 @@ namespace Xceed.Wpf.DataGrid
         Debug.Fail( "Should always have a field name" );
       }
 
-      this.Unregister( cell );
-
       if( recycle )
       {
         // Put the cell into the appropriate recycle bin.
-        object recyclingGroup = this.GetRecyclingGroup( this.GetColumn( cell ) );
-        ICollection<Cell> recycleBin = this.GetRecycleBinOrNew( recyclingGroup );
+        var recyclingGroup = this.GetRecyclingGroup( this.GetColumn( cell ) );
+        var recycleBin = this.GetRecycleBinOrNew( recyclingGroup );
 
         // A released cell shouldn't be in the recycle bin already.
         Debug.Assert( !recycleBin.Contains( cell ) );
@@ -351,95 +389,33 @@ namespace Xceed.Wpf.DataGrid
       }
     }
 
-    private void Register( Cell cell )
+    private Cell CreateOrRecycleCell( string fieldName )
     {
-      if( cell == null )
-        return;
-
-      cell.RequestBringIntoView += new RequestBringIntoViewEventHandler( this.OnCellRequestBringIntoView );
+      return this.CreateOrRecycleCell( this.GetColumn( fieldName ), this.DataGridContext );
     }
 
-    private void Unregister( Cell cell )
+    private Cell CreateOrRecycleCell( ColumnBase column, DataGridContext context )
     {
-      if( cell == null )
-        return;
-
-      cell.RequestBringIntoView -= new RequestBringIntoViewEventHandler( this.OnCellRequestBringIntoView );
-    }
-
-    private void Unregister( IEnumerable<Cell> cells )
-    {
-      if( cells == null )
-        return;
-
-      foreach( Cell cell in cells )
+      // Create a new cell if recycling wasn't possible.
+      Cell cell;
+      if( !this.TryGetRecycledCell( column, out cell ) )
       {
-        this.Unregister( cell );
+        cell = m_parentRow.ProvideCell( column );
+        Debug.Assert( cell != null );
       }
-    }
-
-    private Cell GetCell( string fieldName )
-    {
-      if( string.IsNullOrEmpty( fieldName ) )
-        return null;
-
-      DataGridContext context = this.DataGridContext;
-      if( context == null )
+      else
       {
-        Debug.Fail( "An unprepared Row was asked a Cell" );
-        return null;
+        cell.ClearValue( Cell.VisibilityProperty );
       }
 
-      ColumnBase column = this.GetColumn( context, fieldName );
-      if( column == null )
-        return null;
-
-      return this.GetCell( fieldName, column, context );
-    }
-
-    private Cell GetCell( ColumnBase column )
-    {
-      if( column == null )
-        return null;
-
-      return this.GetCell( column.FieldName, column, this.DataGridContext );
-    }
+      // Make sure the cell is initialized and prepared to be used.
+      this.PrepareCell( cell, column, context );
+      this.InternalAdd( cell );
 
-    private Cell GetCell( string fieldName, ColumnBase column, DataGridContext context )
-    {
-      this.CheckFieldName( fieldName );
-      this.MergeFreeCells();
-
-      // Try to recycle a cell if it wasn't already binded.
-      Cell cell;
-      if( !( m_bindedCells.TryGetValue( fieldName, out cell ) ) && ( column != null ) )
-      {
-        // Create a new cell if recycling wasn't possible.
-        if( !this.TryGetRecycledCell( column, out cell ) )
-        {
-          cell = m_parentRow.ProvideCell( column );
-
-          Debug.Assert( cell != null );
-        }
-        else
-        {
-          cell.Visibility = Visibility.Visible;
-        }
-
-        // Make sure the cell is initialized and prepared to be used.
-        this.PrepareCell( cell, column, context );
-        this.InternalAdd( cell );
-
-        //Need to notify only when cells are not already binded, since the binded cells will get properly measured and arranged by the Virtualizing/FixedCellSubPanel(s).
-        if( !this.AlreadyUpdating )
-        {
-          this.NotifyCollectionChanged();
-        }
-      }
-      else if( cell != null )
+      //Need to notify only when cells are not already binded, since the binded cells will get properly measured and arranged by the Virtualizing/FixedCellSubPanel(s).
+      if( !this.IsUpdating )
       {
-        // Make sure the cell is initialized and prepared to be used.
-        this.PrepareCell( cell, column, context );
+        this.NotifyCollectionChanged();
       }
 
       return cell;
@@ -448,22 +424,25 @@ namespace Xceed.Wpf.DataGrid
     private void PrepareCell( Cell cell, ColumnBase column, DataGridContext context )
     {
       //context can be null when the DataGridCollectionView directly has a list of Xceed.Wpf.DataGrid.DataRow
-      //Certain non recycling cells like StatCell must not be (re)intialized at this point if their binding is not set, for performance reasons.
-      if( ( cell == null ) || ( context == null ) || ( !cell.HasAliveContentBinding ) )
+      if( ( cell == null ) || ( context == null ) )
         return;
 
       // Initialize the cell in case it hasn't been initialized or in case of a column change.
       cell.Initialize( context, m_parentRow, column );
 
-      // Make sure the cell is prepared before leaving this method.
-      cell.PrepareContainer( context, m_parentRow.DataContext );
+      // Certain non recycling cells like StatCell must not be (re)prepared if their binding is not set, for performance reasons.
+      if( cell.HasAliveContentBinding )
+      {
+        // Make sure the cell is prepared before leaving this method.
+        cell.PrepareContainer( context, m_parentRow.DataContext );
+      }
     }
 
     private bool TryGetRecycledCell( ColumnBase column, out Cell cell )
     {
       cell = null;
 
-      if( column == null )
+      if( ( column == null ) || ( m_recyclingBins == null ) )
         return false;
 
       object recyclingGroup = this.GetRecyclingGroup( column );
@@ -473,7 +452,7 @@ namespace Xceed.Wpf.DataGrid
       {
         // Try to recycle a cell that has already the appropriate column in order to minimize the cell's initialization time.
         LinkedListNode<Cell> targetNode = null;
-        for( LinkedListNode<Cell> node = recycleBin.Last; node != null; node = node.Previous )
+        for( var node = recycleBin.Last; node != null; node = node.Previous )
         {
           targetNode = node;
 
@@ -508,7 +487,7 @@ namespace Xceed.Wpf.DataGrid
 
     private void MergeFreeCells()
     {
-      if( m_freeCells.Count == 0 )
+      if( m_freeCells == null )
         return;
 
       foreach( Cell cell in m_freeCells )
@@ -516,8 +495,7 @@ namespace Xceed.Wpf.DataGrid
         this.MergeFreeCell( cell );
       }
 
-      m_freeCells.Clear();
-      m_freeCells.TrimExcess();
+      m_freeCells = null;
     }
 
     private ColumnBase GetColumn( Cell cell )
@@ -536,28 +514,26 @@ namespace Xceed.Wpf.DataGrid
 
     private ColumnBase GetColumn( string fieldName )
     {
-      return this.GetColumn( this.DataGridContext, fieldName );
-    }
-
-    private ColumnBase GetColumn( DataGridContext context, string fieldName )
-    {
-      if( ( context == null ) || ( string.IsNullOrEmpty( fieldName ) ) )
+      if( ( this.Columns == null ) || ( string.IsNullOrEmpty( fieldName ) ) )
         return null;
 
-      return context.Columns[ fieldName ];
+      return this.Columns[ fieldName ];
     }
 
     private object GetRecyclingGroup( ColumnBase column )
     {
-      if( column == null )
-        throw new ArgumentNullException( "column" );
-
       return column.GetCellRecyclingGroupOrDefault();
     }
 
     private ICollection<Cell> GetRecycleBinOrNew( object recyclingGroup )
     {
+      if( m_recyclingBins == null )
+      {
+        m_recyclingBins = new Dictionary<object, LinkedList<Cell>>();
+      }
+
       LinkedList<Cell> recycleBin;
+
       if( !m_recyclingBins.TryGetValue( recyclingGroup, out recycleBin ) )
       {
         recycleBin = new LinkedList<Cell>();
@@ -567,37 +543,16 @@ namespace Xceed.Wpf.DataGrid
       return recycleBin;
     }
 
-    private bool IsRecyclableCell( Cell cell )
-    {
-      return ( cell != null ) && ( !this.IsTemplatedCell( cell ) );
-    }
-
-    private bool IsTemplatedCell( Cell cell )
-    {
-      if( cell == null )
-        return false;
-
-      return Row.GetIsTemplateCell( cell );
-    }
-
-    private bool IsFreeCell( Cell cell )
-    {
-      if( cell == null )
-        throw new ArgumentNullException( "cell" );
-
-      return string.IsNullOrEmpty( cell.FieldName );
-    }
-
     private void CheckFieldName( string fieldName )
     {
       if( string.IsNullOrEmpty( fieldName ) )
-        throw new DataGridInternalException( "A field name is required." );
+        throw new DataGridInternalException( "A field name is required.", this.DataGridContext.DataGridControl );
     }
 
     private void CheckCellFieldName( string fieldName )
     {
       if( string.IsNullOrEmpty( fieldName ) )
-        throw new DataGridInternalException( "A Cell should always have a FieldName." );
+        throw new DataGridInternalException( "A Cell should always have a FieldName.", this.DataGridContext.DataGridControl );
     }
 
     private void CheckCellBinded( string fieldName )
@@ -610,9 +565,50 @@ namespace Xceed.Wpf.DataGrid
 
     private void ThrowCellBinded( string fieldName )
     {
-      throw new DataGridInternalException( string.Format( "A cell with FieldName {0} already exists.", fieldName ) );
+      throw new DataGridInternalException( string.Format( "A cell with FieldName {0} already exists.", fieldName ), this.DataGridContext.DataGridControl );
+    }
+
+    private static bool IsRecyclableCell( Cell cell )
+    {
+      return ( cell != null )
+          && !VirtualizingCellCollection.IsTemplatedCell( cell );
     }
 
+    private static bool IsTemplatedCell( Cell cell )
+    {
+      return ( cell != null )
+          && Row.GetIsTemplateCell( cell );
+    }
+
+    private static bool IsFreeCell( Cell cell )
+    {
+      if( cell == null )
+        throw new ArgumentNullException( "cell" );
+
+      return string.IsNullOrEmpty( cell.FieldName );
+    }
+
+    #region Private Fields
+
+    private readonly Row m_parentRow;
+    private readonly ICollection<Cell> m_cells;
+
+    // This Dictionary is used as a caching system to optimize lookup when virtualizing instead of
+    // parsing every columns looking for the fieldname. e.g.: looking for the last one when 1000
+    // Cells in the parent row. When virtualizing, only the cell visible in the viewport will be contained
+    // within this collection speeding the lookup.
+    private readonly Dictionary<string, Cell> m_bindedCells = new Dictionary<string, Cell>();
+
+    // This Dictionary contains the recycling queues for the cells ready to be recycled.
+    private Dictionary<object, LinkedList<Cell>> m_recyclingBins; //null
+
+    // This collection is used to store cells that are added to the Collection
+    // before the FieldName and/or ParentColumn being set. This occurs when
+    // defining a Row with Cell in XAML during a BeginInit / EndInit.
+    private List<Cell> m_freeCells; //null
+
+    #endregion
+
     #region VirtualizingCellCollectionEnumerator Nested Type
 
     private class VirtualizingCellCollectionEnumerator : IEnumerator<Cell>, IEnumerator
@@ -680,7 +676,7 @@ namespace Xceed.Wpf.DataGrid
       private Cell m_current; // = null;
     }
 
-    #endregion VirtualizingCellCollectionEnumerator Nested Type
+    #endregion
 
     #region VirtualizingItemsList Nested Type
 
@@ -708,9 +704,9 @@ namespace Xceed.Wpf.DataGrid
       {
         get
         {
-          DataGridContext dataGridContext = this.DataGridContext;
-          if( dataGridContext != null )
-            return dataGridContext.Columns.Count;
+          ColumnCollection columns = this.Columns;
+          if( columns != null )
+            return columns.Count;
 
           return 0;
         }
@@ -729,11 +725,11 @@ namespace Xceed.Wpf.DataGrid
         get
         {
           Cell cell = null;
-          DataGridContext dataGridContext = this.DataGridContext;
+          ColumnCollection columns = this.Columns;
 
-          if( dataGridContext != null )
+          if( columns != null )
           {
-            ColumnBase column = dataGridContext.Columns[ index ];
+            ColumnBase column = columns[ index ];
 
             if( column != null )
             {
@@ -753,14 +749,14 @@ namespace Xceed.Wpf.DataGrid
         }
       }
 
-      private DataGridContext DataGridContext
+      private ColumnCollection Columns
       {
         get
         {
           if( m_collection == null )
             return null;
 
-          return m_collection.DataGridContext;
+          return m_collection.Columns;
         }
       }
 
@@ -795,10 +791,10 @@ namespace Xceed.Wpf.DataGrid
           return false;
 
         string fieldName = item.FieldName;
-        DataGridContext dataGridContext = this.DataGridContext;
+        ColumnCollection columns = this.Columns;
 
-        if( dataGridContext != null )
-          return ( dataGridContext.Columns[ fieldName ] != null );
+        if( columns != null )
+          return ( columns[ fieldName ] != null );
 
         Debug.Fail( "An unprepared Row was asked for Cell" );
 
@@ -828,7 +824,7 @@ namespace Xceed.Wpf.DataGrid
       private VirtualizingCellCollection m_collection;
     }
 
-    #endregion VirtualizingItemsList Nested Type
+    #endregion
 
     #region ReadOnlyCollection Nested Type
 
@@ -896,23 +892,137 @@ namespace Xceed.Wpf.DataGrid
       private readonly ICollection<T> m_collection;
     }
 
-    #endregion ReadOnlyCollection Nested Type
+    #endregion
 
-    private readonly Row m_parentRow;
-    private readonly HashSet<Cell> m_cells = new HashSet<Cell>();
+    #region CellSet Nested Type
 
-    // This Dictionary is used as a caching system to optimize research when virtualizing instead of
-    // parsing every columns looking for the fieldname. e.g.: looking for the last one when 1000
-    // Cells in the parent row. When virtualizing, only the cell visible in the viewport will be contained
-    // within this collection speeding the research.
-    private readonly Dictionary<string, Cell> m_bindedCells = new Dictionary<string, Cell>();
+    private sealed class CellSet : ICollection<Cell>, IWeakEventListener
+    {
+      internal CellSet( Row parentRow )
+      {
+        Debug.Assert( parentRow != null );
 
-    // This Dictionary contains the recycling queues for the cells ready to be recycled.
-    private readonly Dictionary<object, LinkedList<Cell>> m_recyclingBins = new Dictionary<object, LinkedList<Cell>>();
+        m_parentRow = parentRow;
+      }
 
-    // This collection is used to store cells that are added to the Collection
-    // before the FieldName and/or ParentColumn being set. This occurs when
-    // defining a Row with Cell in XAML during a BeginInit / EndInit.
-    private readonly List<Cell> m_freeCells = new List<Cell>( 0 );
+      public int Count
+      {
+        get
+        {
+          return m_collection.Count;
+        }
+      }
+
+      bool ICollection<Cell>.IsReadOnly
+      {
+        get
+        {
+          return false;
+        }
+      }
+
+      public bool Contains( Cell item )
+      {
+        return m_collection.Contains( item );
+      }
+
+      public void Add( Cell item )
+      {
+        Debug.Assert( item != null );
+
+        m_collection.Add( item );
+
+        this.RegisterBringIntoView( item );
+      }
+
+      public bool Remove( Cell item )
+      {
+        Debug.Assert( item != null );
+
+        if( !m_collection.Remove( item ) )
+          return false;
+
+        this.UnregisterBringIntoView( item );
+
+        return true;
+      }
+
+      public void Clear()
+      {
+        foreach( var item in m_collection )
+        {
+          this.UnregisterBringIntoView( item );
+        }
+
+        m_collection.Clear();
+        m_collection.TrimExcess();
+      }
+
+      private void RegisterBringIntoView( Cell item )
+      {
+        RequestBringIntoViewWeakEventManager.AddListener( item, this );
+      }
+
+      private void UnregisterBringIntoView( Cell item )
+      {
+        RequestBringIntoViewWeakEventManager.RemoveListener( item, this );
+      }
+
+      private void OnRequestBringIntoView( object sender, RequestBringIntoViewEventArgs e )
+      {
+        if( e.Handled )
+          return;
+
+        var targetCell = ( Cell )sender;
+        Debug.Assert( targetCell != null );
+        Debug.Assert( m_collection.Contains( targetCell ) );
+
+        if( ( targetCell != e.TargetObject ) && !targetCell.IsAncestorOf( e.TargetObject ) )
+          return;
+
+        // Do not process the bring into view for a templated cell.
+        if( VirtualizingCellCollection.IsTemplatedCell( targetCell ) )
+          return;
+
+        var targetRow = targetCell.ParentRow;
+        Debug.Assert( ( targetRow == null ) || ( targetRow == m_parentRow ) );
+
+        var targetHost = ( targetRow != null ) ? targetRow.CellsHostPanel as IVirtualizingCellsHost : null;
+
+        e.Handled = ( targetHost != null )
+                 && ( targetHost.BringIntoView( targetCell, e ) );
+      }
+
+      void ICollection<Cell>.CopyTo( Cell[] array, int arrayIndex )
+      {
+        m_collection.CopyTo( array, arrayIndex );
+      }
+
+      IEnumerator<Cell> IEnumerable<Cell>.GetEnumerator()
+      {
+        return m_collection.GetEnumerator();
+      }
+
+      IEnumerator IEnumerable.GetEnumerator()
+      {
+        return m_collection.GetEnumerator();
+      }
+
+      bool IWeakEventListener.ReceiveWeakEvent( Type managerType, object sender, EventArgs e )
+      {
+        if( managerType == typeof( RequestBringIntoViewWeakEventManager ) )
+        {
+          this.OnRequestBringIntoView( sender, ( RequestBringIntoViewEventArgs )e );
+          return true;
+        }
+
+        return false;
+      }
+
+      private readonly HashSet<Cell> m_collection = new HashSet<Cell>();
+      private readonly Row m_parentRow;
+    }
+
+    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VisibleColumnsUpdatedEventArgs.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VisibleColumnsUpdatedEventArgs.cs
new file mode 100644
index 00000000..2878b5bb
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/VisibleColumnsUpdatedEventArgs.cs
@@ -0,0 +1,42 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+
+namespace Xceed.Wpf.DataGrid
+{
+  internal class VisibleColumnsUpdatedEventArgs : EventArgs
+  {
+    internal VisibleColumnsUpdatedEventArgs( bool onlyIncrementFlag )
+    {
+      m_onlyIncrementFlag = onlyIncrementFlag;
+    }
+
+    #region OnlyIncrementFlag Property
+
+    internal bool OnlyIncrementFlag
+    {
+      get
+      {
+        return m_onlyIncrementFlag;
+      }
+    }
+
+    private bool m_onlyIncrementFlag;
+
+    #endregion
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Xceed.Wpf.DataGrid.csproj b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Xceed.Wpf.DataGrid.csproj
index eb9f7bd6..31f5d996 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Xceed.Wpf.DataGrid.csproj
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Xceed.Wpf.DataGrid.csproj
@@ -47,10 +47,10 @@
     <NoWarn>1699</NoWarn>
     <BaseAddress>125829120</BaseAddress>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-    <RunCodeAnalysis>false</RunCodeAnalysis>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugSymbols>false</DebugSymbols>
+    <DebugSymbols>true</DebugSymbols>
     <Optimize>true</Optimize>
     <OutputPath>.\bin\Release\</OutputPath>
     <DefineConstants>TRACE;CODE_ANALYSIS;XBAP_FRIENDLY</DefineConstants>
@@ -62,11 +62,47 @@
     </CodeAnalysisRules>
     <BaseAddress>125829120</BaseAddress>
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <ErrorReport>prompt</ErrorReport>
+    <DebugType>pdbonly</DebugType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release+Log|AnyCPU'">
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE;CODE_ANALYSIS;XBAP_FRIENDLY;LOG</DefineConstants>
+    <BaseAddress>125829120</BaseAddress>
+    <Optimize>true</Optimize>
+    <NoWarn>1699</NoWarn>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+    <CodeAnalysisLogFile>bin\Release\Xceed.Wpf.DataGrid.v4.2.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <DebugType>pdbonly</DebugType>
+    <DebugSymbols>true</DebugSymbols>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug+Log|AnyCPU'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>TRACE;DEBUG;XBAP_FRIENDLY;LOG</DefineConstants>
+    <BaseAddress>125829120</BaseAddress>
+    <NoWarn>1699</NoWarn>
+    <DebugType>full</DebugType>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <CodeAnalysisLogFile>bin\Debug\Xceed.Wpf.DataGrid.v4.2.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="PresentationFramework.Aero">
-      <Private>True</Private>
-    </Reference>
+    <Reference Include="PresentationFramework.Aero" />
     <Reference Include="PresentationFramework.Classic" />
     <Reference Include="PresentationFramework.Luna" />
     <Reference Include="PresentationFramework.Royale" />
@@ -113,6 +149,8 @@
     <Compile Include="%28CollectionView%29\BindingPathValueExtractor.cs" />
     <Compile Include="%28CollectionView%29\CollectionViewGroupExtensions.cs" />
     <Compile Include="%28CollectionView%29\CommitItemsEvent.cs" />
+    <Compile Include="%28CollectionView%29\ConnectionErrorChangedEventManager.cs" />
+    <Compile Include="%28CollectionView%29\ConnectionStateChangedEventManager.cs" />
     <Compile Include="%28CollectionView%29\CustomDistinctValueItemConfiguration.cs" />
     <Compile Include="%28CollectionView%29\CustomDistinctValueItemConfigurationCollection.cs" />
     <Compile Include="%28CollectionView%29\CustomDistinctValueItemFilterEventArgs.cs" />
@@ -162,9 +200,17 @@
     <Compile Include="%28CollectionView%29\DataGridItemEvent.cs" />
     <Compile Include="%28CollectionView%29\DataGridItemHandledEvent.cs" />
     <Compile Include="%28CollectionView%29\DataGridItemRemovedEvent.cs" />
+    <Compile Include="%28CollectionView%29\DistinctValuesRefreshNeededEventManager.cs" />
     <Compile Include="%28CollectionView%29\EmptyDataItemSafePropertyDescriptor.cs" />
     <Compile Include="%28CollectionView%29\EntityDetailDescription.cs" />
-    <Compile Include="%28CollectionView%29\OptimizedReadOnlyObservableCollection.cs" />
+    <Compile Include="%28CollectionView%29\ItemPropertyGroupSortStatNameChangedEventManager.cs" />
+    <Compile Include="%28CollectionView%29\PostBatchCollectionChangedEventManager.cs" />
+    <Compile Include="%28CollectionView%29\PreBatchCollectionChangedEventManager.cs" />
+    <Compile Include="%28CollectionView%29\ProxyApplyingFilterCriteriasEventManager.cs" />
+    <Compile Include="%28CollectionView%29\ProxyAutoFilterValuesChangedEventManager.cs" />
+    <Compile Include="%28CollectionView%29\ProxyCollectionRefreshEventManager.cs" />
+    <Compile Include="%28CollectionView%29\ProxyGroupDescriptionsChangedEventManager.cs" />
+    <Compile Include="%28CollectionView%29\ProxySortDescriptionsChangedEventManager.cs" />
     <Compile Include="%28CollectionView%29\QueryEntityDetailsEventArgs.cs" />
     <Compile Include="%28CollectionView%29\QueryDistinctValueEventArgs.cs" />
     <Compile Include="%28CollectionView%29\%28DataVirtualization%29\EmptyDataItem.cs" />
@@ -186,11 +232,15 @@
     <Compile Include="%28CollectionView%29\QueryGroupsEventArgs.cs" />
     <Compile Include="%28CollectionView%29\QueryItemCountEvent.cs" />
     <Compile Include="%28CollectionView%29\QueryItemsEvent.cs" />
+    <Compile Include="%28CollectionView%29\RawItemMap.cs" />
+    <Compile Include="%28CollectionView%29\RootGroupChangedEventManager.cs" />
     <Compile Include="%28CollectionView%29\SortDescriptionsSyncContext.cs" />
     <Compile Include="%28CollectionView%29\%28DataVirtualization%29\VirtualizedItemInfo.cs" />
     <Compile Include="%28CollectionView%29\%28DataVirtualization%29\VirtualizedItemValueCollection.cs" />
     <Compile Include="%28CollectionView%29\StatResultComparer.cs" />
     <Compile Include="%28CollectionView%29\UnboundDataItem.cs" />
+    <Compile Include="%28enums%29\AutoScrollCurrentItemTriggersEnum.cs" />
+    <Compile Include="%28enums%29\AutoScrollCurrentItemSourceTriggersEnum.cs" />
     <Compile Include="%28enums%29\CommitModeEnum.cs" />
     <Compile Include="%28enums%29\DataGridConnectionStateEnum.cs" />
     <Compile Include="%28enums%29\DataGridUpdateSourceTriggerEnum.cs" />
@@ -205,29 +255,55 @@
     <Compile Include="%28ForeignKeys%29\DataTableForeignKeyConverter.cs" />
     <Compile Include="%28ForeignKeys%29\ForeignKeyConverter.cs" />
     <Compile Include="%28ForeignKeys%29\ForeignKeyScrollTipContentControl.cs" />
+    <Compile Include="%28Generator%29\DataItemDataProvider.cs" />
+    <Compile Include="%28Generator%29\DataItemDataProviderBase.cs" />
+    <Compile Include="%28Generator%29\EmptyDataItemDataProvider.cs" />
     <Compile Include="%28Generator%29\IInhibitGenPosToIndexUpdating.cs" />
     <Compile Include="%28Generator%29\StickyContainerGeneratedComparer.cs" />
     <Compile Include="%28Generator%29\StickyContainerGeneratedReverseComparer.cs" />
     <Compile Include="%28Generator%29\StickyContainerGeneratedStruct.cs" />
+    <Compile Include="%28Generator%29\VisibilityChangingEventManager.cs" />
     <Compile Include="Automation\AutomationPeerExtensions.cs" />
+    <Compile Include="AutoResetFlag.cs" />
+    <Compile Include="AutoResetFlagFactory.cs" />
+    <Compile Include="AutoScrollCurrentItemSourceTriggersRestrictions.cs" />
     <Compile Include="CanBeCurrentWhenReadOnlyChangedEventManager.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="CellContentStringFormatChangedEventManager.cs" />
     <Compile Include="CellContentTemplateChangedEventManager.cs" />
-    <Compile Include="ValidateInputWrapper.cs" />
     <Compile Include="CellEditorDisplayConditionsChangedEventManager.cs" />
-    <Compile Include="DataGridCheckBox.cs" />
+    <Compile Include="ValidateInputWrapper.cs" />
+    <Compile Include="CheckBox.cs" />
+    <Compile Include="ChildColumnVisibilityChangedEventManager.cs" />
+    <Compile Include="ColumnAddGroupCommand.cs" />
+    <Compile Include="ColumnCommand.cs" />
+    <Compile Include="ColumnGroupCommand.cs" />
+    <Compile Include="ColumnSortCommand.cs" />
     <Compile Include="Converters\SortingDirectionToBooleanConverter.cs" />
+    <Compile Include="Converters\StringFormatMultiConverter.cs" />
+    <Compile Include="DataItemEventDescriptor.cs" />
+    <Compile Include="DataItemEventDescriptorBase.cs" />
+    <Compile Include="DataItemEventDescriptorFactory.cs" />
+    <Compile Include="DataItemPropertyDescriptor.cs" />
+    <Compile Include="DataItemPropertyDescriptorBase.cs" />
+    <Compile Include="DataItemPropertyDescriptorFactory.cs" />
+    <Compile Include="DataItemTypeDescriptionProvider.cs" />
+    <Compile Include="DataItemTypeDescriptor.cs" />
+    <Compile Include="FilterCriteria\FilterExpressionHelper.cs" />
+    <Compile Include="ForeignKeyConfigNotifyCollectionChangedEventManager.cs" />
     <Compile Include="DataGridControlSelectionChangedWeakEventManager.cs" />
     <Compile Include="DataGridCurrentChangedEvent.cs" />
     <Compile Include="DataGridCurrentChangingEvent.cs" />
     <Compile Include="DataGridDatePicker.cs" />
     <Compile Include="DataGridFocusException.cs" />
+    <Compile Include="DataGridItemContainerManager.cs" />
     <Compile Include="DataGridSelectionChangingEvent.cs" />
+    <Compile Include="FittedWidthRequestedEventArgs.cs" />
     <Compile Include="ForeignKeyConfigurationChangedEventManager.cs" />
+    <Compile Include="GenericContentTemplateSelector.cs" />
     <Compile Include="GroupNavigationButton.cs" />
     <Compile Include="CellEditorContext.cs" />
-    <Compile Include="Converters\FilterCriterionToForeignKeyConverter.cs" />
     <Compile Include="Converters\EmptyStringToBooleanConverter.cs" />
     <Compile Include="ColumnBase.cs" />
     <Compile Include="FilterCriteria\EndsWithFilterCriterion.cs">
@@ -239,12 +315,34 @@
     <Compile Include="GroupNavigationControl.cs" />
     <Compile Include="GroupNavigationControlItem.cs" />
     <Compile Include="HashedLinkedList.cs" />
+    <Compile Include="IDataGridItemContainerExtensions.cs" />
+    <Compile Include="IGroupLevelDescription.cs" />
     <Compile Include="InnerCellContentPresenter.cs" />
     <Compile Include="ItemPropertiesChangedEventManager.cs" />
+    <Compile Include="ItemPropertyNameMap.cs" />
+    <Compile Include="LateGroupLevelDescription.cs" />
     <Compile Include="Log.cs" />
+    <Compile Include="Markup\DataGridThemeResourceDictionary.cs" />
+    <Compile Include="Markup\FrameworkThemeResourceDictionary.cs" />
+    <Compile Include="Markup\SharedResourceDictionary.cs" />
+    <Compile Include="Markup\SharedThemeResourceDictionary.cs" />
+    <Compile Include="FieldNameMap.cs" />
+    <Compile Include="NotifyCollectionChangedEventArgsExtensions.cs" />
+    <Compile Include="SelectionChangedInternalEventArgs.cs" />
+    <Compile Include="SelectionRangePoint.cs" />
+    <Compile Include="StringFormatDataTemplate.cs" />
+    <Compile Include="Utils\Collections\DoubleFenwickTree.cs" />
+    <Compile Include="Utils\Collections\FenwickTree.Generic.cs" />
+    <Compile Include="Utils\Collections\LongestIncreasingSubsequence.cs" />
+    <Compile Include="Utils\PropertyHelper.cs" />
+    <Compile Include="Utils\Wpf\DragDrop\AutoScrollManager.cs" />
+    <Compile Include="ValueChangeDataItemPropertyDescriptor.cs" />
+    <Compile Include="NotifyRangeCollectionChangedEventArgs.cs" />
     <Compile Include="ObjectComparer.cs" />
+    <Compile Include="ObservableColumnCollection.cs" />
     <Compile Include="FrameworkElementUnloadedEventManager.cs" />
-    <Compile Include="Print\IPrintInfo.cs" />
+    <Compile Include="RequestBringIntoViewWeakEventManager.cs" />
+    <Compile Include="RequestingDelayBringIntoViewAndFocusCurrentEventArgs.cs" />
     <Compile Include="ScrollChangedWeakEventManager.cs" />
     <Compile Include="SelectedCellsStorage.cs" />
     <Compile Include="SelectionCellRange.cs" />
@@ -254,6 +352,8 @@
     <Compile Include="SelectionRange.cs" />
     <Compile Include="SelectionItemRangeCollection.cs" />
     <Compile Include="SelectionRangeWithItems.cs" />
+    <Compile Include="ColumnSynchronizationManager.cs" />
+    <Compile Include="ToggleColumnSortCommand.cs" />
     <Compile Include="UnboundColumn.cs" />
     <Compile Include="SelectionInfo.cs" />
     <Compile Include="DataGridSelectionChangedEvent.cs" />
@@ -266,7 +366,6 @@
     <Compile Include="FilterCriteria\EqualToFilterCriterion.cs" />
     <Compile Include="FilterCriteria\FilterCriterion.cs" />
     <Compile Include="%28enums%29\FilterOperatorPrecedenceEnum.cs" />
-    <Compile Include="Converters\FilterCriterionToNullableBoolConverter.cs" />
     <Compile Include="FilterParser.cs" />
     <Compile Include="FilterParserTestWindow.cs" />
     <Compile Include="FilterParser_UnitTests.cs" />
@@ -278,9 +377,15 @@
     <Compile Include="FilterCriteria\OrFilterCriterion.cs" />
     <Compile Include="MaxGroupLevelsChangedEventManager.cs" />
     <Compile Include="MaxSortLevelsChangedEventManager.cs" />
+    <Compile Include="UpdateColumnSortCommand.cs" />
     <Compile Include="Utils\WeakEventHandler.cs" />
+    <Compile Include="Utils\Wpf\BreadthFirstSearchTreeTraversal.cs" />
+    <Compile Include="Utils\Wpf\BreadthFirstSearchTreeTraversalStrategy.cs" />
+    <Compile Include="Utils\Wpf\DepthFirstSearchTreeTraversal.cs" />
+    <Compile Include="Utils\Wpf\DepthFirstSearchTreeTraversalStrategy.cs" />
     <Compile Include="Utils\Wpf\DragDrop\DragDropHelper.cs" />
-    <Compile Include="ValidationRules\FilterExpressionValidationRule.cs" />
+    <Compile Include="Utils\Wpf\ITreeTraversal.cs" />
+    <Compile Include="Utils\Wpf\ITreeTraversalStrategy.cs" />
     <Compile Include="Automation\ColumnManagerCellAutomationPeer.cs" />
     <Compile Include="Automation\ColumnManagerRowAutomationPeer.cs" />
     <Compile Include="Automation\DataGridItemCellAutomationPeer.cs" />
@@ -298,6 +403,14 @@
     <Compile Include="Export\FormatSettingsBase.cs" />
     <Compile Include="%28ForeignKeys%29\ForeignKeyConfiguration.cs" />
     <Compile Include="GroupExtensions.cs" />
+    <Compile Include="SharedListStruct.cs" />
+    <Compile Include="Views\%28ColumnVirtualization%29\FixedColumnCountChangedEventArgs.cs" />
+    <Compile Include="Views\%28ColumnVirtualization%29\FixedColumnCountEventManager.cs" />
+    <Compile Include="Views\%28ColumnVirtualization%29\IColumnInfoCollection.Generic.cs" />
+    <Compile Include="Views\%28ColumnVirtualization%29\IColumnNameCollection.cs" />
+    <Compile Include="Views\%28ColumnVirtualization%29\TableViewColumnVirtualizationManagerBase.cs" />
+    <Compile Include="Views\%28Enums%29\FlattenDetailBindingModeEnum.cs" />
+    <Compile Include="Views\%28Enums%29\MasterDetailLayoutModeEnum.cs" />
     <Compile Include="Views\%28TableflowView%29\AnimatedDraggedElementAdorner.cs" />
     <Compile Include="Views\%28TableflowView%29\PointAnimation.cs" />
     <Compile Include="Views\%28TableflowView%29\TableflowView.cs" />
@@ -333,8 +446,6 @@
     <Compile Include="SelectedItemsStorage.cs" />
     <Compile Include="SelectionChanger.cs" />
     <Compile Include="SelectionManager.cs" />
-    <Compile Include="Settings\UserSettingsEnum.cs" />
-    <Compile Include="Settings\XmlColumnWidthStruct.cs" />
     <Compile Include="Automation\CellAutomationPeer.cs" />
     <Compile Include="Automation\DataGridContextAutomationPeer.cs" />
     <Compile Include="Automation\DataGridControlAutomationPeer.cs" />
@@ -347,6 +458,7 @@
     <Compile Include="ValidationRules\CellEditorValidationRule.cs" />
     <Compile Include="ValidationRules\CellEditorErrorValidationRule.cs" />
     <Compile Include="Views\DictionaryTheme.cs" />
+    <Compile Include="Views\MasterDetailLayoutAttribute.cs" />
     <Compile Include="Views\FixedCellPanel.cs" />
     <Compile Include="Views\%28ColumnVirtualization%29\UpdateMeasureRequiredEventArgs.cs" />
     <Compile Include="Views\%28ColumnVirtualization%29\UpdateMeasureRequiredEventManager.cs" />
@@ -354,6 +466,8 @@
     <Compile Include="Views\DataGridControlBackgroundBrushesResources.xaml.cs">
       <DependentUpon>DataGridControlBackgroundBrushesResources.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Views\NavigationHelper.cs" />
+    <Compile Include="Views\ScrollViewerTemplateHelper.cs" />
     <Compile Include="Views\ColumnStretchingManager.cs" />
     <Compile Include="Views\%28Enums%29\ColumnStretchModeEnum.cs" />
     <Compile Include="%28enums%29\ColumnWidthUnitTypeEnum.cs" />
@@ -384,6 +498,8 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="ThemeChangedEventManager.cs" />
+    <Compile Include="Views\TableViewEndPageInfo.cs" />
+    <Compile Include="Views\TableViewFullPageInfo.cs" />
     <Compile Include="Views\TableViewHeaderFooterPanel.cs" />
     <Compile Include="Views\%28Enums%29\ViewPropertyModeEnum.cs" />
     <Compile Include="%28Generator%29\WeakDataGridContextKey.cs" />
@@ -443,9 +559,6 @@
     <Compile Include="LevelGroupConfigurationSelector.cs" />
     <Compile Include="HierarchicalGroupLevelIndicatorPane.cs" />
     <Compile Include="Markup\ClearGroupLevelConfigurations.cs" />
-    <Compile Include="SortingHelper.cs">
-      <SubType>Code</SubType>
-    </Compile>
     <Compile Include="Utils\Collections\ReadOnlyObservableHashList.cs" />
     <Compile Include="Views\%28Enums%29\PassiveLayoutAxisEnum.cs" />
     <Compile Include="%28enums%29\DistinctValuesConstraintEnum.cs" />
@@ -475,7 +588,6 @@
     <Compile Include="Converters\DefaultDataConverter.cs" />
     <Compile Include="Converters\MultimodalResultConverter.cs" />
     <Compile Include="Converters\SourceDataConverter.cs" />
-    <Compile Include="Converters\StatResultConverter.cs" />
     <Compile Include="Converters\StringFormatConverter.cs" />
     <Compile Include="%28CollectionView%29\DataGridDetailDescription.cs" />
     <Compile Include="%28CollectionView%29\DataGridDetailDescriptionCollection.cs" />
@@ -493,8 +605,6 @@
     <Compile Include="%28Generator%29\GeneratorNodeFactory.cs" />
     <Compile Include="%28Generator%29\GeneratorNodeHelper.cs" />
     <Compile Include="ValidationRules\SourceDataConverterValidationRule.cs" />
-    <Compile Include="Stats\InvalidSourcePropertyNameException.cs" />
-    <Compile Include="Stats\InvalidValueException.cs" />
     <Compile Include="Stats\StatFunctionCollection.cs" />
     <Compile Include="Stats\StatFunctionComparer.cs" />
     <Compile Include="Stats\StatResult.cs" />
@@ -518,8 +628,7 @@
     <Compile Include="IDeferableScrollInfoRefresh.cs" />
     <Compile Include="Views\PassiveLayoutDecorator.cs" />
     <Compile Include="Views\ScrollingCellsDecorator.cs" />
-    <Compile Include="Views\FixedCellSubPanel.cs">
-    </Compile>
+    <Compile Include="Views\FixedCellSubPanel.cs" />
     <Compile Include="Views\FixedColumnSplitter.cs" />
     <Compile Include="Views\%28Enums%29\SynchronizedScrollViewerPositionEnum.cs" />
     <Compile Include="%28enums%29\ValidationModeEnum.cs" />
@@ -583,7 +692,11 @@
     <Compile Include="StaircasePanel.cs" />
     <Compile Include="Views\SynchronizedScrollViewer.cs" />
     <Compile Include="Views\TableView.cs" />
+    <Compile Include="Views\TableViewPage.cs" />
+    <Compile Include="Views\TableViewPageInfo.cs" />
+    <Compile Include="Views\TableViewPartialPageInfo.cs" />
     <Compile Include="Views\TableViewScrollViewer.cs" />
+    <Compile Include="Views\TableViewStartPageInfo.cs" />
     <Compile Include="Views\TargetViewAttribute.cs" />
     <Compile Include="TextInputActivationGesture.cs" />
     <Compile Include="Views\Theme.cs" />
@@ -601,6 +714,7 @@
     <Compile Include="VirtualizingCellCollection.cs" />
     <Compile Include="VirtualizingCellCollectionChangedEventManager.cs" />
     <Compile Include="VirtualizingStackPanel.cs" />
+    <Compile Include="VisibleColumnsUpdatedEventArgs.cs" />
     <Compile Include="VisibleColumnsUpdatingEventManager.cs" />
     <Compile Include="WatermarkAdorner.cs" />
     <AppDesigner Include="Properties\" />
@@ -775,16 +889,24 @@
       <SubType>Designer</SubType>
     </Page>
     <Page Include="themes\Aero2\Resources\TableView.Aero2.normalcolor.Graphics.xaml">
+      <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
+    </Page>
+    <Page Include="themes\Aero2\Resources\Aero2.normalcolor.Controls.xaml">
       <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
     </Page>
     <Page Include="themes\Aero2\Resources\Aero2.normalcolor.Resources.xaml">
-      <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
     </Page>
     <Page Include="themes\Aero2\TableflowView.Aero2.normalcolor.xaml">
+      <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
+    </Page>
+    <Page Include="themes\Aero2\TableView.Aero2.normalcolor.xaml">
       <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
     </Page>
     <Page Include="themes\zune.normalcolor.xaml">
       <Generator>MSBuild:Compile</Generator>
@@ -969,10 +1091,11 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Xceed.Wpf.Toolkit\Xceed.Wpf.Toolkit.csproj">
-      <Project>{72E591D6-8F83-4D8C-8F67-9C325E623234}</Project>
+      <Project>{72e591d6-8f83-4d8c-8f67-9c325e623234}</Project>
       <Name>Xceed.Wpf.Toolkit</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Target Name="GenSerializationAssembly" DependsOnTargets="AssignTargetPaths;Compile;ResolveKeySource" Inputs="$(MSBuildAllProjects);@(IntermediateAssembly)" Outputs="$(OutputPath)$(_SGenDllName)">
     <SGen BuildAssemblyName="$(TargetFileName)" BuildAssemblyPath="$(OutputPath)" References="@(ReferencePath)" ShouldGenerateSerializer="true" UseProxyTypes="false" KeyContainer="$(KeyContainerName)" KeyFile="..\..\SolutionItems\Xceed.snk" DelaySign="$(DelaySign)" ToolPath="$(SGenToolPath)">
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/Resources/TableView.Aero.Graphics.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/Resources/TableView.Aero.Graphics.xaml
index 164210be..ca80e719 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/Resources/TableView.Aero.Graphics.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/Resources/TableView.Aero.Graphics.xaml
@@ -16,12 +16,13 @@
 
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid">
+                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Aero uses the same graphics as Luna, so reuse the same ResourceDictionary. -->
-      <ResourceDictionary Source="../../Luna/Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../../Luna/Resources/TableView.Luna.Graphics.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableView.Aero.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableView.Aero.normalcolor.xaml
index 60e255ce..b511b329 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableView.Aero.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableView.Aero.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant and color-scheme independant theme resources -->
-      <ResourceDictionary Source="Resources/Aero.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Aero.Resources.xaml" />
 
       <!-- Include the view dependant and color-scheme independant theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Aero.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Aero.Graphics.xaml" />
 
       <!-- Include the view independant and color-scheme dependant theme resources -->
-      <ResourceDictionary Source="Resources/Aero.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Aero.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -485,7 +484,6 @@
                                ColumnStretchMode="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).ColumnStretchMode}"
                                FixedCellCount="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).FixedColumnCount, Mode=TwoWay}"
                                FixedColumnDropMarkPen="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).FixedColumnDropMarkPen}"
-                               TextElement.Foreground="{TemplateBinding Foreground}"
                                Margin="{TemplateBinding BorderThickness}" />
 
       </Grid>
@@ -516,6 +514,10 @@
                     Property="Background"
                     Value="{StaticResource selectionInnerRowBackgroundBrush}" />
 
+            <Setter TargetName="rootGrid"
+                    Property="TextElement.Foreground"
+                    Value="{Binding RelativeSource={RelativeSource TemplatedParent},Path=SelectionForeground}" />
+
          </MultiDataTrigger>
 
          <!-- This trigger is used to display the Inactive Selection look -->
@@ -545,6 +547,10 @@
                     Property="Background"
                     Value="{StaticResource inactiveSelectionInnerRowBackgroundBrush}" />
 
+            <Setter TargetName="rootGrid"
+                    Property="TextElement.Foreground"
+                    Value="{Binding RelativeSource={RelativeSource TemplatedParent},Path=InactiveSelectionForeground}" />
+
          </MultiDataTrigger>
 
          <!-- This trigger is used to display Mouse Over look -->
@@ -1016,6 +1022,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+    <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -1033,12 +1041,15 @@
 
                   <DockPanel Margin="{TemplateBinding Padding}">
 
-                     <ContentPresenter x:Name="sortGlyphPresenter"
-                                       DockPanel.Dock="Top"
-                                       Content="{x:Null}"
-                                       ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}"
-                                       Visibility="Hidden"
-                                       HorizontalAlignment="Center" />
+                     <StackPanel Orientation="Horizontal"
+                                 DockPanel.Dock="Top"
+                                 HorizontalAlignment="Center">
+                        <ContentPresenter x:Name="sortGlyphPresenter"
+                                          Content="{x:Null}"
+                                          ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}"
+                                          VerticalAlignment="Top"
+                                          Visibility="Hidden" />
+                     </StackPanel>
                      <Grid>
                         <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="*" />
@@ -1069,7 +1080,6 @@
                   <Border x:Name="delimiterBorder"
                           BorderThickness="1,0,1,0"
                           BorderBrush="{StaticResource rowSelectorDelimiterBorderBrush}" />
-
                </Grid>
 
             </DockPanel>
@@ -1988,7 +1998,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Aero;V4.0.0.0;31bf3856ad364e35;component\themes/aero.normalcolor.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Aero;V4.0.0.0;31bf3856ad364e35;component\themes/aero.normalcolor.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -2098,7 +2108,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -2106,6 +2116,9 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewRowTemplate}" />
 
@@ -2113,7 +2126,7 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -2212,18 +2225,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -2252,6 +2274,9 @@
       <Setter Property="BorderThickness"
               Value="1" />
 
+      <Setter Property="Background"
+              Value="Transparent" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
               Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
@@ -2259,6 +2284,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewColumnManagerCellTemplate}" />
 
@@ -2317,6 +2348,9 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="BorderThickness"
+              Value="1" />
+
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
@@ -2326,6 +2360,18 @@
       <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
+      <Setter Property="SelectionBackground"
+              Value="{StaticResource selectionInnerRowBackgroundBrush}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{StaticResource inactiveSelectionInnerRowBackgroundBrush}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+
       <!-- The GroupHeaderControl itself must not be focusable. The main Border inside its Template will
            be made Focusable because it holds the various InputBindings that make the
            GroupHeaderControl work. -->
@@ -2413,7 +2459,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableflowView.Aero.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableflowView.Aero.normalcolor.xaml
index e20fcc40..b506c1c9 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableflowView.Aero.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero/TableflowView.Aero.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant and color-scheme independant theme resources -->
-      <ResourceDictionary Source="Resources/Aero.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Aero.Resources.xaml" />
 
       <!-- Include the view dependant and color-scheme independant theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Aero.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Aero.Graphics.xaml" />
 
       <!-- Include the view independant and color-scheme dependant theme resources -->
-      <ResourceDictionary Source="Resources/Aero.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Aero.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -339,7 +338,6 @@
         Thickness="2"
         Pen.Brush="White" />
 
-
    <!-- =================================================================== -->
    <!-- Templates specific to this View/Theme/ColorScheme                   -->
    <!-- =================================================================== -->
@@ -635,7 +633,6 @@
             <ColumnDefinition Width="Auto" />
             <ColumnDefinition Width="Auto" />
 
-
             <!-- CellsHost panel -->
             <ColumnDefinition Width="*" />
          </Grid.ColumnDefinitions>
@@ -694,7 +691,6 @@
                                ColumnStretchMode="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).ColumnStretchMode}"
                                FixedCellCount="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).FixedColumnCount, Mode=TwoWay}"
                                FixedColumnDropMarkPen="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).FixedColumnDropMarkPen}"
-                               TextElement.Foreground="{TemplateBinding Foreground}"
                                Margin="{TemplateBinding BorderThickness}" />
 
       </Grid>
@@ -725,6 +721,10 @@
                     Property="Background"
                     Value="{StaticResource selectionInnerRowBackgroundBrush}" />
 
+            <Setter TargetName="rootGrid"
+                    Property="TextElement.Foreground"
+                    Value="{Binding RelativeSource={RelativeSource TemplatedParent},Path=SelectionForeground}" />
+
          </MultiDataTrigger>
 
          <!-- This trigger is used to display the Inactive Selection look -->
@@ -754,6 +754,10 @@
                     Property="Background"
                     Value="{StaticResource inactiveSelectionInnerRowBackgroundBrush}" />
 
+            <Setter TargetName="rootGrid"
+                    Property="TextElement.Foreground"
+                    Value="{Binding RelativeSource={RelativeSource TemplatedParent},Path=InactiveSelectionForeground}" />
+
          </MultiDataTrigger>
 
          <!-- This trigger is used to display Mouse Over look -->
@@ -780,7 +784,6 @@
                     Property="Background"
                     Value="{StaticResource hotInnerRowBackgroundBrush}" />
 
-
          </MultiDataTrigger>
 
          <!-- This trigger is used to display Mouse Over + Selected look -->
@@ -920,7 +923,6 @@
 
       </Grid>
       <ControlTemplate.Triggers>
-
          <!-- When there are details, display the Toggle button for the expansion, collapsing of the details -->
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
@@ -1227,6 +1229,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+    <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -1244,18 +1248,22 @@
 
                   <DockPanel Margin="{TemplateBinding Padding}">
 
-                     <ContentPresenter x:Name="sortGlyphPresenter"
-                                       DockPanel.Dock="Top"
-                                       Content="{x:Null}"
-                                       ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}"
-                                       Visibility="Hidden"
-                                       HorizontalAlignment="Center" />
+                     <StackPanel Orientation="Horizontal"
+                                 DockPanel.Dock="Top"
+                                 HorizontalAlignment="Center">
+                        <ContentPresenter x:Name="sortGlyphPresenter"
+                                          Content="{x:Null}"
+                                          ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}"
+                                          VerticalAlignment="Top"
+                                          Visibility="Hidden" />
+                     </StackPanel>
                      <Grid>
                         <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="*" />
                            <ColumnDefinition Width="Auto" />
                         </Grid.ColumnDefinitions>
-                        <local:CellContentPresenter x:Name="PART_CellContentPresenter" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                        <local:CellContentPresenter x:Name="PART_CellContentPresenter"
+                                                    HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                                                     VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
                         <Border x:Name="thumbToggleBackgroundBorder"
@@ -1279,7 +1287,6 @@
                   <Border x:Name="delimiterBorder"
                           BorderThickness="1,0,1,0"
                           BorderBrush="{StaticResource rowSelectorDelimiterBorderBrush}" />
-
                </Grid>
 
             </DockPanel>
@@ -1306,12 +1313,13 @@
                <Condition Value="Visible"
                           Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
                <Condition Value="Center"
-                           Binding="{Binding RelativeSource={RelativeSource Self},
+                          Binding="{Binding RelativeSource={RelativeSource Self},
                         Path=HorizontalContentAlignment}" />
             </MultiDataTrigger.Conditions>
 
             <Setter TargetName="PART_CellContentPresenter"
-                    Property="Margin" Value="19,0,0,0"/>
+                    Property="Margin"
+                    Value="19,0,0,0" />
          </MultiDataTrigger>
 
          <!-- Trigger related to the filteringToggleButton-->
@@ -1745,7 +1753,6 @@
                           Grid.Column="1"
                           Grid.RowSpan="3">
 
-
                      <!--Will contain DetailGroupByConrol-->
 
                      <ContentPresenter Content="{TemplateBinding HeaderedContentControl.Header}"
@@ -1812,7 +1819,6 @@
                  BorderBrush="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}"
                  BorderThickness="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
 
-
          <local:HierarchicalGroupLevelIndicatorPane Grid.Column="0" />
 
          <!-- GroupLevelIndicatorPane is a placeholder for individual GroupLevelIndicator elements that are added
@@ -1944,12 +1950,10 @@
                     Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right, Left'}" />
          </DataTrigger>
 
-
       </ControlTemplate.Triggers>
 
    </ControlTemplate>
 
-
    <!--**************************
     * TEMPLATE: HierarchicalGroupByControlNode
     ************************** -->
@@ -2322,7 +2326,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Aero;V4.0.0.0;31bf3856ad364e35;component\themes/aero.normalcolor.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Aero;V4.0.0.0;31bf3856ad364e35;component\themes/aero.normalcolor.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -2375,7 +2379,6 @@
 
       <Style.Triggers>
 
-
          <!-- The DataContext of a RowSelector is always set to its corresponding
               Row/item. This is why we use DataTriggers with no explicit Binding Source
               when we want to react to properties of the Row/item. -->
@@ -2433,7 +2436,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -2441,6 +2444,9 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewRowTemplate}" />
 
@@ -2448,13 +2454,13 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -2544,18 +2550,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -2584,6 +2599,9 @@
       <Setter Property="BorderThickness"
               Value="1" />
 
+      <Setter Property="Background"
+              Value="Transparent" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
               Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
@@ -2591,6 +2609,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
 
@@ -2649,6 +2673,9 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="BorderThickness"
+              Value="1" />      
+
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
@@ -2658,13 +2685,24 @@
       <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
+      <Setter Property="SelectionBackground"
+              Value="{StaticResource selectionInnerRowBackgroundBrush}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{StaticResource inactiveSelectionInnerRowBackgroundBrush}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+
       <!-- The GroupHeaderControl itself must not be focusable. The main Border inside its Template will
            be made Focusable because it holds the various InputBindings that make the
            GroupHeaderControl work. -->
       <Setter Property="Focusable"
               Value="False" />
 
-
       <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupHeaderControlTemplate}" />
 
@@ -2691,7 +2729,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: GroupLevelIndicator
     ************************** -->
@@ -2768,7 +2805,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
@@ -2936,7 +2973,6 @@
               Value="{StaticResource tableflowViewGroupNavigationButtonTemplate}" />
    </Style>
 
-
    <!--**************************
     * STYLE: ScrollTip
     ************************** -->
@@ -3038,7 +3074,6 @@
               Value="{StaticResource connectionStateErrorGlyph}" />
    </Style>
 
-
    <!-- =================================================================== -->
    <!-- DefaultStyleKey declarations                                        -->
    <!-- =================================================================== -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Controls.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Controls.xaml
new file mode 100644
index 00000000..ad565c3e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Controls.xaml
@@ -0,0 +1,2177 @@
+<!--***********************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  **********************************************************************************-->
+
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:s="clr-namespace:System;assembly=mscorlib"
+                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
+
+   <ResourceDictionary.MergedDictionaries>
+
+      <!-- Include the view independant, color-scheme independant, theme resources -->
+      <markup:DataGridThemeResourceDictionary Source="Aero2.normalcolor.Resources.xaml" />
+
+   </ResourceDictionary.MergedDictionaries>
+
+   <LinearGradientBrush x:Key="NormalBrush"
+                        EndPoint="0,1"
+                        StartPoint="0,0">
+      <GradientStop Color="#EEE"
+                    Offset="0.0" />
+      <GradientStop Color="#CCC"
+                    Offset="1.0" />
+   </LinearGradientBrush>
+
+   <SolidColorBrush x:Key="DisabledForegroundBrush"
+                    Color="#888" />
+   <SolidColorBrush x:Key="DisabledBackgroundBrush"
+                    Color="#EEE" />
+
+   <ControlTemplate x:Key="ComboBoxTextBox"
+                    TargetType="{x:Type TextBox}">
+
+      <!-- This must be named as PART_ContentHost -->
+      <Border x:Name="PART_ContentHost"
+              Focusable="False"
+              Background="{TemplateBinding Background}" />
+   </ControlTemplate>
+
+   <!-- Used for Checkmark, Radio button, TreeViewItem, Expander ToggleButton glyphs -->
+   <SolidColorBrush x:Key="aero2NormalColorGlyphBrush"
+                    Color="#444" />
+
+   <SolidColorBrush x:Key="glyphDefaultBordeBrush"
+                    Color="Black" />
+
+   <SolidColorBrush x:Key="scrollbarGlyphBordeBrush"
+                    Color="White" />
+
+   <LinearGradientBrush x:Key="checkBoxBorderDefaultBackgroundBrush"
+                        EndPoint="0.5,1"
+                        StartPoint="0.5,0">
+      <GradientStop Color="#3F1686D8"
+                    Offset="0" />
+      <GradientStop Offset="0.53"
+                    Color="#001686D8" />
+      <GradientStop Color="#3F1686D8"
+                    Offset="0.987" />
+   </LinearGradientBrush>
+
+   <LinearGradientBrush x:Key="checkBoxPathDefaultBackgroundBrush"
+                        EndPoint="0.6,0.75"
+                        StartPoint="0,0">
+      <GradientStop Color="#7F1686D8" />
+      <GradientStop Offset="1"
+                    Color="#001686D8" />
+   </LinearGradientBrush>
+
+   <LinearGradientBrush x:Key="checkBoxPathMouseOverBackgroundBrush"
+                        EndPoint="0.6,0.75"
+                        StartPoint="0,0">
+      <GradientStop Color="White" />
+      <GradientStop Offset="1" />
+   </LinearGradientBrush>
+
+   <LinearGradientBrush x:Key="checkBoxBorderPressedBackgroundBrush"
+                        EndPoint="0.5,1"
+                        StartPoint="0.5,0">
+      <GradientStop Color="#BF1686D8" />
+      <GradientStop Offset="0.53" />
+      <GradientStop Color="#BF1686D8"
+                    Offset="0.987" />
+      <GradientStop Color="#7F56A7E2"
+                    Offset="0.252" />
+      <GradientStop Color="#7F56A7E2"
+                    Offset="0.756" />
+   </LinearGradientBrush>
+
+   <SolidColorBrush x:Key="buttonOutsideBorderDefaultBorderBrush"
+                    Color="#FFAAAAAA" />
+
+   <LinearGradientBrush x:Key="buttonOutsideBorderDefaultBackgroundBrush"
+                        EndPoint="0.5,1"
+                        StartPoint="0.5,0">
+      <GradientStop Color="#FF0280E0"
+                    Offset="0.51" />
+      <GradientStop Color="#FF04A2F7"
+                    Offset="0.5" />
+   </LinearGradientBrush>
+
+   <LinearGradientBrush x:Key="buttonOutsideBorderDefaultVerticalBackgroundBrush"
+                        EndPoint="1,0.5"
+                        StartPoint="0,0.5">
+      <GradientStop Color="#FF0280E0"
+                    Offset="0.51" />
+      <GradientStop Color="#FF04A2F7"
+                    Offset="0.5" />
+   </LinearGradientBrush>
+
+   <SolidColorBrush x:Key="buttonInsideBorderIsMouseOverBorderBrush"
+                    Color="White" />
+
+   <SolidColorBrush x:Key="buttonInsideBorderIsPressedBorderBrush"
+                    Color="White" />
+
+   <LinearGradientBrush x:Key="buttonOutsideBorderIsPressedBackgroundBrush"
+                        EndPoint="0.5,1"
+                        StartPoint="0.5,0">
+      <GradientStop Color="#FF015EC8"
+                    Offset="0.5" />
+      <GradientStop Color="#FF0283E2"
+                    Offset="0.49" />
+      <GradientStop Color="#FF015EC8"
+                    Offset="1" />
+      <GradientStop Color="#FF0283E2"
+                    Offset="0.003" />
+   </LinearGradientBrush>
+
+   <LinearGradientBrush x:Key="buttonOutsideBorderIsPressedVerticalBackgroundBrush"
+                        EndPoint="1,0.5"
+                        StartPoint="0,0.5">
+      <GradientStop Color="#FF015EC8"
+                    Offset="0.5" />
+      <GradientStop Color="#FF0283E2"
+                    Offset="0.49" />
+      <GradientStop Color="#FF015EC8"
+                    Offset="1" />
+      <GradientStop Color="#FF0283E2"
+                    Offset="0.003" />
+   </LinearGradientBrush>
+
+   <LinearGradientBrush x:Key="buttonOutsideBorderIsMouseOverBackgroundBrush"
+                        EndPoint="0.5,1"
+                        StartPoint="0.5,0">
+      <GradientStop Color="#FF31B7FF"
+                    Offset="0.49" />
+      <GradientStop Color="#FF04A2F7"
+                    Offset="0.5" />
+   </LinearGradientBrush>
+
+   <LinearGradientBrush x:Key="buttonOutsideBorderIsMouseOverVerticalBackgroundBrush"
+                        EndPoint="1,0.5"
+                        StartPoint="0,0.5">
+      <GradientStop Color="#FF31B7FF"
+                    Offset="0.49" />
+      <GradientStop Color="#FF04A2F7"
+                    Offset="0.5" />
+   </LinearGradientBrush>
+
+   <SolidColorBrush x:Key="buttonOutsideBorderDisabledBorderBrush"
+                    Color="#AAA" />
+
+   <SolidColorBrush x:Key="buttonOutsideBorderDisabledBackgroundBrush"
+                    Color="#EEE" />
+
+   <!-- Used for background of ScrollViewer, TreeView, ListBox, Expander, TextBox, Tab Control -->
+   <SolidColorBrush x:Key="windowDefaultBackgroundBrush"
+                    Color="#FFFFFFFF" />
+
+   <SolidColorBrush x:Key="repeatButtonBorderDefaultBackgrounBrush"
+                    Color="Transparent" />
+
+   <DataTemplate x:Key="leafGlyph">
+      <Viewbox RenderTransformOrigin="0.5,0.5">
+         <Viewbox.LayoutTransform>
+            <RotateTransform Angle="133" />
+         </Viewbox.LayoutTransform>
+         <Grid Width="32.737"
+               Height="23.022">
+            <Path Stretch="Fill"
+                  Width="27.518"
+                  Data="F1M359.521,63.197C359.521,63.197,365.377,73.922,387.039,72.272L387.039,72.272C382.633,66.602,375.129,60.384,367.609,60.385L367.609,60.385C364.865,60.385,362.119,61.213,359.521,63.197"
+                  HorizontalAlignment="Right"
+                  Margin="0,0,1,10.962">
+               <Path.Fill>
+                  <LinearGradientBrush EndPoint="0.954,0.925"
+                                       StartPoint="0.041,0.212">
+                     <GradientStop Color="#3FA0FF00"
+                                   Offset="0" />
+                     <GradientStop Color="#FF35D16A"
+                                   Offset="0.504" />
+                     <GradientStop Color="#FF269B4E"
+                                   Offset="0.991" />
+                  </LinearGradientBrush>
+               </Path.Fill>
+            </Path>
+            <Path Stretch="Fill"
+                  Width="16.811"
+                  Data="F1M371.038,82.379C371.038,82.379,387.183,87.576,387.849,73.688L387.849,73.688C386.354,73.428,385.138,73.309,384.133,73.309L384.133,73.309C377.22,73.309,380.281,78.91,371.038,82.379"
+                  HorizontalAlignment="Right"
+                  Margin="0,13,0,0"
+                  VerticalAlignment="Top"
+                  Height="10.022">
+               <Path.Fill>
+                  <LinearGradientBrush EndPoint="0.944,0.199"
+                                       StartPoint="0.014,1.019">
+                     <GradientStop Color="#3FA0FF00"
+                                   Offset="0" />
+                     <GradientStop Color="#FF35D16A"
+                                   Offset="0.496" />
+                     <GradientStop Color="#FF269B4E"
+                                   Offset="0.991" />
+                  </LinearGradientBrush>
+               </Path.Fill>
+            </Path>
+            <Path Stretch="Fill"
+                  Width="24.737"
+                  Data="F1M354.892,78.722C364.253,87.011,375.045,79.608,379.629,73.713L379.629,73.713C376.149,72.569,373.047,72.116,370.317,72.116L370.317,72.116C359.895,72.115,354.892,78.722,354.892,78.722"
+                  HorizontalAlignment="Right"
+                  Margin="0,12,8,0"
+                  VerticalAlignment="Top"
+                  Height="10.306">
+               <Path.Fill>
+                  <LinearGradientBrush EndPoint="0.93,0.231"
+                                       StartPoint="0.046,0.686">
+                     <GradientStop Color="#3FA0FF00"
+                                   Offset="0" />
+                     <GradientStop Color="#FF35D16A"
+                                   Offset="0.526" />
+                     <GradientStop Color="#FF269B4E"
+                                   Offset="0.996" />
+                  </LinearGradientBrush>
+               </Path.Fill>
+            </Path>
+         </Grid>
+      </Viewbox>
+   </DataTemplate>
+
+   <!-- Radio Button -->
+   <Style TargetType="{x:Type RadioButton}">
+
+      <Setter Property="SnapsToDevicePixels"
+              Value="true" />
+
+      <Setter Property="Template">
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type RadioButton}">
+
+               <!-- BulletDecorator is used to provide baseline alignment between the checkmark and the Content -->
+               <BulletDecorator Background="Transparent">
+
+                  <BulletDecorator.Bullet>
+
+                     <Grid Width="13"
+                           Height="13">
+
+                        <Ellipse x:Name="EllipseOutside"
+                                 Fill="{StaticResource checkBoxOutsideBorderDefaultBackgroundBrush}"
+                                 Stroke="{StaticResource checkBoxOutsideBorderDefaultBorderBrush}"
+                                 StrokeThickness="1" />
+
+                        <Ellipse x:Name="EllipseInside"
+                                 Fill="{StaticResource checkBoxInsideBorderDefaultBackgroundBrush}"
+                                 Stroke="{StaticResource checkBoxInsideBorderDefaultBorderBrush}"
+                                 StrokeThickness="1"
+                                 HorizontalAlignment="Stretch"
+                                 Margin="2,2,2,2"
+                                 Width="Auto" />
+
+                        <Ellipse x:Name="CheckMark"
+                                 Margin="4"
+                                 Fill="{StaticResource glyphDefaultBordeBrush}" />
+                     </Grid>
+
+                  </BulletDecorator.Bullet>
+
+                  <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                    Margin="{TemplateBinding Padding}"
+                                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                                    RecognizesAccessKey="True" />
+
+               </BulletDecorator>
+
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsChecked"
+                           Value="false">
+
+                     <Setter Property="Visibility"
+                             Value="Collapsed"
+                             TargetName="CheckMark" />
+                  </Trigger>
+
+                  <Trigger Property="IsMouseOver"
+                           Value="true">
+
+                     <Setter Property="Stroke"
+                             TargetName="EllipseOutside"
+                             Value="{StaticResource checkBoxOutsideBorderIsMouseOverBorderBrush}" />
+
+                     <Setter Property="Fill"
+                             TargetName="EllipseOutside"
+                             Value="{StaticResource checkBoxOutsideBorderIsMouseOverBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="EllipseInside"
+                             Value="{StaticResource checkBoxInsideBorderIsMouseOverBorderBrush}" />
+
+                     <Setter Property="Fill"
+                             TargetName="EllipseInside"
+                             Value="{StaticResource checkBoxInsideBorderIsMouseOverBackgroundBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsPressed"
+                           Value="true">
+
+                     <Setter Property="Fill"
+                             TargetName="EllipseOutside"
+                             Value="{StaticResource checkBoxOutsideBorderIsPressedBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="EllipseOutside"
+                             Value="{StaticResource checkBoxOutsideBorderIsPressedBorderBrush}" />
+
+                     <Setter Property="Fill"
+                             TargetName="EllipseInside"
+                             Value="{StaticResource checkBoxInsideBorderIsPressedBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="EllipseInside"
+                             Value="{StaticResource checkBoxInsideBorderIsPressedBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="false">
+
+                     <Setter Property="Foreground"
+                             Value="#80000000" />
+
+                     <Setter Property="Stroke"
+                             TargetName="EllipseInside"
+                             Value="{StaticResource checkBoxInsideBorderIsEnabledBorderBrush}" />
+
+                     <Setter Property="Fill"
+                             TargetName="EllipseInside"
+                             Value="{StaticResource checkBoxInsideBorderIsEnabledBackgroundBrush}" />
+
+                     <Setter Property="Fill"
+                             TargetName="EllipseOutside"
+                             Value="{StaticResource checkBoxOutsideBorderIsEnabledBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="EllipseOutside"
+                             Value="{StaticResource checkBoxOutsideBorderIsEnabledBorderBrush}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <!-- checkBoxWindows8 -->
+
+   <Style TargetType="{x:Type CheckBox}">
+
+      <Setter Property="SnapsToDevicePixels"
+              Value="true" />
+
+      <Setter Property="Template">
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type CheckBox}">
+               <Border>
+                  <Grid>
+                     <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="13" />
+                     </Grid.ColumnDefinitions>
+                     <Border Name="Border"
+                             Margin="1"
+                             Grid.Column="0"
+                             Grid.ColumnSpan="4" />
+
+                     <Grid HorizontalAlignment="Center"
+                           VerticalAlignment="Center"
+                           Width="13"
+                           Height="13">
+
+                        <Border Background="#FFD1ECFF"
+                                CornerRadius="1"
+                                Margin="1" />
+
+                        <Border x:Name="insideBorder"
+                                Margin="1"
+                                BorderBrush="White"
+                                BorderThickness="1"
+                                CornerRadius="1"
+                                Background="{StaticResource checkBoxBorderDefaultBackgroundBrush}" />
+
+                        <Path x:Name="CheckBoxPath"
+                              Stroke="{x:Null}"
+                              Stretch="Fill"
+                              Margin="0.976,0.985,0.978,1.024"
+                              Fill="{StaticResource checkBoxPathDefaultBackgroundBrush}"
+                              Data="M0.89013951,21.53754 C0.89013951,22.13754 0.92765297,3.68705 1.0012841,2.92993 1.2523327,0.34849 -3.6053779,-0.02693 23.25,-0.01368 46.88465,-0.00203 353.22295,0.01789 368.74551,-0.01368 399.32761,-0.0759 393.45345,-0.35295 392.87051,4.81326 366.3499,4.83686 234.23724,4.3665 163.26526,7.74613 92.293281,11.12575 15.63336,16.94202 12.222291,22.88633 10.979058,22.89814 7.5156977,23.01335 3.751176,22.50587 -0.013345688,21.99839 0.89013951,21.32853 0.89013951,21.53754 z" />
+
+                        <Border BorderBrush="Black"
+                                BorderThickness="1"
+                                CornerRadius="2" />
+                     </Grid>
+
+                     <Border Name="Check"
+                             Width="13"
+                             Height="13"
+                             Margin="6,0,6,0"
+                             Background="Transparent"
+                             BorderThickness="1"
+                             BorderBrush="Transparent">
+                        <Path Name="CheckMark"
+                              Visibility="Hidden"
+                              SnapsToDevicePixels="False"
+                              Fill="{StaticResource glyphDefaultBordeBrush}"
+                              Height="11"
+                              Width="10"
+                              Stretch="Fill"
+                              Opacity="1"
+                              Data="M 9.58416748046875,0 C9.58416748046875,0 10,0.6159515380859375 10,0.6159515380859375 8.7657470703125,1.540008544921875 8.419189453125,2.9010162353515625 6.96038818359375,4.698974609375 5.5015869140625,6.4969329833984375 4.602294921875,9.774444580078125 4.602294921875,9.774444580078125 4.602294921875,9.774444580078125 3.9029541015625,10.2296142578125 3.9029541015625,10.2296142578125 3.419921875,10.55328369140625 3.01983642578125,10.810089111328125 2.70257568359375,11 2.581787109375,10.676483154296875 2.114166259765625,9.48345947265625 1.46875,8.5 0.8125,7.5 0.4044189453125,6.9029998779296875 0,6.7393035888671875 0.667236328125,5.9750518798828125 1.8385009765625,5.592926025390625 1.8385009765625,5.592926025390625 1.8385009765625,5.592926025390625 3.555908203125,7.8286285400390625 3.555908203125,7.8286285400390625 4.3878173828125,6.349609375 4.5516357421875,4.8782501220703125 6.04742431640625,3.4145355224609375 7.543212890625,1.9508209228515625 8.055419921875,0.8126373291015625 9.58416748046875,0 z" />
+                     </Border>
+                     <ContentPresenter Name="HeaderHost"
+                                       Grid.Column="1"
+                                       VerticalAlignment="Center"
+                                       ContentSource="Header"
+                                       RecognizesAccessKey="True"
+                                       Content="{TemplateBinding Content}"
+                                       ContentTemplate="{TemplateBinding ContentTemplate}"
+                                       ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}" />
+                  </Grid>
+               </Border>
+               <ControlTemplate.Triggers>
+                  <Trigger Property="IsMouseOver"
+                           Value="true">
+                     <Setter TargetName="CheckBoxPath"
+                             Property="Fill"
+                             Value="{StaticResource checkBoxPathMouseOverBackgroundBrush}" />
+                  </Trigger>
+                  <Trigger Property="IsPressed"
+                           Value="true">
+                     <Setter TargetName="CheckBoxPath"
+                             Property="Fill"
+                             Value="{StaticResource checkBoxPathDefaultBackgroundBrush}" />
+                     <Setter TargetName="insideBorder"
+                             Property="Background"
+                             Value="{StaticResource checkBoxBorderPressedBackgroundBrush}" />
+                  </Trigger>
+                     <Trigger Property="IsChecked"
+                           Value="true">
+                     <Setter TargetName="CheckMark"
+                             Property="Visibility"
+                             Value="Visible" />
+                  </Trigger>
+                  <Trigger Property="IsEnabled"
+                           Value="false">
+                     <Setter Property="Foreground"
+                             Value="#DADADA" />
+                  </Trigger>
+               </ControlTemplate.Triggers>
+            </ControlTemplate>
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <!-- Expander 
+	 This uses the Simpler ExpanderToggleButton. It sets Visibility on the ContentPresenter to expand
+	 Limitations : The Simple Expander only expands down -->
+
+   <!-- Expander ToggleButton - This Button is used by the Expander control. When it is toggled it switches visibility on the Up_Arrow and Down_Arrow -->
+   <ControlTemplate x:Key="toggleButtonControllAero2NormalColor"
+                    TargetType="{x:Type ToggleButton}">
+
+      <Grid>
+         <Border Background="Transparent" />
+
+         <Border CornerRadius="4"
+                 BorderBrush="Black"
+                 BorderThickness="1,0,0,1"
+                 MinHeight="16"
+                 MinWidth="16"
+                 SnapsToDevicePixels="True"
+                 HorizontalAlignment="Center"
+                 VerticalAlignment="Center"
+                 IsHitTestVisible="False"
+                 Margin="0,0,4,0">
+            <Border x:Name="toggleDecorator"
+                    CornerRadius="3"
+                    BorderBrush="{StaticResource basicWhiteBorderBrush}"
+                    BorderThickness="1,0,0,1"
+                    SnapsToDevicePixels="True">
+               <Path Data="M 0 0 L 4 4 L 8 0 Z"
+                     Fill="{StaticResource aero2NormalColorGlyphBrush}"
+                     HorizontalAlignment="Center"
+                     VerticalAlignment="Center"
+                     IsHitTestVisible="False"
+                     Margin="0,2,2,0" />
+            </Border>
+         </Border>
+
+      </Grid>
+
+      <ControlTemplate.Triggers>
+
+         <Trigger Property="IsMouseOver"
+                  Value="true">
+
+            <Setter Property="Background"
+                    TargetName="toggleDecorator">
+               <Setter.Value>
+                  <LinearGradientBrush EndPoint="0.5,1"
+                                       StartPoint="0.5,0">
+                     <GradientStop Offset="0" />
+                     <GradientStop Color="White"
+                                   Offset="1" />
+                  </LinearGradientBrush>
+               </Setter.Value>
+            </Setter>
+
+         </Trigger>
+
+         <Trigger Property="IsChecked"
+                  Value="true">
+
+            <Setter Property="Background"
+                    TargetName="toggleDecorator">
+               <Setter.Value>
+                  <LinearGradientBrush EndPoint="0.5,1"
+                                       StartPoint="0.5,0">
+                     <GradientStop Offset="1" />
+                     <GradientStop Color="#FF04A2F7"
+                                   Offset="0" />
+                  </LinearGradientBrush>
+               </Setter.Value>
+            </Setter>
+
+         </Trigger>
+
+         <Trigger Property="IsEnabled"
+                  Value="False">
+
+            <Setter Property="Opacity"
+                    Value="0.3"
+                    TargetName="toggleDecorator" />
+
+         </Trigger>
+
+      </ControlTemplate.Triggers>
+
+   </ControlTemplate>
+
+   <Style TargetType="{x:Type Expander}">
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type Expander}">
+
+               <Grid>
+
+                  <Grid.RowDefinitions>
+
+                     <RowDefinition Height="Auto" />
+
+                     <RowDefinition x:Name="ContentRow"
+                                    Height="*" />
+
+                  </Grid.RowDefinitions>
+
+                  <Border x:Name="Border"
+                          Grid.Row="0"
+                          Background="{StaticResource windowDefaultBackgroundBrush}"
+                          BorderBrush="{StaticResource buttonOutsideBorderDefaultBorderBrush}"
+                          BorderThickness="{TemplateBinding BorderThickness}"
+                          CornerRadius="0,0,0,0">
+
+                     <Grid>
+
+                        <Grid.ColumnDefinitions>
+
+                           <ColumnDefinition Width="20" />
+
+                           <ColumnDefinition Width="*" />
+
+                        </Grid.ColumnDefinitions>
+
+                        <ToggleButton Template="{StaticResource toggleButtonControllAero2NormalColor}"
+                                      Background="{StaticResource NormalBrush}"
+                                      IsChecked="{Binding Path=IsExpanded, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}"
+                                      OverridesDefaultStyle="True" />
+
+                        <ContentPresenter Grid.Column="1"
+                                          Margin="4"
+                                          RecognizesAccessKey="True"
+                                          ContentSource="Header" />
+
+                     </Grid>
+
+                  </Border>
+
+                  <Border x:Name="ExpandSite"
+                          Visibility="Collapsed"
+                          Grid.Row="1"
+                          Background="{StaticResource windowDefaultBackgroundBrush}"
+                          BorderBrush="{StaticResource buttonOutsideBorderDefaultBorderBrush}"
+                          BorderThickness="1,0,1,1"
+                          CornerRadius="0,0,0,0">
+
+                     <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                       Margin="{TemplateBinding Padding}"
+                                       VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                                       Focusable="false" />
+
+                  </Border>
+
+               </Grid>
+
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsExpanded"
+                           Value="True">
+
+                     <Setter Property="Visibility"
+                             Value="Visible"
+                             TargetName="ExpandSite" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+
+                     <Setter Property="Foreground"
+                             Value="{StaticResource DisabledForegroundBrush}" />
+
+                     <Setter Property="Background"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDisabledBackgroundBrush}" />
+
+                     <Setter Property="BorderBrush"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDisabledBorderBrush}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <!-- ScrollBar  This makes use of Thumb, RepeatButton and ScrollRepeatButton -->
+
+   <!-- Repeat Button - This is used by ScrollBar for the up and down buttons -->
+   <Style x:Key="increaseDecreaseRepeatButtonAero2NormalColor"
+          TargetType="{x:Type RepeatButton}">
+
+      <Setter Property="OverridesDefaultStyle"
+              Value="True" />
+
+      <Setter Property="Focusable"
+              Value="False" />
+
+      <Setter Property="IsTabStop"
+              Value="False" />
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type RepeatButton}">
+
+               <Grid>
+
+                  <Border x:Name="Border"
+                          Background="{StaticResource buttonOutsideBorderDefaultVerticalBackgroundBrush}"
+                          BorderBrush="{StaticResource buttonOutsideBorderDefaultBorderBrush}"
+                          BorderThickness="1"
+                          CornerRadius="3" />
+
+                  <ContentPresenter x:Name="ContentPresenter"
+                                    HorizontalAlignment="Center"
+                                    VerticalAlignment="Center"
+                                    Content="{TemplateBinding Content}"
+                                    ContentTemplate="{TemplateBinding ContentTemplate}"
+                                    ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}" />
+
+               </Grid>
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsMouseOver"
+                           Value="true">
+
+                     <Setter Property="Background"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderIsMouseOverVerticalBackgroundBrush}" />
+
+                     <Setter Property="BorderBrush"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsPressed"
+                           Value="true">
+
+                     <Setter Property="Background"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderIsPressedVerticalBackgroundBrush}" />
+
+                     <Setter Property="BorderBrush"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="false">
+
+                     <Setter Property="Foreground"
+                             Value="{StaticResource DisabledForegroundBrush}" />
+
+                     <Setter Property="Background"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDisabledBackgroundBrush}" />
+
+                     <Setter Property="BorderBrush"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDisabledBorderBrush}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <Style x:Key="increaseDecreaseHorizontalRepeatButtonAero2NormalColor"
+          TargetType="{x:Type RepeatButton}"
+          BasedOn="{StaticResource increaseDecreaseRepeatButtonAero2NormalColor}">
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type RepeatButton}">
+
+               <Grid>
+
+                  <Border x:Name="Border"
+                          Background="{StaticResource buttonOutsideBorderDefaultBackgroundBrush}"
+                          BorderBrush="{StaticResource buttonOutsideBorderDefaultBorderBrush}"
+                          BorderThickness="1"
+                          CornerRadius="3" />
+
+                  <ContentPresenter x:Name="ContentPresenter"
+                                    HorizontalAlignment="Center"
+                                    VerticalAlignment="Center"
+                                    Content="{TemplateBinding Content}"
+                                    ContentTemplate="{TemplateBinding ContentTemplate}"
+                                    ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}" />
+
+               </Grid>
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsMouseOver"
+                           Value="true">
+
+                     <Setter Property="Background"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderIsMouseOverBackgroundBrush}" />
+
+                     <Setter Property="BorderBrush"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsPressed"
+                           Value="true">
+
+                     <Setter Property="Background"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderIsPressedBackgroundBrush}" />
+
+                     <Setter Property="BorderBrush"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="false">
+
+                     <Setter Property="Foreground"
+                             Value="{StaticResource DisabledForegroundBrush}" />
+
+                     <Setter Property="Background"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDisabledBackgroundBrush}" />
+
+                     <Setter Property="BorderBrush"
+                             TargetName="Border"
+                             Value="{StaticResource buttonOutsideBorderDisabledBorderBrush}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <!-- Thumb - The Thumb is the draggable part of the Scrollbar -->
+   <Style x:Key="thumbAero2NormalColor"
+          TargetType="{x:Type Thumb}">
+
+      <Setter Property="OverridesDefaultStyle"
+              Value="True" />
+
+      <Setter Property="IsTabStop"
+              Value="False" />
+
+      <Setter Property="Focusable"
+              Value="False" />
+
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type Thumb}">
+               <Grid x:Name="Grid"
+                     Margin="0,0,0,0">
+                  <Rectangle x:Name="Rectangle"
+                             HorizontalAlignment="Stretch"
+                             VerticalAlignment="Stretch"
+                             Width="Auto"
+                             Height="Auto"
+                             RadiusX="3"
+                             RadiusY="3"
+                             Fill="{StaticResource buttonOutsideBorderDefaultVerticalBackgroundBrush}"
+                             Stroke="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+               </Grid>
+
+               <ControlTemplate.Triggers>
+                  <Trigger Property="IsMouseOver"
+                           Value="True">
+
+                     <Setter Property="Fill"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderIsMouseOverVerticalBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+
+                     <Setter Property="Fill"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDisabledBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDisabledBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsDragging"
+                           Value="True">
+
+                     <Setter Property="Fill"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderIsPressedVerticalBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <Style x:Key="horizontalthumbAero2NormalColor"
+          TargetType="{x:Type Thumb}"
+          BasedOn="{StaticResource thumbAero2NormalColor}">
+
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type Thumb}">
+               <Grid x:Name="Grid"
+                     Margin="0,0,0,0">
+                  <Rectangle x:Name="Rectangle"
+                             HorizontalAlignment="Stretch"
+                             VerticalAlignment="Stretch"
+                             Width="Auto"
+                             Height="Auto"
+                             RadiusX="3"
+                             RadiusY="3"
+                             Fill="{StaticResource buttonOutsideBorderDefaultBackgroundBrush}"
+                             Stroke="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+               </Grid>
+
+               <ControlTemplate.Triggers>
+                  <Trigger Property="IsMouseOver"
+                           Value="True">
+
+                     <Setter Property="Fill"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderIsMouseOverBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+
+                     <Setter Property="Fill"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDisabledBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDisabledBorderBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsDragging"
+                           Value="True">
+
+                     <Setter Property="Fill"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderIsPressedBackgroundBrush}" />
+
+                     <Setter Property="Stroke"
+                             TargetName="Rectangle"
+                             Value="{StaticResource buttonOutsideBorderDefaultBorderBrush}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <!-- ScrollRepeatButton Style - This RepeatButton is used above and below the Thumb in the Scrollbar. They are set to transparent si that they do not show over the scrollbar -->
+   <Style x:Key="repeatButtonPageUpDownAero2NormalColor"
+          TargetType="{x:Type RepeatButton}">
+
+      <Setter Property="OverridesDefaultStyle"
+              Value="True" />
+
+      <Setter Property="Background"
+              Value="Transparent" />
+
+      <Setter Property="BorderBrush"
+              Value="Transparent" />
+
+      <Setter Property="IsTabStop"
+              Value="false" />
+
+      <Setter Property="Focusable"
+              Value="false" />
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type RepeatButton}">
+
+               <Grid>
+                  <Rectangle Fill="{StaticResource repeatButtonBorderDefaultBackgrounBrush}" />
+               </Grid>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <Style TargetType="{x:Type ScrollBar}">
+
+      <Setter Property="Stylus.IsFlicksEnabled"
+              Value="false" />
+
+      <Setter Property="Stylus.IsPressAndHoldEnabled"
+              Value="False" />
+
+      <Setter Property="Foreground"
+              Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
+
+      <Setter Property="Width"
+              Value="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}" />
+
+      <Setter Property="MinWidth"
+              Value="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}" />
+
+      <Setter Property="Background"
+              Value="#FFD1ECFF" />
+
+     <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type ScrollBar}">
+               <Grid x:Name="GridRoot"
+                     Background="{TemplateBinding Background}">
+
+                  <Grid.RowDefinitions>
+
+                     <RowDefinition MaxHeight="{DynamicResource {x:Static SystemParameters.VerticalScrollBarButtonHeightKey}}" />
+
+                     <RowDefinition Height="0.00001*" />
+
+                     <RowDefinition MaxHeight="{DynamicResource {x:Static SystemParameters.VerticalScrollBarButtonHeightKey}}" />
+
+                  </Grid.RowDefinitions>
+
+                  <Border Grid.RowSpan="3"
+                          BorderBrush="#FFAAAAAA"
+                          BorderThickness="1" />
+
+                  <RepeatButton x:Name="DecreaseRepeat"
+                                Style="{StaticResource increaseDecreaseRepeatButtonAero2NormalColor}"
+                                Command="ScrollBar.LineUpCommand">
+                     <Grid>
+
+                        <Path x:Name="DecreaseArrow"
+                              Stroke="{x:Null}"
+                              StrokeThickness="1"
+                              Data="M 0 4 L 8 4 L 4 0 Z"
+                              Fill="{StaticResource scrollbarGlyphBordeBrush}" />
+
+                     </Grid>
+
+                  </RepeatButton>
+
+                  <!-- Track is a special layout container which sizes the thumb and the repeat button which do jump scrolling either side of it -->
+
+                  <Track x:Name="PART_Track"
+                         Grid.Row="1"
+                         IsDirectionReversed="true">
+
+                     <Track.Thumb>
+
+                        <Thumb Style="{StaticResource thumbAero2NormalColor}" />
+
+                     </Track.Thumb>
+
+                     <Track.IncreaseRepeatButton>
+
+                        <RepeatButton x:Name="PageUp"
+                                      Style="{StaticResource repeatButtonPageUpDownAero2NormalColor}"
+                                      Command="ScrollBar.PageDownCommand" />
+
+                     </Track.IncreaseRepeatButton>
+
+                     <Track.DecreaseRepeatButton>
+
+                        <RepeatButton x:Name="PageDown"
+                                      Style="{StaticResource repeatButtonPageUpDownAero2NormalColor}"
+                                      Command="ScrollBar.PageUpCommand" />
+
+                     </Track.DecreaseRepeatButton>
+
+                  </Track>
+
+                  <RepeatButton x:Name="IncreaseRepeat"
+                                Grid.Row="2"
+                                Style="{StaticResource increaseDecreaseRepeatButtonAero2NormalColor}"
+                                Command="ScrollBar.LineDownCommand">
+
+                     <Grid>
+
+                        <Path x:Name="IncreaseArrow"
+                              Stroke="{x:Null}"
+                              StrokeThickness="1"
+                              Data="M 0 0 L 4 4 L 8 0 Z"
+                              Fill="{StaticResource scrollbarGlyphBordeBrush}" />
+
+                     </Grid>
+
+                  </RepeatButton>
+
+               </Grid>
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+      <Style.Triggers>
+         <Trigger Property="Orientation"
+                  Value="Horizontal">
+            <Setter Property="Width"
+                    Value="Auto" />
+
+            <Setter Property="MinWidth"
+                    Value="0" />
+
+            <Setter Property="Height"
+                    Value="{DynamicResource {x:Static SystemParameters.HorizontalScrollBarHeightKey}}" />
+
+            <Setter Property="MinHeight"
+                    Value="{DynamicResource {x:Static SystemParameters.HorizontalScrollBarHeightKey}}" />
+
+            <Setter Property="Template">
+               <Setter.Value>
+                  <ControlTemplate TargetType="{x:Type ScrollBar}">
+                     <Grid x:Name="GridRoot"
+                           Background="{TemplateBinding Background}">
+
+                        <Grid.ColumnDefinitions>
+                           <ColumnDefinition MaxWidth="{DynamicResource {x:Static SystemParameters.HorizontalScrollBarButtonWidthKey}}" />
+                           <ColumnDefinition Width="0.00001*" />
+                           <ColumnDefinition MaxWidth="{DynamicResource {x:Static SystemParameters.HorizontalScrollBarButtonWidthKey}}" />
+                        </Grid.ColumnDefinitions>
+
+                        <Border Grid.ColumnSpan="3"
+                                BorderBrush="#FFAAAAAA"
+                                BorderThickness="1" />
+
+                        <RepeatButton x:Name="DecreaseRepeat"
+                                      Style="{StaticResource increaseDecreaseHorizontalRepeatButtonAero2NormalColor}"
+                                      Command="ScrollBar.LineLeftCommand">
+                           <Grid>
+                              <Grid.LayoutTransform>
+                                 <RotateTransform Angle="-90" />
+                              </Grid.LayoutTransform>
+
+                              <Path x:Name="DecreaseArrow"
+                                    Stroke="{x:Null}"
+                                    StrokeThickness="1"
+                                    Data="M 0 4 L 8 4 L 4 0 Z"
+                                    Fill="{StaticResource scrollbarGlyphBordeBrush}" />
+
+                           </Grid>
+
+                        </RepeatButton>
+
+                        <!-- Track is a special layout container which sizes the thumb and the repeat button which do jump scrolling either side of it -->
+
+                        <Track x:Name="PART_Track"
+                               Grid.Column="1">
+
+                           <Track.Thumb>
+
+                              <Thumb Style="{StaticResource horizontalthumbAero2NormalColor}" />
+
+                           </Track.Thumb>
+
+                           <Track.IncreaseRepeatButton>
+
+                              <RepeatButton x:Name="PageRight"
+                                            Style="{StaticResource repeatButtonPageUpDownAero2NormalColor}"
+                                            Command="ScrollBar.PageRightCommand" />
+
+                           </Track.IncreaseRepeatButton>
+
+                           <Track.DecreaseRepeatButton>
+
+                              <RepeatButton x:Name="PageLeft"
+                                            Style="{StaticResource repeatButtonPageUpDownAero2NormalColor}"
+                                            Command="ScrollBar.PageLeftCommand" />
+
+                           </Track.DecreaseRepeatButton>
+
+                        </Track>
+
+                        <RepeatButton x:Name="IncreaseRepeat"
+                                      Grid.Column="2"
+                                      Style="{StaticResource increaseDecreaseHorizontalRepeatButtonAero2NormalColor}"
+                                      Command="ScrollBar.LineRightCommand">
+
+                           <Grid>
+                              <Grid.LayoutTransform>
+                                 <RotateTransform Angle="-90" />
+                              </Grid.LayoutTransform>
+
+                              <Path x:Name="IncreaseArrow"
+                                    Stroke="{x:Null}"
+                                    StrokeThickness="1"
+                                    Data="M 0 0 L 4 4 L 8 0 Z"
+                                    Fill="{StaticResource scrollbarGlyphBordeBrush}" />
+
+                           </Grid>
+
+                        </RepeatButton>
+
+                     </Grid>
+                  </ControlTemplate>
+               </Setter.Value>
+            </Setter>
+         </Trigger>
+      </Style.Triggers>
+
+   </Style>
+
+   <!-- Simple Button - This control sets brushes on each state. Note that these brushes must be listed above since they are static resources -->
+   <Style TargetType="{x:Type Button}">
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type Button}">
+
+               <!-- We use Grid as a root because it is easy to add more elements to customize the button -->
+               <Grid x:Name="Grid">
+
+                  <Border Background="#FFD1ECFF"
+                          CornerRadius="3"
+                          BorderThickness="1"
+                          BorderBrush="{StaticResource basicBlackBorderBrush}">
+                     <Border x:Name="insideBorder"
+                             CornerRadius="2"
+                             BorderThickness="1"
+                             BorderBrush="{StaticResource basicWhiteBorderBrush}">
+                        <Border.Background>
+                           <LinearGradientBrush EndPoint="0.5,1"
+                                                StartPoint="0.5,0">
+                              <GradientStop Color="#3F1686D8"
+                                            Offset="0" />
+                              <GradientStop Offset="0.53"
+                                            Color="#001686D8" />
+                              <GradientStop Color="#3F1686D8"
+                                            Offset="0.987" />
+                           </LinearGradientBrush>
+                        </Border.Background>
+
+                        <Path x:Name="ClearFilterPath"
+                              Stroke="{x:Null}"
+                              Stretch="Fill"
+                              HorizontalAlignment="Stretch"
+                              Width="Auto"
+                              Data="M0.02,0.54 C0.02,0.55 0.02,0.09 0.03,0.07 0.03,0.01 -0.09,0 0.58,0 1.17,0 8.83,0 9.22,0 9.98,0 9.84,-0.01 9.82,0.12 9.16,0.12 5.86,0.11 4.08,0.19 2.30,0.28 0.39,0.42 0.31,0.57 0.27,0.57 0.19,0.58 0.09,0.56 0,0.55 0.02,0.53 0.02,0.53 z">
+                           <Path.Fill>
+                              <LinearGradientBrush EndPoint="0.6,0.75"
+                                                   StartPoint="0,0">
+                                 <GradientStop Color="#7F1686D8" />
+                                 <GradientStop Offset="1"
+                                               Color="#001686D8" />
+                              </LinearGradientBrush>
+                           </Path.Fill>
+                        </Path>
+                     </Border>
+                  </Border>
+
+                  <Border x:Name="mouseOverEffect"
+                          Margin="1"
+                          CornerRadius="3"
+                          Opacity="0">
+                     <Border.Background>
+                        <RadialGradientBrush Center="0.5,0.7"
+                                             GradientOrigin="0.5,1"
+                                             RadiusX="0.6"
+                                             RadiusY="0.8">
+                           <GradientStop Color="#BFFFFFFF"
+                                         Offset="0.3" />
+                           <GradientStop Offset="0.7"
+                                         Color="#33FFFFFF" />
+                           <GradientStop Color="#4CFFFFFF"
+                                         Offset="0.4" />
+                           <GradientStop Color="White"
+                                         Offset="0.06" />
+                        </RadialGradientBrush>
+                     </Border.Background>
+                  </Border>
+
+                  <!-- Content Presenter is where the text content etc is placed by the control -->
+                  <!-- The bindings are useful so that the control can be parameterized without editing the template -->
+                  <ContentPresenter x:Name="buttonContent"
+                                    HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                    Margin="{TemplateBinding Padding}"
+                                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                                    RecognizesAccessKey="True" />
+
+               </Grid>
+
+               <!--Each state sets a brush on the Border in the template -->
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsMouseOver"
+                           Value="true">
+
+                     <Setter Property="Opacity"
+                             TargetName="mouseOverEffect"
+                             Value="1" />
+                  </Trigger>
+
+                  <Trigger Property="IsPressed"
+                           Value="true">
+
+                     <Setter Property="Background"
+                             TargetName="insideBorder">
+                        <Setter.Value>
+                           <LinearGradientBrush EndPoint="0.5,1"
+                                                StartPoint="0.5,0">
+                              <GradientStop Color="#BF1686D8"
+                                            Offset="0" />
+                              <GradientStop Offset="0.5" />
+                              <GradientStop Color="#BF1686D8"
+                                            Offset="1" />
+                           </LinearGradientBrush>
+                        </Setter.Value>
+                     </Setter>
+
+                     <Setter Property="Opacity"
+                             TargetName="mouseOverEffect"
+                             Value="0" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="True" />
+
+                  <Trigger Property="IsEnabled"
+                           Value="false">
+
+                     <Setter TargetName="buttonContent"
+                             Property="TextElement.Foreground"
+                             Value="#868686" />
+
+                     <Setter Property="Foreground"
+                             Value="{StaticResource DisabledForegroundBrush}" />
+
+                     <Setter Property="Background"
+                             TargetName="insideBorder">
+                        <Setter.Value>
+                           <LinearGradientBrush EndPoint="0.5,1"
+                                                StartPoint="0.5,0">
+                              <GradientStop Color="#3FFFFFFF"
+                                            Offset="0" />
+                              <GradientStop Offset="0.5" />
+                              <GradientStop Color="#3FFFFFFF"
+                                            Offset="1" />
+                           </LinearGradientBrush>
+                        </Setter.Value>
+                     </Setter>
+
+                     <Setter Property="BorderBrush"
+                             TargetName="insideBorder"
+                             Value="{StaticResource buttonOutsideBorderDisabledBorderBrush}" />
+
+                     <Setter Property="Fill"
+                             TargetName="ClearFilterPath">
+                        <Setter.Value>
+                           <LinearGradientBrush EndPoint="0.5,1"
+                                                StartPoint="0.5,0">
+                              <GradientStop Color="#3FFFFFFF"
+                                            Offset="0" />
+                              <GradientStop Offset="0.5" />
+                              <GradientStop Color="#3FFFFFFF"
+                                            Offset="1" />
+                           </LinearGradientBrush>
+                        </Setter.Value>
+                     </Setter>
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <!-- ComboBox 
+	This uses the ComboBoxToggleButton to expand and collapse a Popup control
+	SimpleScrollViewer to allow items to be scrolled and SimpleComboBoxItem to define the look of each item 
+	The Popup shows a list of items in a StackPanel-->
+
+   <!-- ComboBox Toggle Button - This is used in ComboBox to expand and collapse the ComboBox Popup-->
+   <ControlTemplate x:Key="toggleButtonControlAero2NormalColor"
+                    TargetType="{x:Type ToggleButton}">
+      <Grid>
+
+         <Grid.ColumnDefinitions>
+
+            <ColumnDefinition />
+
+            <ColumnDefinition Width="Auto" />
+
+         </Grid.ColumnDefinitions>
+
+         <Border Background="Transparent"
+                 Grid.ColumnSpan="2" />
+
+         <Border CornerRadius="4"
+                 BorderBrush="Black"
+                 BorderThickness="1,0,0,1"
+                 MinHeight="16"
+                 MinWidth="16"
+                 SnapsToDevicePixels="True"
+                 HorizontalAlignment="Center"
+                 VerticalAlignment="Center"
+                 Grid.Column="1"
+                 IsHitTestVisible="False"
+                 Margin="0,0,4,0">
+            <Border x:Name="toggleDecorator"
+                    CornerRadius="3"
+                    BorderBrush="{StaticResource basicWhiteBorderBrush}"
+                    BorderThickness="1,0,0,1"
+                    SnapsToDevicePixels="True">
+               <Path Data="M 0 0 L 4 4 L 8 0 Z"
+                     Fill="{StaticResource aero2NormalColorGlyphBrush}"
+                     HorizontalAlignment="Center"
+                     VerticalAlignment="Center"
+                     IsHitTestVisible="False"
+                     Margin="0,2,2,0" />
+            </Border>
+         </Border>
+
+      </Grid>
+
+      <ControlTemplate.Triggers>
+
+         <Trigger Property="IsMouseOver"
+                  Value="true">
+
+            <Setter Property="Background"
+                    TargetName="toggleDecorator">
+               <Setter.Value>
+                  <LinearGradientBrush EndPoint="0.5,1"
+                                       StartPoint="0.5,0">
+                     <GradientStop Offset="0" />
+                     <GradientStop Color="White"
+                                   Offset="1" />
+                  </LinearGradientBrush>
+               </Setter.Value>
+            </Setter>
+
+         </Trigger>
+
+         <Trigger Property="IsChecked"
+                  Value="true">
+
+            <Setter Property="Background"
+                    TargetName="toggleDecorator">
+               <Setter.Value>
+                  <LinearGradientBrush EndPoint="0.5,1"
+                                       StartPoint="0.5,0">
+                     <GradientStop Offset="1" />
+                     <GradientStop Color="#FF04A2F7"
+                                   Offset="0" />
+                  </LinearGradientBrush>
+               </Setter.Value>
+            </Setter>
+
+         </Trigger>
+
+         <Trigger Property="IsEnabled"
+                  Value="False">
+
+            <Setter Property="Opacity"
+                    Value="0.3"
+                    TargetName="toggleDecorator" />
+
+         </Trigger>
+
+      </ControlTemplate.Triggers>
+
+   </ControlTemplate>
+
+   <!-- ScrollViewer 
+	ScrollViewer is a Grid control which has a ContentPresenter and a Horizontal and Vertical ScrollBar 
+	It is used by ListBox, MenuItem, ComboBox, and TreeView -->
+   <Style x:Key="ScrollViewerAero2NormalColor"
+          TargetType="{x:Type ScrollViewer}">
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type ScrollViewer}">
+
+               <Grid Background="{TemplateBinding Background}">
+
+                  <Grid.ColumnDefinitions>
+
+                     <ColumnDefinition Width="*" />
+
+                     <ColumnDefinition Width="Auto" />
+
+                  </Grid.ColumnDefinitions>
+
+                  <Grid.RowDefinitions>
+
+                     <RowDefinition Height="*" />
+
+                     <RowDefinition Height="Auto" />
+
+                  </Grid.RowDefinitions>
+
+                  <ScrollContentPresenter Grid.Column="0"
+                                          Grid.Row="0"
+                                          Margin="{TemplateBinding Padding}"
+                                          Content="{TemplateBinding Content}"
+                                          ContentTemplate="{TemplateBinding ContentTemplate}"
+                                          CanContentScroll="{TemplateBinding CanContentScroll}" />
+
+                  <!-- The visibility of the ScrollBars is controlled by the implementation fo the control -->
+                  <ScrollBar x:Name="PART_HorizontalScrollBar"
+                             Visibility="{TemplateBinding ComputedHorizontalScrollBarVisibility}"
+                             Grid.Column="0"
+                             Grid.Row="1"
+                             Orientation="Horizontal"
+                             Value="{Binding Path=HorizontalOffset, Mode=OneWay, RelativeSource={RelativeSource TemplatedParent}}"
+                             ViewportSize="{TemplateBinding ViewportWidth}"
+                             Minimum="0"
+                             Maximum="{TemplateBinding ScrollableWidth}"
+                             AutomationProperties.AutomationId="HorizontalScrollBar" />
+
+                  <ScrollBar x:Name="PART_VerticalScrollBar"
+                             Visibility="{TemplateBinding ComputedVerticalScrollBarVisibility}"
+                             Grid.Column="1"
+                             Grid.Row="0"
+                             Orientation="Vertical"
+                             Value="{Binding Path=VerticalOffset, Mode=OneWay, RelativeSource={RelativeSource TemplatedParent}}"
+                             ViewportSize="{TemplateBinding ViewportHeight}"
+                             Minimum="0"
+                             Maximum="{TemplateBinding ScrollableHeight}"
+                             AutomationProperties.AutomationId="VerticalScrollBar" />
+
+               </Grid>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <Style x:Key="aero2NormalColorComboBoxStyle"
+          TargetType="{x:Type ComboBox}">
+
+      <Setter Property="SnapsToDevicePixels"
+              Value="true" />
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type ComboBox}">
+
+               <Grid>
+
+                  <!-- The ToggleButton is databound to the ComboBox itself to toggle IsDropDownOpen -->
+                  <ToggleButton x:Name="ToggleButton"
+                                Grid.Column="2"
+                                Template="{StaticResource toggleButtonControlAero2NormalColor}"
+                                Focusable="false"
+                                IsChecked="{Binding Path=IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}"
+                                ClickMode="Press" />
+
+                  <ContentPresenter x:Name="ContentSite"
+                                    HorizontalAlignment="Left"
+                                    Margin="3,2,23,3"
+                                    TextElement.Foreground="Black"
+                                    VerticalAlignment="Center"
+                                    Content="{TemplateBinding SelectionBoxItem}"
+                                    ContentTemplate="{TemplateBinding SelectionBoxItemTemplate}"
+                                    ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"
+                                    IsHitTestVisible="False" />
+
+                  <!-- The TextBox must be named PART_EditableTextBox or ComboBox will not recognize it -->
+                  <TextBox x:Name="PART_EditableTextBox"
+                           Visibility="Hidden"
+                           Template="{StaticResource ComboBoxTextBox}"
+                           HorizontalAlignment="Left"
+                           Margin="3,2,23,3"
+                           Style="{x:Null}"
+                           VerticalAlignment="Center"
+                           Focusable="True"
+                           Background="Transparent"
+                           IsReadOnly="{TemplateBinding IsReadOnly}" />
+
+                  <!-- The Popup shows the list of items in the ComboBox. IsOpen is databound to IsDropDownOpen which is toggled via the ComboBoxToggleButton -->
+                  <Popup x:Name="Popup"
+                         IsOpen="{TemplateBinding IsDropDownOpen}"
+                         Placement="Bottom"
+                         Focusable="False"
+                         AllowsTransparency="True"
+                         PopupAnimation="Slide">
+
+                     <Grid x:Name="DropDown"
+                           MaxHeight="{TemplateBinding MaxDropDownHeight}"
+                           MinWidth="{TemplateBinding ActualWidth}"
+                           SnapsToDevicePixels="True">
+
+                        <Border x:Name="DropDownBorder"
+                                BorderBrush="{StaticResource basicBlackBorderBrush}"
+                                BorderThickness="1"
+                                CornerRadius="4">
+                           <Border BorderBrush="{StaticResource basicWhiteBorderBrush}"
+                                   BorderThickness="1"
+                                   CornerRadius="4">
+                              <Border.Background>
+                                 <LinearGradientBrush EndPoint="0.979,0.046"
+                                                      StartPoint="-0.019,1.017">
+                                    <GradientStop Color="#FF1686D8"
+                                                  Offset="1" />
+                                    <GradientStop Color="#FF06397B"
+                                                  Offset="0.297" />
+                                 </LinearGradientBrush>
+                              </Border.Background>
+                           </Border>
+                        </Border>
+
+                        <ScrollViewer Margin="4,6,4,6"
+                                      Style="{StaticResource ScrollViewerAero2NormalColor}"
+                                      SnapsToDevicePixels="True"
+                                      HorizontalScrollBarVisibility="Auto"
+                                      VerticalScrollBarVisibility="Auto"
+                                      CanContentScroll="True">
+
+                           <!-- The StackPanel is used to display the children by setting IsItemsHost to be True -->
+                           <StackPanel IsItemsHost="True"
+                                       KeyboardNavigation.DirectionalNavigation="Contained" 
+                                       TextElement.Foreground="White"/>
+
+                        </ScrollViewer>
+
+                     </Grid>
+
+                  </Popup>
+
+               </Grid>
+
+               <ControlTemplate.Triggers>
+                  <!-- This forces the DropDown to have a minimum size if it is empty -->
+                  <Trigger Property="HasItems"
+                           Value="false">
+
+                     <Setter Property="MinHeight"
+                             Value="95"
+                             TargetName="DropDownBorder" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="false">
+
+                     <Setter Property="Foreground"
+                             Value="{StaticResource DisabledForegroundBrush}" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsGrouping"
+                           Value="true">
+
+                     <Setter Property="ScrollViewer.CanContentScroll"
+                             Value="false" />
+
+                  </Trigger>
+                  <Trigger Property="AllowsTransparency"
+                           SourceName="Popup"
+                           Value="true">
+
+                     <Setter Property="CornerRadius"
+                             Value="4"
+                             TargetName="DropDownBorder" />
+
+                     <Setter Property="Margin"
+                             Value="0,2,0,0"
+                             TargetName="DropDownBorder" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEditable"
+                           Value="true">
+
+                     <Setter Property="IsTabStop"
+                             Value="false" />
+
+                     <Setter Property="Visibility"
+                             Value="Visible"
+                             TargetName="PART_EditableTextBox" />
+
+                     <Setter Property="Visibility"
+                             Value="Hidden"
+                             TargetName="ContentSite" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <Style TargetType="{x:Type ComboBox}"
+          BasedOn="{StaticResource aero2NormalColorComboBoxStyle}" />
+
+   <!-- Simple TextBox -->
+   <Style x:Key="textBoxAero2NormalColor"
+          TargetType="{x:Type TextBox}">
+
+      <Setter Property="KeyboardNavigation.TabNavigation"
+              Value="None" />
+
+      <Setter Property="FocusVisualStyle"
+              Value="{x:Null}" />
+
+      <Setter Property="AllowDrop"
+              Value="true" />
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type TextBox}">
+
+               <Grid>
+
+                  <Border x:Name="Border"
+                          Background="{StaticResource windowDefaultBackgroundBrush}"
+                          BorderBrush="{StaticResource buttonOutsideBorderDefaultBorderBrush}"
+                          BorderThickness="1"
+                          Padding="2"
+                          CornerRadius="0,0,0,0">
+
+                     <!-- The implementation places the Content into the ScrollViewer. It must be named PART_ContentHost for the control to function -->
+                     <ScrollViewer Margin="0"
+                                   x:Name="PART_ContentHost"
+                                   Style="{StaticResource ScrollViewerAero2NormalColor}"
+                                   Background="{TemplateBinding Background}" />
+                  </Border>
+
+               </Grid>
+
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+
+                     <Setter Property="Background"
+                             Value="{StaticResource DisabledBackgroundBrush}"
+                             TargetName="Border" />
+
+                     <Setter Property="BorderBrush"
+                             Value="{StaticResource DisabledBackgroundBrush}"
+                             TargetName="Border" />
+
+                     <Setter Property="Foreground"
+                             Value="{StaticResource DisabledForegroundBrush}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+   </Style>
+
+   <Style TargetType="{x:Type ComboBoxItem}">
+
+      <Setter Property="Padding"
+              Value="3,0,3,0" />
+
+      <Setter Property="Background"
+              Value="Transparent" />
+
+      <Setter Property="Template">
+
+         <Setter.Value>
+
+            <ControlTemplate TargetType="{x:Type ComboBoxItem}">
+
+               <Border x:Name="Bd"
+                       SnapsToDevicePixels="true"
+                       Background="{TemplateBinding Background}"
+                       BorderBrush="{TemplateBinding BorderBrush}"
+                       BorderThickness="{TemplateBinding BorderThickness}"
+                       Padding="{TemplateBinding Padding}">
+
+                  <ContentPresenter SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"
+                                    HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
+
+               </Border>
+
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsHighlighted"
+                           Value="true">
+
+                     <Setter Property="Background"
+                             TargetName="Bd"
+                             Value="#FF86E9F9" />
+
+                     <Setter Property="Foreground"
+                             Value="Black" />
+
+                  </Trigger>
+
+                  <Trigger Property="IsEnabled"
+                           Value="false">
+
+                     <Setter Property="Foreground"
+                             Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
+
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+
+            </ControlTemplate>
+
+         </Setter.Value>
+
+      </Setter>
+
+      <Style.Triggers>
+         <Trigger Property="IsVisible" Value="True">
+            <Setter Property="HorizontalContentAlignment"
+                    Value="{Binding Path=HorizontalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>
+            <Setter Property="VerticalContentAlignment"
+                    Value="{Binding Path=VerticalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>
+         </Trigger>
+      </Style.Triggers>
+   </Style>
+
+   <Style x:Key="DefaultItemContainerStyle"
+          TargetType="{x:Type ComboBoxItem}">
+
+      <Setter Property="Foreground"
+              Value="White" />
+
+      <Setter Property="Background"
+              Value="Transparent" />
+
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type ComboBoxItem}">
+               <Border x:Name="blackBorder"
+                       Background="{TemplateBinding Background}"
+                       BorderThickness="1"
+                       BorderBrush="{TemplateBinding BorderBrush}"
+                       CornerRadius="4">
+                  <Border x:Name="whiteBorder"
+                          Background="Transparent"
+                          BorderThickness="1"
+                          BorderBrush="Transparent"
+                          CornerRadius="3">
+                     <ContentPresenter />
+                  </Border>
+               </Border>
+
+               <ControlTemplate.Triggers>
+
+                  <Trigger Property="IsSelected"
+                           Value="True">
+                     <Setter TargetName="blackBorder"
+                             Property="BorderBrush"
+                             Value="{StaticResource basicBlackBorderBrush}" />
+                     <Setter TargetName="whiteBorder"
+                             Property="BorderBrush"
+                             Value="{StaticResource basicWhiteBorderBrush}" />
+                  </Trigger>
+
+               </ControlTemplate.Triggers>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+   <Style x:Key="aero2NormalColorRepeatButton"
+          TargetType="{x:Type RepeatButton}">
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type RepeatButton}"><Border Background="Transparent">
+                  <ContentPresenter x:Name="glyphZone">
+                     <ContentPresenter.Content>
+                        <Canvas x:Name="leftArrowCanvas"
+                                Height="11"
+                                Width="13">
+                           <Path Stroke="Black"
+                                 Data="M0.97,1.19 C1.97,0.00 12.08,0.00 12.96,1.19 C13.85,2.38 8.31,10.50 7.01,10.50 C5.72,10.50 0.00,2.38 0.97,1.19 z" />
+                           <Path Data="M1.91,1.80 C2.44,0.88 11.95,0.88 12.03,1.80 C12.81,2.04 7.55,9.73 7.01,9.46 C6.47,9.68 1.02,2.05 1.91,1.80 z">
+                              <Path.Fill>
+                                 <RadialGradientBrush>
+                                    <GradientStop Color="White"
+                                                  Offset="1" />
+                                    <GradientStop Offset="0.4" />
+                                 </RadialGradientBrush>
+                              </Path.Fill>
+                              <Path.Stroke>
+                                 <LinearGradientBrush EndPoint="0.5,1"
+                                                      StartPoint="0.5,0">
+                                    <GradientStop Color="White"
+                                                  Offset="0" />
+                                    <GradientStop Color="White"
+                                                  Offset="1" />
+                                    <GradientStop Offset="0.52" />
+                                 </LinearGradientBrush>
+                              </Path.Stroke>
+                           </Path>
+                        </Canvas>
+                     </ContentPresenter.Content>
+                  </ContentPresenter>
+               </Border>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+   <!--**************************
+    * Style: MenuItem(ContextMenu)
+    ************************** -->
+
+   <ControlTemplate x:Key="aero2NormalColorMenuItem"
+                    TargetType="{x:Type MenuItem}">
+      <Border>
+         <Grid>
+            <Grid.ColumnDefinitions>
+               <ColumnDefinition Width="Auto"
+                                 SharedSizeGroup="Icon" />
+               <ColumnDefinition Width="*" />
+               <ColumnDefinition Width="Auto"
+                                 SharedSizeGroup="Shortcut" />
+               <ColumnDefinition Width="13" />
+            </Grid.ColumnDefinitions>
+            <Border Name="Border"
+                    Margin="1"
+                    Grid.Column="0"
+                    Grid.ColumnSpan="4" />
+            <ContentPresenter Name="Icon"
+                              Margin="6,0,6,0"
+                              VerticalAlignment="Center"
+                              ContentSource="Icon" />
+            <Border Name="Check"
+                    Width="13"
+                    Height="13"
+                    Visibility="Collapsed"
+                    Margin="6,0,6,0"
+                    Background="Transparent"
+                    BorderThickness="1"
+                    BorderBrush="Transparent">
+               <Path Name="CheckMark"
+                     Visibility="Hidden"
+                     SnapsToDevicePixels="False"
+                     Fill="{StaticResource scrollbarGlyphBordeBrush}"
+                     Height="11"
+                     Width="10"
+                     Stretch="Fill"
+                     Opacity="1"
+                     Data="M 9.58416748046875,0 C9.58416748046875,0 10,0.6159515380859375 10,0.6159515380859375 8.7657470703125,1.540008544921875 8.419189453125,2.9010162353515625 6.96038818359375,4.698974609375 5.5015869140625,6.4969329833984375 4.602294921875,9.774444580078125 4.602294921875,9.774444580078125 4.602294921875,9.774444580078125 3.9029541015625,10.2296142578125 3.9029541015625,10.2296142578125 3.419921875,10.55328369140625 3.01983642578125,10.810089111328125 2.70257568359375,11 2.581787109375,10.676483154296875 2.114166259765625,9.48345947265625 1.46875,8.5 0.8125,7.5 0.4044189453125,6.9029998779296875 0,6.7393035888671875 0.667236328125,5.9750518798828125 1.8385009765625,5.592926025390625 1.8385009765625,5.592926025390625 1.8385009765625,5.592926025390625 3.555908203125,7.8286285400390625 3.555908203125,7.8286285400390625 4.3878173828125,6.349609375 4.5516357421875,4.8782501220703125 6.04742431640625,3.4145355224609375 7.543212890625,1.9508209228515625 8.055419921875,0.8126373291015625 9.58416748046875,0 z" />
+            </Border>
+            <ContentPresenter Name="HeaderHost"
+                              Grid.Column="1"
+                              VerticalAlignment="Center"
+                              ContentSource="Header"
+                              RecognizesAccessKey="True" />
+            <TextBlock x:Name="InputGestureText"
+                       Grid.Column="2"
+                       Text="{TemplateBinding InputGestureText}"
+                       Margin="5,2,0,2"
+                       DockPanel.Dock="Right" />
+         </Grid>
+      </Border>
+      <ControlTemplate.Triggers>
+         <Trigger Property="Icon"
+                  Value="{x:Null}">
+            <Setter TargetName="Icon"
+                    Property="Visibility"
+                    Value="Hidden" />
+         </Trigger>
+         <Trigger Property="IsChecked"
+                  Value="true">
+            <Setter TargetName="CheckMark"
+                    Property="Visibility"
+                    Value="Visible" />
+         </Trigger>
+         <Trigger Property="IsCheckable"
+                  Value="true">
+            <Setter TargetName="Check"
+                    Property="Visibility"
+                    Value="Visible" />
+            <Setter TargetName="Icon"
+                    Property="Visibility"
+                    Value="Hidden" />
+         </Trigger>
+         <Trigger Property="IsEnabled"
+                  Value="false">
+            <Setter Property="Foreground"
+                    Value="#DADADA" />
+         </Trigger>
+         <Trigger Property="IsMouseOver"
+                  Value="True">
+            <Setter TargetName="Border"
+                    Property="Background"
+                    Value="#FF86E9F9" />
+            <Setter TargetName="CheckMark"
+                    Property="Fill"
+                    Value="Black" />
+            <Setter Property="TextElement.Foreground"
+                    Value="Black" />
+         </Trigger>
+      </ControlTemplate.Triggers>
+   </ControlTemplate>
+
+   <MenuScrollingVisibilityConverter x:Key="MenuScrollingVisibilityConverter" />
+
+   <!--**************************
+    * Style: MenuItemScrollViewer (ContextMenu)
+    ************************** -->
+
+   <Style x:Key="MenuItemScrollViewer"
+          TargetType="{x:Type ScrollViewer}">
+
+      <Setter Property="VerticalScrollBarVisibility"
+              Value="Auto" />
+
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type ScrollViewer}">
+               <Grid>
+                  <Grid.RowDefinitions>
+                     <RowDefinition Height="15" />
+                     <RowDefinition Height="*" />
+                     <RowDefinition Height="15" />
+                  </Grid.RowDefinitions>
+
+                  <ScrollContentPresenter Grid.RowSpan="3" />
+                  <RepeatButton x:Name="topRepeatButton"
+                                Height="15"
+                                Style="{StaticResource increaseDecreaseRepeatButtonAero2NormalColor}"
+                                Command="ScrollBar.LineUpCommand"
+                                ClickMode="Hover"
+                                Grid.Row="0">
+                     <Grid	Height="10"
+                           Width="5"
+                           HorizontalAlignment="Center"
+                           VerticalAlignment="Center">
+                        <Canvas Width="9"
+                                Height="5">
+                           <Path Opacity="1"
+                                 Data="M 4.53125,0.15625 C4.53125,0.15625 9,5 9,5 9,5 0,5 0,5 0,5 4.53125,0.15625 4.53125,0.15625 z"
+                                 Fill="{StaticResource glyphDefaultBordeBrush}" />
+                        </Canvas>
+
+                     </Grid>
+                     <RepeatButton.Visibility>
+                        <MultiBinding FallbackValue="Visibility.Collapsed"
+                                      Converter="{StaticResource MenuScrollingVisibilityConverter}"
+                                      ConverterParameter="0">
+                           <Binding Path="ComputedVerticalScrollBarVisibility"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                           <Binding Path="VerticalOffset"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                           <Binding Path="ExtentHeight"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                           <Binding Path="ViewportHeight"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                        </MultiBinding>
+                     </RepeatButton.Visibility>
+                  </RepeatButton>
+
+                  <RepeatButton x:Name="bottomRepeatButton"
+                                Height="15"
+                                Style="{StaticResource increaseDecreaseRepeatButtonAero2NormalColor}"
+                                Command="ScrollBar.LineDownCommand"
+                                ClickMode="Hover"
+                                Grid.Row="2">
+                     <RepeatButton.Visibility>
+                        <MultiBinding FallbackValue="Visibility.Collapsed"
+                                      Converter="{StaticResource MenuScrollingVisibilityConverter}"
+                                      ConverterParameter="100">
+                           <Binding Path="ComputedVerticalScrollBarVisibility"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                           <Binding Path="VerticalOffset"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                           <Binding Path="ExtentHeight"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                           <Binding Path="ViewportHeight"
+                                    RelativeSource="{RelativeSource TemplatedParent}" />
+                        </MultiBinding>
+                     </RepeatButton.Visibility>
+                     <Grid	Height="10"
+                           Width="5"
+                           RenderTransformOrigin="0.5,0.5"
+                           HorizontalAlignment="Center"
+                           VerticalAlignment="Center">
+                        <Canvas Width="9"
+                                Height="5">
+                           <Path Opacity="1"
+                                 Data="M 4.53125,0.15625 C4.53125,0.15625 9,5 9,5 9,5 0,5 0,5 0,5 4.53125,0.15625 4.53125,0.15625 z"
+                                 Fill="{StaticResource glyphDefaultBordeBrush}" />
+                        </Canvas>
+                        <Grid.RenderTransform>
+                           <RotateTransform Angle="180" />
+                        </Grid.RenderTransform>
+                     </Grid>
+                  </RepeatButton>
+               </Grid>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+</ResourceDictionary>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Resources.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Resources.xaml
index 5d1ef1c9..e67ffca5 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Resources.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/Aero2.normalcolor.Resources.xaml
@@ -21,29 +21,29 @@
    <SolidColorBrush x:Key="gridLineBrush"
                     Color="Gray" />
 
-    <LinearGradientBrush x:Key="errorBackgroundBrush"
+   <LinearGradientBrush x:Key="errorBackgroundBrush"
                         EndPoint="0.5,1"
                         StartPoint="0.5,0">
-        <GradientStop Color="#FFF69898"
+      <GradientStop Color="#FFF69898"
                     Offset="1" />
-        <GradientStop Color="Red" />
-    </LinearGradientBrush>
+      <GradientStop Color="Red" />
+   </LinearGradientBrush>
 
-    <SolidColorBrush x:Key="errorForegroundBrush"
+   <SolidColorBrush x:Key="errorForegroundBrush"
                     Color="White" />
 
-    <SolidColorBrush x:Key="dropMarkBrush"
+   <SolidColorBrush x:Key="dropMarkBrush"
                     Color="#FFC4E5F6" />
 
-    <!-- Pen that is used to draw the drop mark when a ColumnHeader is dragged over another one. -->
-    <Pen x:Key="dropMarkPen"
+   <!-- Pen that is used to draw the drop mark when a ColumnHeader is dragged over another one. -->
+   <Pen x:Key="dropMarkPen"
         Brush="{StaticResource dropMarkBrush}"
         Thickness="7" />
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: ScrollTip
     ************************** -->
-    <ControlTemplate x:Key="scrollTipTemplate"
+   <ControlTemplate x:Key="scrollTipTemplate"
                     TargetType="{x:Type local:ScrollTip}">
 
         <Grid VerticalAlignment="{TemplateBinding VerticalAlignment}"
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/TableView.Aero2.normalcolor.Graphics.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/TableView.Aero2.normalcolor.Graphics.xaml
index bdd03b47..317bdc16 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/TableView.Aero2.normalcolor.Graphics.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/Resources/TableView.Aero2.normalcolor.Graphics.xaml
@@ -17,24 +17,24 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
-    <ResourceDictionary.MergedDictionaries>
+   <ResourceDictionary.MergedDictionaries>
 
-        <!-- Include the standard graphics -->
-        <utils:XceedResourceDictionary XceedSource="/Xceed.Wpf.DataGrid;component\themes/Common/Graphics.xaml" />
+      <!-- Include the standard graphics -->
+      <markup:DataGridThemeResourceDictionary Source="../../Common/Graphics.xaml" />
 
-        <!-- Needs Windows8 Resources -->
-        <ResourceDictionary Source="Aero2.normalcolor.Resources.xaml" />
+      <!-- Needs Windows8 Resources -->
+      <markup:DataGridThemeResourceDictionary Source="Aero2.NormalColor.Resources.xaml" />
 
-    </ResourceDictionary.MergedDictionaries>
+   </ResourceDictionary.MergedDictionaries>
 
-    <DataTemplate x:Key="editingRowGlyph">
-        <Grid Height="14"
+   <DataTemplate x:Key="editingRowGlyph">
+      <Grid Height="14"
             Width="14"
             HorizontalAlignment="Left"
             VerticalAlignment="Top">
-            <Path Margin="1.096,0.056,0,0"
+         <Path Margin="1.096,0.056,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="13.743"
@@ -45,7 +45,7 @@
                Stroke="#FF002647"
                StrokeThickness="1"
                Fill="#FF002647" />
-            <Path Margin="1.293,8.281,0,0"
+         <Path Margin="1.293,8.281,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="5.358"
@@ -53,21 +53,21 @@
                Stretch="Fill"
                Opacity="1"
                Data="M1.5429214,15.130966 C1.5429214,15.130966 6.4629087,12.423883 6.4629087,12.423883 6.4629087,12.423883 5.3522882,10.021933 5.3522882,10.021933 5.3522882,10.021933 3.3217649,9.7752304 3.3217649,9.7752304 3.3217649,9.7752304 1.5429214,15.130966 1.5429214,15.130966 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.1846440410613174,0.5041270477469605"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.1846440410613174,0.5041270477469605"
                                     GradientOrigin="0.1846440410613174,0.5041270477469605"
                                     RadiusX="0.8296137405478166"
                                     RadiusY="1.6531750098768538">
-                        <GradientStop Color="#FFffcc99"
+                  <GradientStop Color="#FFffcc99"
                                 Offset="0" />
-                        <GradientStop Color="#FF9B6803"
+                  <GradientStop Color="#FF9B6803"
                                 Offset="0.9611110091209412" />
-                        <GradientStop Color="#FF996600"
+                  <GradientStop Color="#FF996600"
                                 Offset="0.9833329916000366" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="3.11,0.456,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="3.11,0.456,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="10.534"
@@ -75,21 +75,21 @@
                Stretch="Fill"
                Opacity="1"
                Data="M3.358902,9.9091635 C3.358902,9.9091635 3.6575527,10.98584 3.6575527,10.98584 3.6575527,10.98584 5.017499,10.948517 5.017499,10.948517 5.017499,10.948517 5.2315655,12.080843 5.2315655,12.080843 5.2315655,12.080843 6.338026,12.48374 6.338026,12.48374 6.338026,12.48374 13.62499,4.3498156 13.62499,4.3498156 13.62499,4.3498156 10.224961,1.9498379 10.224961,1.9498379 10.224961,1.9498379 3.358902,9.9091635 3.358902,9.9091635 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.042813071747018726,0.8175057001256929"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.042813071747018726,0.8175057001256929"
                                     GradientOrigin="0.042813071747018726,0.8175057001256929"
                                     RadiusX="0.9929616115052466"
                                     RadiusY="0.8117382454245395">
-                        <GradientStop Color="#FF0099cc"
+                  <GradientStop Color="#FF0099cc"
                                 Offset="0" />
-                        <GradientStop Color="#FF003568"
+                  <GradientStop Color="#FF003568"
                                 Offset="0.9277780055999756" />
-                        <GradientStop Color="#FF003366"
+                  <GradientStop Color="#FF003366"
                                 Offset="0.949999988079071" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="8.369,0.621,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="8.369,0.621,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="4.404"
@@ -97,21 +97,21 @@
                Stretch="Fill"
                Opacity="1"
                Data="M 8.618328094482422,4.025081634521484 C8.618328094482422,4.025081634521484 11.708536148071289,6.519054412841797 11.708536148071289,6.519054412841797 11.708536148071289,6.519054412841797 13.288734436035156,4.586820602416992 13.288734436035156,4.586820602416992 13.288734436035156,4.586820602416992 12.757492065429688,4.055429458618164 11.856122016906738,3.315974235534668 10.961745262145996,2.5823020935058594 10.229959487915039,2.1148900985717773 10.229959487915039,2.1148900985717773 10.229959487915039,2.1148900985717773 8.618328094482422,4.025081634521484 8.618328094482422,4.025081634521484 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.5311699810261868,0.2591244756232053"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.5311699810261868,0.2591244756232053"
                                     GradientOrigin="0.5311699810261868,0.2591244756232053"
                                     RadiusX="0.49560300869019297"
                                     RadiusY="0.5788496774454529">
-                        <GradientStop Color="#FFc27a72"
+                  <GradientStop Color="#FFc27a72"
                                 Offset="0" />
-                        <GradientStop Color="#FF80340D"
+                  <GradientStop Color="#FF80340D"
                                 Offset="0.9333329796791077" />
-                        <GradientStop Color="#FF7f330b"
+                  <GradientStop Color="#FF7f330b"
                                 Offset="0.9555559754371643" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="5.935,4.5,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="5.935,4.5,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="3.482"
@@ -119,21 +119,21 @@
                Stretch="Fill"
                Opacity="1"
                Data="M 6.812163352966309,5.993573188781738 C6.812163352966309,5.993573188781738 6.1839494705200195,6.777921676635742 6.1839494705200195,6.777921676635742 6.1839494705200195,6.777921676635742 6.947524070739746,7.232476234436035 7.835901260375977,7.975306510925293 8.719582557678223,8.714177131652832 9.381957054138184,9.475302696228027 9.381957054138184,9.475302696228027 9.381957054138184,9.475302696228027 10.11921501159668,8.657419204711914 10.11921501159668,8.657419204711914 10.11921501159668,8.657419204711914 9.420568466186523,7.980251312255859 8.501447677612305,7.22212028503418 7.565184593200684,6.44985294342041 6.812163352966309,5.993573188781738 6.812163352966309,5.993573188781738 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.9697059803583005,0.2890594484912862"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.9697059803583005,0.2890594484912862"
                                     GradientOrigin="0.9697059803583005,0.2890594484912862"
                                     RadiusX="0.5364282834670617"
                                     RadiusY="0.7586126771411669">
-                        <GradientStop Color="#FFcccccc"
+                  <GradientStop Color="#FFcccccc"
                                 Offset="0" />
-                        <GradientStop Color="#FF686868"
+                  <GradientStop Color="#FF686868"
                                 Offset="0.9333329796791077" />
-                        <GradientStop Color="#FF666666"
+                  <GradientStop Color="#FF666666"
                                 Offset="0.9555559754371643" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="7.812,2.405,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="7.812,2.405,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="3.228"
@@ -141,21 +141,21 @@
                Stretch="Fill"
                Opacity="1"
                Data="M 8.530866622924805,3.898571014404297 C8.530866622924805,3.898571014404297 8.061341285705566,4.433980941772461 8.061341285705566,4.433980941772461 8.061341285705566,4.433980941772461 8.838849067687988,4.981285095214844 9.74392318725586,5.693037033081055 10.656047821044922,6.410333633422852 11.378190040588379,7.126607894897461 11.378190040588379,7.126607894897461 11.378190040588379,7.126607894897461 11.849910736083984,6.556713104248047 11.849910736083984,6.556713104248047 11.849910736083984,6.556713104248047 11.032713890075684,5.833953857421875 10.199588775634766,5.140911102294922 9.271937370300293,4.369194984436035 8.530866622924805,3.898571014404297 8.530866622924805,3.898571014404297 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.43447986118925047,0.28248733618880884"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.43447986118925047,0.28248733618880884"
                                     GradientOrigin="0.43447986118925047,0.28248733618880884"
                                     RadiusX="0.5308935530282759"
                                     RadiusY="0.40372149053823364">
-                        <GradientStop Color="#FFcccccc"
+                  <GradientStop Color="#FFcccccc"
                                 Offset="0" />
-                        <GradientStop Color="#FF686868"
+                  <GradientStop Color="#FF686868"
                                 Offset="0.9333329796791077" />
-                        <GradientStop Color="#FF666666"
+                  <GradientStop Color="#FF666666"
                                 Offset="0.9555559754371643" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="6.71,3.179,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="6.71,3.179,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="3.808"
@@ -163,21 +163,21 @@
                Stretch="Fill"
                Opacity="1"
                Data="M 6.95892333984375,5.76214599609375 C6.95892333984375,5.76214599609375 7.862613677978516,4.672874450683594 7.862613677978516,4.672874450683594 7.862613677978516,4.672874450683594 9.588410377502441,5.925745964050293 9.588410377502441,5.925745964050293 9.588410377502441,5.925745964050293 11.188949584960938,7.379446983337402 11.188949584960938,7.379446983337402 11.188949584960938,7.379446983337402 10.28754997253418,8.480874061584473 10.28754997253418,8.480874061584473 10.28754997253418,8.480874061584473 9.755718231201172,8.000542640686035 8.876455307006836,7.2333221435546875 8.004179000854492,6.472166061401367 6.95892333984375,5.76214599609375 6.95892333984375,5.76214599609375 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.5568233057618706,0.276759169912574"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.5568233057618706,0.276759169912574"
                                     GradientOrigin="0.5568233057618706,0.276759169912574"
                                     RadiusX="0.5647990057810927"
                                     RadiusY="0.7719788210009958">
-                        <GradientStop Color="#FFcccccc"
+                  <GradientStop Color="#FFcccccc"
                                 Offset="0" />
-                        <GradientStop Color="#FF686868"
+                  <GradientStop Color="#FF686868"
                                 Offset="0.9333329796791077" />
-                        <GradientStop Color="#FF666666"
+                  <GradientStop Color="#FF666666"
                                 Offset="0.9555559754371643" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="0.875,0.756,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="0.875,0.756,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="13.438"
@@ -185,23 +185,23 @@
                Stretch="Fill"
                Opacity="1"
                Data="M11.12455,2.9497099 C10.796974,2.7020817 10.224615,2.2496935 10.224615,2.2496935 10.224615,2.2496935 3.2972279,9.9386616 3.2972279,9.9386616 3.2972279,9.9386616 1.1238382,15.688009 1.1238382,15.688009 1.1238382,15.688009 3.925,10.15 3.925,10.15 3.925,10.15 11.144807,2.9650784 11.12455,2.9497099 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.2340284913609595,0.40941221543697837"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.2340284913609595,0.40941221543697837"
                                     GradientOrigin="0.2340284913609595,0.40941221543697837"
                                     RadiusX="1.1828655482909158"
                                     RadiusY="2.5474404245883986">
-                        <GradientStop Color="#FF000000"
+                  <GradientStop Color="#FF000000"
                                 Offset="0" />
-                        <GradientStop Color="#00000000"
+                  <GradientStop Color="#00000000"
                                 Offset="0.005555999930948019" />
-                        <GradientStop Color="#14000000"
+                  <GradientStop Color="#14000000"
                                 Offset="0.9055560231208801" />
-                        <GradientStop Color="#16000000"
+                  <GradientStop Color="#16000000"
                                 Offset="0.949999988079071" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="3.199,0.656,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="3.199,0.656,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="8.627"
@@ -209,21 +209,21 @@
                Stretch="Fill"
                Opacity="1"
                Data="M10.225209,2.1494628 C10.225209,2.1494628 13.525206,4.6493671 13.525206,4.6493671 13.525206,4.6493671 12.226868,4.0539665 9.625,5.75 7.0231352,7.4460325 6.0014434,11.71711 3.5866861,10.589012 2.3121116,9.9935741 10.225209,2.1494628 10.225209,2.1494628 z">
-                <Path.Fill>
-                    <RadialGradientBrush Center="0.6033051568848984,0.41797103154667026"
+            <Path.Fill>
+               <RadialGradientBrush Center="0.6033051568848984,0.41797103154667026"
                                     GradientOrigin="0.6033051568848984,0.41797103154667026"
                                     RadiusX="1.710308509229654"
                                     RadiusY="1.4486240697822559">
-                        <GradientStop Color="#19ffffff"
+                  <GradientStop Color="#19ffffff"
                                 Offset="0" />
-                        <GradientStop Color="#7Cffffff"
+                  <GradientStop Color="#7Cffffff"
                                 Offset="0.9611110091209412" />
-                        <GradientStop Color="#7fffffff"
+                  <GradientStop Color="#7fffffff"
                                 Offset="0.9833329916000366" />
-                    </RadialGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="0.751,0.756,0,0"
+               </RadialGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="0.751,0.756,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="13.75"
@@ -231,17 +231,17 @@
                Stretch="Fill"
                Opacity="1"
                Data="M1.9540095,14.851641 C1.9540095,14.851641 3.7059202,10.445454 3.7059202,10.445454 3.7059202,10.445454 10.325357,2.9334286 10.325357,2.9334286 10.325357,2.9334286 12.725009,4.7499978 12.725009,4.7499978 12.725009,4.7499978 5.9621078,12.390781 5.9621078,12.390781 5.9621078,12.390781 1.9540095,14.851641 1.9540095,14.851641 z M13.575486,4.6500827 C13.575486,4.6500827 10.225351,2.2501002 10.225351,2.2501002 10.225351,2.2501002 3.2102799,10.065701 3.2102799,10.065701 3.2102799,10.065701 1,16 1,16 1,16 6.3704149,12.607931 6.3704149,12.607931 6.3704149,12.607931 13.575486,4.6500827 13.575486,4.6500827 z">
-                <Path.Fill>
-                    <LinearGradientBrush StartPoint="0.9663513767662231,-0.10391423000415648"
+            <Path.Fill>
+               <LinearGradientBrush StartPoint="0.9663513767662231,-0.10391423000415648"
                                     EndPoint="0.08183985805967778,0.8771993466412239">
-                        <GradientStop Color="#7fffffff"
+                  <GradientStop Color="#7fffffff"
                                 Offset="0" />
-                        <GradientStop Color="#00ffffff"
+                  <GradientStop Color="#00ffffff"
                                 Offset="0.9888889789581299" />
-                    </LinearGradientBrush>
-                </Path.Fill>
-            </Path>
-            <Path Margin="1.362,11.619,0,0"
+               </LinearGradientBrush>
+            </Path.Fill>
+         </Path>
+         <Path Margin="1.362,11.619,0,0"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                Height="2.025"
@@ -250,7 +250,7 @@
                Opacity="1"
                Data="M1.8887157,13.610427 C1.8887157,13.610427 1.1334019,15.475085 1.3031181,15.624239 1.4731229,15.773591 3.2897057,14.507758 3.2897057,14.507758 3.2897057,14.507758 1.8887157,13.610427 1.8887157,13.610427 z"
                Fill="#000000" />
-        </Grid>
-    </DataTemplate>
+      </Grid>
+   </DataTemplate>
 
 </ResourceDictionary>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableView.Aero2.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableView.Aero2.normalcolor.xaml
new file mode 100644
index 00000000..8300c726
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableView.Aero2.normalcolor.xaml
@@ -0,0 +1,45 @@
+<!--***********************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  **********************************************************************************-->
+
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:s="clr-namespace:System;assembly=mscorlib"
+                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
+                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
+
+   <ResourceDictionary.MergedDictionaries>
+
+      <!-- Include the view independant, color-scheme independant, theme resources -->
+      <markup:DataGridThemeResourceDictionary Source="Resources/Aero2.normalcolor.Resources.xaml" />
+
+      <!-- Include the view dependant, color-scheme independant, theme graphics -->
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Aero2.normalcolor.Graphics.xaml" />
+
+      <!-- Include the standard grid element templates -->
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+
+      <!-- Control Styles used in the Grid Control -->
+      <markup:DataGridThemeResourceDictionary Source="Resources/Aero2.normalcolor.Controls.xaml" />
+
+   </ResourceDictionary.MergedDictionaries>
+
+   <!-- =================================================================== -->
+   <!-- Resources specific to this View/Theme/ColorScheme                   -->
+   <!-- =================================================================== -->
+
+</ResourceDictionary>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableflowView.Aero2.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableflowView.Aero2.normalcolor.xaml
index cfe830f3..ac126581 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableflowView.Aero2.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Aero2/TableflowView.Aero2.normalcolor.xaml
@@ -20,124 +20,132 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
-    <ResourceDictionary.MergedDictionaries>
+   <ResourceDictionary.MergedDictionaries>
 
-        <!-- Include the view independant, color-scheme independant, theme resources -->
-        <ResourceDictionary Source="Resources/Aero2.normalcolor.Resources.xaml" />
+      <!-- Include the view independant, color-scheme independant, theme resources -->
+      <markup:DataGridThemeResourceDictionary Source="Resources/Aero2.NormalColor.Resources.xaml" />
 
-        <!-- Include the view dependant, color-scheme independant, theme graphics -->
-        <ResourceDictionary Source="Resources/TableView.Aero2.normalcolor.Graphics.xaml" />
+      <!-- Include the view dependant, color-scheme independant, theme graphics -->
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Aero2.NormalColor.Graphics.xaml" />
 
-        <!-- Include the standard grid element templates -->
-        <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <!-- Include the standard grid element templates -->
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
+      <!-- Control Styles used in the Grid Control -->
+      <!-- TODO : for now do not use Aero2.NormalColor.Controls.xaml (see case 153892)  -->
+      <!--<markup:DataGridThemeResourceDictionary Source="Resources/Aero2.NormalColor.Controls.xaml" />-->
 
-    </ResourceDictionary.MergedDictionaries>
+   </ResourceDictionary.MergedDictionaries>
 
-    <SolidColorBrush x:Key="warningBackgroundBrush"
+   <SolidColorBrush x:Key="warningBackgroundBrush"
                     Color="#FFC400" />
 
-    <SolidColorBrush x:Key="warningForegroundBrush"
+   <SolidColorBrush x:Key="warningForegroundBrush"
                     Color="Black" />
 
-    <!-- ****************************************** -->
-    <!-- Windows8 Font                              -->
-    <!-- ****************************************** -->
+   <!-- ****************************************** -->
+   <!-- Windows8 Font                              -->
+   <!-- ****************************************** -->
 
-    <FontFamily x:Key="defaultFontFamily">Segoe UI</FontFamily>
-    <s:Double x:Key="defaultFontSize">12</s:Double>
+   <FontFamily x:Key="defaultFontFamily">Segoe UI</FontFamily>
+   <s:Double x:Key="defaultFontSize">12</s:Double>
 
-    <!-- ****************************************** -->
-    <!--  Windows8 Color Scheme                     -->
-    <!-- ****************************************** -->
+   <!-- ****************************************** -->
+   <!--  Windows8 Color Scheme                     -->
+   <!-- ****************************************** -->
 
-    <!-- Default -->
-    <SolidColorBrush x:Key="defaultBackgroundBrush"
+   <!-- Default -->
+   <SolidColorBrush x:Key="defaultBackgroundBrush"
                     Color="White" />
-    <SolidColorBrush x:Key="defaultForegroundBrush"
+   <SolidColorBrush x:Key="defaultForegroundBrush"
                     Color="#FF151C55" />
 
-    <!-- DataGridControl -->
-    <SolidColorBrush x:Key="gridBorderBrush"
+   <!-- DataGridControl -->
+   <SolidColorBrush x:Key="gridBorderBrush"
                     Color="#FF5284BC" />
 
-    <!-- ColumnManagerCell -->
-    <LinearGradientBrush x:Key="columnManagerCellBackgroundBrush"
+   <!-- ColumnManagerCell -->
+   <LinearGradientBrush x:Key="columnManagerCellBackgroundBrush"
                         StartPoint="0,0"
                         EndPoint="0,1">
-        <GradientStop Color="#FFF0F0F0"
+      <GradientStop Color="#FFF0F0F0"
                     Offset="0.0" />
-        <GradientStop Color="#FFE5E5E5"
+      <GradientStop Color="#FFE5E5E5"
                     Offset="1.0" />
-    </LinearGradientBrush>
-    <SolidColorBrush x:Key="columnManagerCellMouseOverBackgroundBrush"
+   </LinearGradientBrush>
+   <SolidColorBrush x:Key="columnManagerCellMouseOverBackgroundBrush"
                     Color="#FFBEE6FD" />
-    <SolidColorBrush x:Key="columnManagerCellPressedBackgroundBrush"
+   <SolidColorBrush x:Key="columnManagerCellPressedBackgroundBrush"
                     Color="#FFC4E5F6" />
 
-    <!-- DataRow -->
-    <SolidColorBrush x:Key="rowBackgroundBrush"
+   <!-- DataRow -->
+   <SolidColorBrush x:Key="rowBackgroundBrush"
                     Color="White" />
-    <SolidColorBrush x:Key="rowAlternatingBackgroundBrush"
+   <SolidColorBrush x:Key="rowAlternatingBackgroundBrush"
                     Color="#FFF7F7F7" />
-    <SolidColorBrush x:Key="rowSelectionBackgroundBrush"
+   <!-- TODO : determine the alternate row background color -->
+   <SolidColorBrush x:Key="rowSelectionBackgroundBrush"
                     Color="#FFCBE8F6" />
-    <SolidColorBrush x:Key="rowMouseOverBackgroundBrush"
+   <SolidColorBrush x:Key="rowMouseOverBackgroundBrush"
                     Color="#FFE5F3FB" />
-    <SolidColorBrush x:Key="rowMouseOverSelectionBackgroundBrush"
+   <SolidColorBrush x:Key="rowMouseOverSelectionBackgroundBrush"
                     Color="#FFD1E8FF" />
-    <SolidColorBrush x:Key="rowInactiveSelectionBackgroundBrush"
+   <SolidColorBrush x:Key="rowInactiveSelectionBackgroundBrush"
                     Color="#FFF7F7F7" />
 
-    <!-- Groups -->
-    <SolidColorBrush x:Key="groupByControlBackgroundBrush"
+   <!-- DataRow Borders (if we implement this behavior) -->
+   <!--<SolidColorBrush x:Key="rowSelectionBorderBrush" Color="#FF26A0DA" />-->
+   <!--<SolidColorBrush x:Key="rowMouseOverBorderBrush" Color="#FF70C0E7" />-->
+   <!--<SolidColorBrush x:Key="rowMouseOverSelectionBorderBrush" Color="#FF66A7E8" />-->
+   <!--<SolidColorBrush x:Key="rowInactiveSelectionBorderBrush" Color="#FFDEDEDE" />-->
+
+   <!-- Groups -->
+   <SolidColorBrush x:Key="groupByControlBackgroundBrush"
                     Color="Gray" />
-    <SolidColorBrush x:Key="groupLevelIndicatorBackgroundBrush"
+   <SolidColorBrush x:Key="groupLevelIndicatorBackgroundBrush"
                     Color="#FFDFE7F2" />
-    <LinearGradientBrush x:Key="groupHeaderBackgroundBrush"
+   <LinearGradientBrush x:Key="groupHeaderBackgroundBrush"
                         StartPoint="0,0"
                         EndPoint="0,1">
-        <GradientStop Color="#FFE9F1FC"
+      <GradientStop Color="#FFE9F1FC"
                     Offset="0.0" />
-        <GradientStop Color="#FFDFE7F2"
+      <GradientStop Color="#FFDFE7F2"
                     Offset="1.0" />
-    </LinearGradientBrush>
-
+   </LinearGradientBrush>
 
-    <!-- =================================================================== -->
-    <!-- Templates specific to this View/Theme/ColorScheme                   -->
-    <!-- =================================================================== -->
+   <!-- =================================================================== -->
+   <!-- Templates specific to this View/Theme/ColorScheme                   -->
+   <!-- =================================================================== -->
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: GroupNavigationControl
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewGroupNavigationControlTemplate"
+   <ControlTemplate x:Key="tableflowViewGroupNavigationControlTemplate"
                     TargetType="{x:Type local:GroupNavigationControl}">
 
-        <Grid>
-            <Border x:Name="outlineBorder"
+      <Grid>
+         <Border x:Name="outlineBorder"
                  Background="Transparent"
                  BorderBrush="{StaticResource defaultForegroundBrush}"
                  BorderThickness="1"
                  CornerRadius="1"
                  Opacity="0" />
 
-            <Grid>
-                <Grid.ColumnDefinitions>
-                    <!-- Button part -->
-                    <ColumnDefinition Width="*" />
+         <Grid>
+            <Grid.ColumnDefinitions>
+               <!-- Button part -->
+               <ColumnDefinition Width="*" />
 
-                    <!-- Seperator part -->
-                    <ColumnDefinition Width="Auto" />
+               <!-- Seperator part -->
+               <ColumnDefinition Width="Auto" />
 
-                    <!-- Toggle button part -->
-                    <ColumnDefinition Width="Auto" />
-                </Grid.ColumnDefinitions>
+               <!-- Toggle button part -->
+               <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
 
-                <Button x:Name="PART_Button"
+            <Button x:Name="PART_Button"
                     Command="local:GroupNavigationButton.NavigateToGroup"
                     CommandParameter="{TemplateBinding Group}"
                     Content="{TemplateBinding Group}"
@@ -146,280 +154,280 @@
                     Foreground="{TemplateBinding Foreground}"
                     Focusable="False"
                     Grid.Column="0">
-                    <Button.Template>
-                        <ControlTemplate TargetType="{x:Type Button}">
-                            <Border Background="Transparent">
-                                <ContentPresenter Margin="4,2,4,2" />
-                            </Border>
-                        </ControlTemplate>
-                    </Button.Template>
-                </Button>
-
-                <Border x:Name="seperator"
+               <Button.Template>
+                  <ControlTemplate TargetType="{x:Type Button}">
+                     <Border Background="Transparent">
+                        <ContentPresenter Margin="4,2,4,2" />
+                     </Border>
+                  </ControlTemplate>
+               </Button.Template>
+            </Button>
+
+            <Border x:Name="seperator"
                     Grid.Column="1"
                     BorderThickness="0,0,1,0"
                     BorderBrush="{StaticResource defaultForegroundBrush}"
                     Margin="0,4,0,4"
                     Visibility="Hidden" />
 
-                <ToggleButton x:Name="PART_ToggleButton"
+            <ToggleButton x:Name="PART_ToggleButton"
                           Focusable="False"
                           IsChecked="{Binding Path=IsDropDownOpen,Mode=TwoWay,RelativeSource={RelativeSource TemplatedParent}}"
                           Grid.Column="2"
                           Foreground="{TemplateBinding Foreground}">
-                    <ToggleButton.Template>
-                        <ControlTemplate>
-                            <Border x:Name="toggleButtonBackground"
+               <ToggleButton.Template>
+                  <ControlTemplate>
+                     <Border x:Name="toggleButtonBackground"
                              CornerRadius="0,6,6,0"
                              Background="Transparent">
-                                <Path x:Name="Arrow"
+                        <Path x:Name="Arrow"
                               Fill="{TemplateBinding Foreground}"
                               Margin="7,1,7,1"
                               HorizontalAlignment="Center"
                               VerticalAlignment="Center"
                               Data="M 0 0 L 4 4 L 0 8 Z"
                               Opacity="0.3" />
-                            </Border>
+                     </Border>
 
-                            <ControlTemplate.Triggers>
-                                <Trigger Property="ToggleButton.IsMouseOver"
+                     <ControlTemplate.Triggers>
+                        <Trigger Property="ToggleButton.IsMouseOver"
                                  Value="True">
-                                    <Setter TargetName="Arrow"
+                           <Setter TargetName="Arrow"
                                    Property="Opacity"
                                    Value="1" />
-                                </Trigger>
-                                <Trigger Property="ToggleButton.IsChecked"
+                        </Trigger>
+                        <Trigger Property="ToggleButton.IsChecked"
                                  Value="True">
-                                    <Setter TargetName="Arrow"
+                           <Setter TargetName="Arrow"
                                    Property="Opacity"
                                    Value="1" />
-                                    <Setter TargetName="Arrow"
+                           <Setter TargetName="Arrow"
                                    Property="Margin"
                                    Value="5,1,5,1" />
-                                    <Setter TargetName="Arrow"
+                           <Setter TargetName="Arrow"
                                    Property="Data"
                                    Value="M 0 0 L 4 4 L 8 0 Z" />
-                                </Trigger>
-                            </ControlTemplate.Triggers>
-                        </ControlTemplate>
-                    </ToggleButton.Template>
-                </ToggleButton>
-            </Grid>
+                        </Trigger>
+                     </ControlTemplate.Triggers>
+                  </ControlTemplate>
+               </ToggleButton.Template>
+            </ToggleButton>
+         </Grid>
 
-            <Popup x:Name="PART_Popup"
+         <Popup x:Name="PART_Popup"
                 Placement="Bottom"
                 IsOpen="{TemplateBinding IsDropDownOpen}"
                 AllowsTransparency="True"
                 Focusable="False"
                 PopupAnimation="Slide">
-                <Grid SnapsToDevicePixels="True"
+            <Grid SnapsToDevicePixels="True"
                   MinWidth="{TemplateBinding ActualWidth}"
                   MaxHeight="{TemplateBinding MaxDropDownHeight}">
-                    <Border Background="White"
+               <Border Background="White"
                        BorderBrush="Black"
                        BorderThickness="1"
                        TextElement.Foreground="Black">
-                        <ScrollViewer CanContentScroll="True"
+                  <ScrollViewer CanContentScroll="True"
                                 HorizontalScrollBarVisibility="Hidden"
                                 VerticalScrollBarVisibility="Auto">
-                            <!--<ItemsPresenter />-->
-                            <VirtualizingStackPanel IsItemsHost="True" />
-                        </ScrollViewer>
-                    </Border>
-                </Grid>
-            </Popup>
-        </Grid>
+                     <!--<ItemsPresenter />-->
+                     <VirtualizingStackPanel IsItemsHost="True" />
+                  </ScrollViewer>
+               </Border>
+            </Grid>
+         </Popup>
+      </Grid>
 
-        <ControlTemplate.Triggers>
-            <Trigger Property="IsMouseOver"
+      <ControlTemplate.Triggers>
+         <Trigger Property="IsMouseOver"
                   Value="True">
-                <Setter TargetName="outlineBorder"
+            <Setter TargetName="outlineBorder"
                     Property="Opacity"
                     Value="1" />
-                <Setter TargetName="seperator"
+            <Setter TargetName="seperator"
                     Property="Visibility"
                     Value="Visible" />
-            </Trigger>
+         </Trigger>
 
-            <Trigger Property="IsDropDownOpen"
+         <Trigger Property="IsDropDownOpen"
                   Value="True">
-                <Setter TargetName="outlineBorder"
+            <Setter TargetName="outlineBorder"
                     Property="Opacity"
                     Value="1" />
-                <Setter TargetName="seperator"
+            <Setter TargetName="seperator"
                     Property="Visibility"
                     Value="Visible" />
-            </Trigger>
-            <Trigger Property="IsEnabled"
+         </Trigger>
+         <Trigger Property="IsEnabled"
                   Value="False">
-                <Setter Property="Opacity"
+            <Setter Property="Opacity"
                     TargetName="outlineBorder"
                     Value="0" />
-            </Trigger>
-        </ControlTemplate.Triggers>
-    </ControlTemplate>
+         </Trigger>
+      </ControlTemplate.Triggers>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: GroupNavigationButton
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewGroupNavigationButtonTemplate"
+   <ControlTemplate x:Key="tableflowViewGroupNavigationButtonTemplate"
                     TargetType="{x:Type local:GroupNavigationButton}">
-        <Grid>
-            <Border x:Name="outerBorder"
+      <Grid>
+         <Border x:Name="outerBorder"
                  BorderBrush="{StaticResource defaultForegroundBrush}"
                  BorderThickness="1"
                  CornerRadius="1"
                  Opacity="0" />
 
-            <ContentPresenter Margin="4,2,4,2" />
-        </Grid>
-        <ControlTemplate.Triggers>
-            <Trigger Property="IsMouseOver"
+         <ContentPresenter Margin="4,2,4,2" />
+      </Grid>
+      <ControlTemplate.Triggers>
+         <Trigger Property="IsMouseOver"
                   Value="True">
-                <Setter Property="Opacity"
+            <Setter Property="Opacity"
                     TargetName="outerBorder"
                     Value="1" />
-            </Trigger>
-            <Trigger Property="IsEnabled"
+         </Trigger>
+         <Trigger Property="IsEnabled"
                   Value="False">
-                <Setter Property="Opacity"
+            <Setter Property="Opacity"
                     TargetName="outerBorder"
                     Value="0" />
-            </Trigger>
-        </ControlTemplate.Triggers>
-    </ControlTemplate>
+         </Trigger>
+      </ControlTemplate.Triggers>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: RowSelector 
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewRowSelectorTemplate"
+   <ControlTemplate x:Key="tableflowViewRowSelectorTemplate"
                     TargetType="local:RowSelector">
 
-        <!-- This Grid is used to position the resizer Thumb over the RowSelector -->
-        <Grid>
+      <!-- This Grid is used to position the resizer Thumb over the RowSelector -->
+      <Grid>
 
-            <Border Background="{TemplateBinding Background}"
+         <Border Background="{TemplateBinding Background}"
                  BorderBrush="{TemplateBinding BorderBrush}"
                  BorderThickness="{TemplateBinding BorderThickness}">
 
-                <!-- This Grid is used to layout the delimiter lines on top of the ContentPresenter -->
-                <Grid>
+            <!-- This Grid is used to layout the delimiter lines on top of the ContentPresenter -->
+            <Grid>
 
-                    <!-- This Border is used to apply the Padding around the ContentPresenter.
+               <!-- This Border is used to apply the Padding around the ContentPresenter.
                     We cannot use the ContentPresenter's Margin for this purpose because
                     the Margin is used to represent the Pressed state. -->
-                    <Border Padding="{TemplateBinding Padding}">
+               <Border Padding="{TemplateBinding Padding}">
 
-                        <ContentPresenter x:Name="contentPresenter"
+                  <ContentPresenter x:Name="contentPresenter"
                                     Content="{TemplateBinding Content}"
                                     ContentTemplate="{TemplateBinding ContentTemplate}"
                                     ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
                                     HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                                     VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                    </Border>
+               </Border>
 
-                    <!-- Bottom Line -->
-                    <Rectangle Fill="{StaticResource defaultForegroundBrush}"
+               <!-- Bottom Line -->
+               <Rectangle Fill="{StaticResource defaultForegroundBrush}"
                           HorizontalAlignment="Stretch"
                           VerticalAlignment="Top"
                           Height="1"
                           Margin="2,0,2,0" />
 
-                    <!-- Top Line -->
-                    <Rectangle x:Name="bottomBorder"
+               <!-- Top Line -->
+               <Rectangle x:Name="bottomBorder"
                           Fill="LightGray"
                           HorizontalAlignment="Stretch"
                           VerticalAlignment="Bottom"
                           Height="1"
                           Margin="2,0,2,0" />
-                </Grid>
-            </Border>
+            </Grid>
+         </Border>
 
-            <!-- Thumb that is used to resize the Row. -->
-            <Thumb x:Name="PART_RowResizerThumb"
+         <!-- Thumb that is used to resize the Row. -->
+         <Thumb x:Name="PART_RowResizerThumb"
                 Style="{StaticResource invisibleThumbStyle}"
                 VerticalAlignment="Bottom" />
 
-        </Grid>
+      </Grid>
 
-        <ControlTemplate.Triggers>
+      <ControlTemplate.Triggers>
 
-            <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
 
-                <Setter TargetName="bottomBorder"
+            <Setter TargetName="bottomBorder"
                     Property="Fill"
                     Value="LightGray" />
 
-            </DataTrigger>
+         </DataTrigger>
 
-        </ControlTemplate.Triggers>
+      </ControlTemplate.Triggers>
 
-    </ControlTemplate>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
-                    TargetType="local:ColumnManagerCell">
+    <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
 
+    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
+                     TargetType="local:ColumnManagerCell">
         <!-- This Grid is used to position the resizer Thumb over the ColumnManagerCell -->
         <Grid>
 
             <Border x:Name="rootBorder"
-                 Background="{TemplateBinding Background}"
-                 BorderBrush="{TemplateBinding BorderBrush}"
-                 BorderThickness="{TemplateBinding BorderThickness}">
+                    Background="{TemplateBinding Background}"
+                    BorderBrush="{TemplateBinding BorderBrush}"
+                    BorderThickness="{TemplateBinding BorderThickness}">
 
                 <Grid>
 
                     <Rectangle Fill="LightGray"
-                          HorizontalAlignment="Left"
-                          VerticalAlignment="Stretch"
-                          Width="1"
-                          Margin="0,2,0,2" />
+                               HorizontalAlignment="Left"
+                               VerticalAlignment="Stretch"
+                               Width="1"
+                               Margin="0,2,0,2" />
 
                     <Rectangle Fill="{StaticResource defaultForegroundBrush}"
-                          HorizontalAlignment="Right"
-                          VerticalAlignment="Stretch"
-                          Width="1"
-                          Margin="0,2,0,2" />
+                               HorizontalAlignment="Right"
+                               VerticalAlignment="Stretch"
+                               Width="1"
+                               Margin="0,2,0,2" />
 
                     <DockPanel>
                         <Border x:Name="thumbToggleBackgroundBorder"
-                          DockPanel.Dock="Right">
+                                DockPanel.Dock="Right">
 
                             <Grid>
 
                                 <Border x:Name="toggleDelimeterBorder"
-                                BorderBrush="{StaticResource defaultForegroundBrush}"
-                                BorderThickness="1,0,0,0"
-                                Margin="0,4,0,4"
-                                Background="Transparent"
-                                Visibility="Collapsed">
+                                        BorderBrush="{StaticResource defaultForegroundBrush}"
+                                        BorderThickness="1,0,0,0"
+                                        Margin="0,4,0,4"
+                                        Background="Transparent"
+                                        Visibility="Collapsed">
 
                                     <Border x:Name="toggleDelimeterBorder2"
-                                   BorderBrush="LightGray"
-                                   BorderThickness="1,0,0,0"
-                                   Margin="0,0,0,0"
-                                   Background="Transparent"
-                                   Visibility="Collapsed">
+                                            BorderBrush="LightGray"
+                                            BorderThickness="1,0,0,0"
+                                            Margin="0,0,0,0"
+                                            Background="Transparent"
+                                            Visibility="Collapsed">
 
                                     </Border>
                                 </Border>
 
                                 <Border x:Name="borderToggleBackground"
-                                Background="{TemplateBinding Background}"
-                                Margin="1,0,1,0" />
+                                        Background="{TemplateBinding Background}"
+                                        Margin="1,0,1,0" />
 
                                 <ToggleButton x:Name="toggleButton"
-                                      Focusable="False"
-                                      VerticalAlignment="Stretch"
-                                      Visibility="Collapsed"
-                                      Margin="2,0,0,0"
-                                      Opacity="0.5" />
-
+                                              Focusable="False"
+                                              VerticalAlignment="Stretch"
+                                              Visibility="Collapsed"
+                                              Margin="2,0,0,0"
+                                              Opacity="0.5" />
                             </Grid>
                         </Border>
 
@@ -431,24 +439,25 @@
                                 <Border Padding="{TemplateBinding Padding}">
 
                                     <Grid x:Name="contentPanel"
-                                 HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                 VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
+                                          HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                          VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
                                         <Grid.ColumnDefinitions>
                                             <ColumnDefinition Width="*" />
                                             <ColumnDefinition Width="Auto" />
+                                            <ColumnDefinition Width="Auto" />
                                         </Grid.ColumnDefinitions>
 
                                         <!-- Same ContentPresenter as in the base Cell Template. -->
                                         <local:CellContentPresenter x:Name="PART_CellContentPresenter"
-                                                          Grid.Column="0" />
+                                                                    Grid.Column="0" />
 
                                         <!-- ContentPresenter that is used to display the sort glyph.
-                                      We explicitely set its Content property to Null to prevent the XAML parser
-                                      from implicitely setting it to its TemplatedParent's Content. -->
+                                                We explicitely set its Content property to Null to prevent the XAML parser
+                                                from implicitely setting it to its TemplatedParent's Content. -->
                                         <ContentPresenter x:Name="sortGlyphPresenter"
-                                                Content="{x:Null}"
-                                                ContentTemplate="{x:Null}"
-                                                Grid.Column="1" />
+                                                          Grid.Column="1"
+                                                          Content="{x:Null}"
+                                                          ContentTemplate="{x:Null}" />
                                     </Grid>
                                 </Border>
                             </Grid>
@@ -459,15 +468,15 @@
 
             <!-- Thumb that is used to resize the Column. -->
             <Thumb x:Name="PART_ColumnResizerThumbLeft"
-                Style="{StaticResource invisibleThumbStyle}"
-                Width="6"
-                HorizontalAlignment="Left" />
+                   Style="{StaticResource invisibleThumbStyle}"
+                   Width="6"
+                   HorizontalAlignment="Left" />
 
             <!-- Thumb that is used to resize the Column. -->
             <Thumb x:Name="PART_ColumnResizerThumb"
-                Style="{StaticResource invisibleThumbStyle}"
-                Width="6"
-                HorizontalAlignment="Right" />
+                   Style="{StaticResource invisibleThumbStyle}"
+                   Width="6"
+                   HorizontalAlignment="Right" />
 
         </Grid>
 
@@ -477,123 +486,132 @@
             <MultiDataTrigger>
                 <MultiDataTrigger.Conditions>
                     <Condition Value="Visible"
-                          Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
+                               Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
                     <Condition Value="Center"
-                          Binding="{Binding RelativeSource={RelativeSource Self},
+                               Binding="{Binding RelativeSource={RelativeSource Self},
                         Path=HorizontalContentAlignment}" />
                 </MultiDataTrigger.Conditions>
 
                 <Setter TargetName="PART_CellContentPresenter"
-                    Property="Margin"
-                    Value="16,0,0,0" />
+                        Property="Margin"
+                        Value="16,0,0,0" />
             </MultiDataTrigger>
 
+            <!-- Trigger related to the filteringToggleButton-->
+            <Trigger SourceName="toggleButton"
+                     Property="IsMouseOver"
+                     Value="True">
+
+                <Setter TargetName="toggleButton"
+                        Property="Opacity"
+                        Value="1" />
+            </Trigger>
+
             <Trigger Property="IsBeingDragged"
-                  Value="True">
+                     Value="True">
 
                 <Setter TargetName="borderToggleBackground"
-                    Property="Margin"
-                    Value="0,0,1,0" />
+                        Property="Margin"
+                        Value="0,0,1,0" />
 
             </Trigger>
 
             <Trigger Property="IsPressed"
-                  Value="True">
+                     Value="True">
 
                 <!-- Change background color of cell when IsPressed -->
                 <Setter TargetName="rootBorder"
-                    Property="Background"
-                    Value="{StaticResource columnManagerCellPressedBackgroundBrush}" />
+                        Property="Background"
+                        Value="{StaticResource columnManagerCellPressedBackgroundBrush}" />
             </Trigger>
 
             <!-- Change background color of cell when MouseOver -->
             <MultiTrigger>
                 <MultiTrigger.Conditions>
                     <Condition Property="IsMouseOver"
-                          Value="True" />
+                               Value="True" />
                     <Condition Property="IsPressed"
-                          Value="False" />
+                               Value="False" />
                 </MultiTrigger.Conditions>
                 <Setter TargetName="rootBorder"
-                    Property="Background"
-                    Value="{StaticResource columnManagerCellMouseOverBackgroundBrush}" />
+                        Property="Background"
+                        Value="{StaticResource columnManagerCellMouseOverBackgroundBrush}" />
             </MultiTrigger>
 
             <!-- The following 2 triggers allow the appropriate Sort Glyph to be displayed
               depending on the ParentColumn's SortDirection. -->
 
             <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.SortDirection}"
-                      Value="Ascending">
+                         Value="Ascending">
 
                 <Setter TargetName="sortGlyphPresenter"
-                    Property="ContentPresenter.ContentTemplate"
-                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}" />
+                        Property="ContentPresenter.ContentTemplate"
+                        Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}" />
 
                 <Setter TargetName="sortGlyphPresenter"
-                    Property="Margin"
-                    Value="6,0,0,0" />
+                        Property="Margin"
+                        Value="6,0,0,0" />
 
             </DataTrigger>
 
             <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.SortDirection}"
-                      Value="Descending">
+                         Value="Descending">
 
                 <Setter TargetName="sortGlyphPresenter"
-                    Property="ContentPresenter.ContentTemplate"
-                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).DescendingSortGlyph}" />
+                        Property="ContentPresenter.ContentTemplate"
+                        Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).DescendingSortGlyph}" />
 
                 <Setter TargetName="sortGlyphPresenter"
-                    Property="Margin"
-                    Value="6,0,0,0" />
-
+                        Property="Margin"
+                        Value="6,0,0,0" />
             </DataTrigger>
 
             <MultiDataTrigger>
                 <MultiDataTrigger.Conditions>
                     <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.HasFixedWidth}"
-                          Value="True" />
+                               Value="True" />
 
                     <!-- Don't disable resizing if ColumnStretching can be disabled by an 
                     end-user resize. -->
                     <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).RemoveColumnStretchingOnResize}"
-                          Value="False" />
+                               Value="False" />
                 </MultiDataTrigger.Conditions>
 
                 <Setter TargetName="PART_ColumnResizerThumb"
-                    Property="IsEnabled"
-                    Value="False" />
+                        Property="IsEnabled"
+                        Value="False" />
             </MultiDataTrigger>
 
             <MultiDataTrigger>
                 <MultiDataTrigger.Conditions>
                     <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.PreviousVisibleColumn.HasFixedWidth}"
-                          Value="True" />
+                               Value="True" />
 
                     <!-- Don't disable resizing if ColumnStretching can be disabled by an 
                     end-user resize. -->
                     <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).RemoveColumnStretchingOnResize}"
-                          Value="False" />
+                               Value="False" />
                 </MultiDataTrigger.Conditions>
 
                 <Setter TargetName="PART_ColumnResizerThumbLeft"
-                    Property="IsEnabled"
-                    Value="False" />
+                        Property="IsEnabled"
+                        Value="False" />
             </MultiDataTrigger>
 
             <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=ParentRow.AllowColumnResize}"
-                      Value="False">
+                         Value="False">
                 <Setter TargetName="PART_ColumnResizerThumb"
-                    Property="IsEnabled"
-                    Value="False" />
+                        Property="IsEnabled"
+                        Value="False" />
                 <Setter TargetName="PART_ColumnResizerThumbLeft"
-                    Property="IsEnabled"
-                    Value="False" />
+                        Property="IsEnabled"
+                        Value="False" />
             </DataTrigger>
 
             <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.Visible}"
-                      Value="False">
+                         Value="False">
                 <Setter Property="Visibility"
-                    Value="Collapsed" />
+                        Value="Collapsed" />
             </DataTrigger>
 
         </ControlTemplate.Triggers>
@@ -603,186 +621,186 @@
     <!--**************************
     * TEMPLATE: GroupByItem
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewGroupByItemTemplate"
+   <ControlTemplate x:Key="tableflowViewGroupByItemTemplate"
                     TargetType="local:GroupByItem">
 
-        <Border x:Name="mainBorder"
+      <Border x:Name="mainBorder"
               Background="{TemplateBinding Background}"
               BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}"
               Padding="{TemplateBinding Padding}">
 
-            <!-- This StackPanel is used to layout the ContentPresenter and the Sort Glyph (when present). -->
-            <StackPanel Orientation="Horizontal">
+         <!-- This StackPanel is used to layout the ContentPresenter and the Sort Glyph (when present). -->
+         <StackPanel Orientation="Horizontal">
 
-                <!-- Same ContentPresenter as in the base Cell Template. -->
-                <ContentPresenter Content="{TemplateBinding Content}"
+            <!-- Same ContentPresenter as in the base Cell Template. -->
+            <ContentPresenter Content="{TemplateBinding Content}"
                               ContentTemplate="{TemplateBinding ContentTemplate}"
                               ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
                               HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                               VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                <!-- ContentPresenter that is used to display the sort glyph.
+            <!-- ContentPresenter that is used to display the sort glyph.
                  We explicitely set its Content property to Null to prevent the XAML parser
                  from implicitely setting it to its TemplatedParent's Content. -->
-                <ContentPresenter x:Name="sortGlyphPresenter"
+            <ContentPresenter x:Name="sortGlyphPresenter"
                               Content="{x:Null}"
                               ContentTemplate="{x:Null}"
                               Margin="15,0,0,0"
                               TextBlock.Foreground="{StaticResource defaultForegroundBrush}" />
 
-            </StackPanel>
-        </Border>
+         </StackPanel>
+      </Border>
 
-        <ControlTemplate.Triggers>
+      <ControlTemplate.Triggers>
 
-            <!-- The following 2 triggers allow to display the appropriate Sort Glyph
+         <!-- The following 2 triggers allow to display the appropriate Sort Glyph
               depending on the ParentColumn's SortDirection. -->
-            <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
                       Value="Ascending">
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="ContentPresenter.ContentTemplate"
                     Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}" />
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="Margin"
                     Value="6,0,0,0" />
 
-            </DataTrigger>
+         </DataTrigger>
 
-            <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
                       Value="Descending">
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="ContentPresenter.ContentTemplate"
                     Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).DescendingSortGlyph}" />
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="Margin"
                     Value="6,0,0,0" />
 
-            </DataTrigger>
+         </DataTrigger>
 
-        </ControlTemplate.Triggers>
-    </ControlTemplate>
+      </ControlTemplate.Triggers>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: HierarchicalGroupByControlNode
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewHierarchicalGroupByControlNodeTemplate"
+   <ControlTemplate x:Key="tableflowViewHierarchicalGroupByControlNodeTemplate"
                     TargetType="local:HierarchicalGroupByControlNode">
 
-        <StackPanel Orientation="Horizontal"
+      <StackPanel Orientation="Horizontal"
                   Background="{TemplateBinding Background}">
 
-            <Border BorderBrush="{StaticResource defaultForegroundBrush}"
+         <Border BorderBrush="{StaticResource defaultForegroundBrush}"
                  Background="#55FFFFFF"
                  BorderThickness="1"
                  VerticalAlignment="Top"
                  HorizontalAlignment="Center">
 
-                <TextBlock x:Name="titleTextBlock"
+            <TextBlock x:Name="titleTextBlock"
                        Text="{TemplateBinding Title}"
                        Margin="3"
                        FontFamily="{StaticResource defaultFontFamily}"
                        FontSize="{StaticResource defaultFontSize}" />
 
-            </Border>
+         </Border>
 
-            <ItemsPresenter Margin="0,0,0,0" />
+         <ItemsPresenter Margin="0,0,0,0" />
 
-        </StackPanel>
+      </StackPanel>
 
-    </ControlTemplate>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: HierarchicalGroupByItem
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewHierarchicalGroupByItemTemplate"
+   <ControlTemplate x:Key="tableflowViewHierarchicalGroupByItemTemplate"
                     TargetType="local:HierarchicalGroupByItem">
-        <Grid>
-            <Border x:Name="mainBorder"
+      <Grid>
+         <Border x:Name="mainBorder"
                  Background="{TemplateBinding Background}"
                  BorderBrush="{TemplateBinding BorderBrush}"
                  BorderThickness="{TemplateBinding BorderThickness}"
                  Padding="{TemplateBinding Padding}">
 
-                <!-- This StackPanel is used to layout the ContentPresenter and the Sort Glyph (when present). -->
-                <StackPanel Orientation="Horizontal">
+            <!-- This StackPanel is used to layout the ContentPresenter and the Sort Glyph (when present). -->
+            <StackPanel Orientation="Horizontal">
 
-                    <!-- Same ContentPresenter as in the base Cell Template. -->
-                    <ContentPresenter Content="{TemplateBinding Content}"
+               <!-- Same ContentPresenter as in the base Cell Template. -->
+               <ContentPresenter Content="{TemplateBinding Content}"
                                  ContentTemplate="{TemplateBinding ContentTemplate}"
                                  ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
                                  HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                                  VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                    <!-- ContentPresenter that is used to display the sort glyph.
+               <!-- ContentPresenter that is used to display the sort glyph.
                  We explicitely set its Content property to Null to prevent the XAML parser
                  from implicitely setting it to its TemplatedParent's Content. -->
-                    <ContentPresenter x:Name="sortGlyphPresenter"
+               <ContentPresenter x:Name="sortGlyphPresenter"
                                  Content="{x:Null}"
                                  ContentTemplate="{x:Null}"
                                  Margin="15,0,0,0"
                                  TextBlock.Foreground="{StaticResource defaultForegroundBrush}" />
 
-                </StackPanel>
-            </Border>
-        </Grid>
-        <ControlTemplate.Triggers>
+            </StackPanel>
+         </Border>
+      </Grid>
+      <ControlTemplate.Triggers>
 
-            <!-- The following 2 triggers allow to display the appropriate Sort Glyph
+         <!-- The following 2 triggers allow to display the appropriate Sort Glyph
               depending on the ParentColumn's SortDirection. -->
-            <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
                       Value="Ascending">
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="ContentPresenter.ContentTemplate"
                     Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AscendingSortGlyph}" />
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="Margin"
                     Value="6,0,0,0" />
 
-            </DataTrigger>
+         </DataTrigger>
 
-            <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=SortDirection}"
                       Value="Descending">
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="ContentPresenter.ContentTemplate"
                     Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).DescendingSortGlyph}" />
 
-                <Setter TargetName="sortGlyphPresenter"
+            <Setter TargetName="sortGlyphPresenter"
                     Property="Margin"
                     Value="6,0,0,0" />
 
-            </DataTrigger>
+         </DataTrigger>
 
-        </ControlTemplate.Triggers>
-    </ControlTemplate>
+      </ControlTemplate.Triggers>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: GroupHeaderControl (copied from Office2007Blue)
     ************************** -->
-    <conv:IntAdditionConverter x:Key="groupHeaderControlGroupLevelConverter" />
-    <ControlTemplate x:Key="tableflowViewGroupHeaderControlTemplate"
+   <conv:IntAdditionConverter x:Key="groupHeaderControlGroupLevelConverter" />
+   <ControlTemplate x:Key="tableflowViewGroupHeaderControlTemplate"
                     TargetType="local:GroupHeaderControl">
 
-        <!-- Using this decorator will prevent the GroupHeaderControl of exceeding the width 
+      <!-- Using this decorator will prevent the GroupHeaderControl of exceeding the width 
            defined by the grid's column. -->
-        <views:PassiveLayoutDecorator Axis="Horizontal">
-            <DockPanel>
+      <views:PassiveLayoutDecorator Axis="Horizontal">
+         <DockPanel>
 
-                <!-- GroupLevelIndicatorPane is a placeholder for individual GroupLevelIndicator elements that are added
+            <!-- GroupLevelIndicatorPane is a placeholder for individual GroupLevelIndicator elements that are added
               whenever this GroupHeaderControl is part of a group. -->
-                <local:HierarchicalGroupLevelIndicatorPane DockPanel.Dock="Left" />
-                <local:GroupLevelIndicatorPane DockPanel.Dock="Left"
+            <local:HierarchicalGroupLevelIndicatorPane DockPanel.Dock="Left" />
+            <local:GroupLevelIndicatorPane DockPanel.Dock="Left"
                                            Indented="False"
                                            local:GroupLevelIndicatorPane.GroupLevel="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=(local:GroupLevelIndicatorPane.GroupLevel), Converter={StaticResource groupHeaderControlGroupLevelConverter}, ConverterParameter=-1}" />
-                <!-- Main Border for the GroupHeaderControl. It is Focusable to make the InputBindings work. -->
-                <Border x:Name="mainBorder"
+            <!-- Main Border for the GroupHeaderControl. It is Focusable to make the InputBindings work. -->
+            <Border x:Name="mainBorder"
                     Background="{TemplateBinding Background}"
                     BorderBrush="{TemplateBinding BorderBrush}"
                     BorderThickness="{TemplateBinding BorderThickness}"
@@ -790,91 +808,91 @@
                     Focusable="True"
                     FocusVisualStyle="{TemplateBinding FocusVisualStyle}">
 
-                    <!-- Define all the standard InputBindings for a GroupHeaderControl. -->
-                    <Border.InputBindings>
-                        <KeyBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
+               <!-- Define all the standard InputBindings for a GroupHeaderControl. -->
+               <Border.InputBindings>
+                  <KeyBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
                               Key="Space" />
 
-                        <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
+                  <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
                               Key="Right" />
 
-                        <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
+                  <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
                               Key="Add" />
 
-                        <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
+                  <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
                               Key="Left" />
 
-                        <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
+                  <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
                               Key="Subtract" />
 
-                        <MouseBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
+                  <MouseBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
                                 MouseAction="LeftDoubleClick" />
 
-                    </Border.InputBindings>
+               </Border.InputBindings>
 
-                    <DockPanel>
+               <DockPanel>
 
-                        <!-- ToggleButton that is used to expand/collapse the group. -->
-                        <ToggleButton DockPanel.Dock="Left"
+                  <!-- ToggleButton that is used to expand/collapse the group. -->
+                  <ToggleButton DockPanel.Dock="Left"
                                 OverridesDefaultStyle="True"
                                 Template="{StaticResource groupExpanderToggleButtonTemplate}"
                                 VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                                 Focusable="False"
                                 IsChecked="{Binding RelativeSource={RelativeSource TemplatedParent},Path=Group.IsExpanded}" />
 
-                        <!-- ContentPresenter in charge of displaying this GroupHeaderControl's Content, which is a Group by default. -->
-                        <ContentPresenter DockPanel.Dock="Left"
+                  <!-- ContentPresenter in charge of displaying this GroupHeaderControl's Content, which is a Group by default. -->
+                  <ContentPresenter DockPanel.Dock="Left"
                                     Margin="3,0,0,0"
                                     Content="{TemplateBinding Content}"
                                     ContentTemplate="{TemplateBinding ContentTemplate}"
                                     ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
                                     VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                        <!-- Line that is traced across the GroupHeader, following the content -->
-                        <Rectangle Fill="{StaticResource defaultForegroundBrush}"
+                  <!-- Line that is traced across the GroupHeader, following the content -->
+                  <Rectangle Fill="{StaticResource defaultForegroundBrush}"
                              VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                              HorizontalAlignment="Stretch"
                              Height="1"
                              Margin="7,0,0,0" />
-                    </DockPanel>
-                </Border>
-            </DockPanel>
-        </views:PassiveLayoutDecorator>
+               </DockPanel>
+            </Border>
+         </DockPanel>
+      </views:PassiveLayoutDecorator>
 
-        <ControlTemplate.Triggers>
-            <Trigger Property="local:DataGridControl.NavigationBehavior"
+      <ControlTemplate.Triggers>
+         <Trigger Property="local:DataGridControl.NavigationBehavior"
                   Value="None">
-                <Setter TargetName="mainBorder"
+            <Setter TargetName="mainBorder"
                     Property="Focusable"
                     Value="False" />
-            </Trigger>
-        </ControlTemplate.Triggers>
-    </ControlTemplate>
+         </Trigger>
+      </ControlTemplate.Triggers>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: GroupHeaderControl (When top level sticky)
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewGroupHeaderTopLevelStickyControlTemplate"
+   <ControlTemplate x:Key="tableflowViewGroupHeaderTopLevelStickyControlTemplate"
                     TargetType="local:GroupHeaderControl">
 
-        <!-- Using this decorator will prevent the GroupHeaderControl of exceeding the width 
+      <!-- Using this decorator will prevent the GroupHeaderControl of exceeding the width 
            defined by the grid's column. -->
-        <views:PassiveLayoutDecorator Axis="Horizontal">
-            <!-- This DockPanel is used to layout the GroupLevelIndicatorPane placeholder and the GroupHeaderControl Content. -->
-            <DockPanel>
+      <views:PassiveLayoutDecorator Axis="Horizontal">
+         <!-- This DockPanel is used to layout the GroupLevelIndicatorPane placeholder and the GroupHeaderControl Content. -->
+         <DockPanel>
 
-                <!-- GroupLevelIndicatorPane is a placeholder for individual GroupLevelIndicator elements that are added
+            <!-- GroupLevelIndicatorPane is a placeholder for individual GroupLevelIndicator elements that are added
               whenever this GroupHeaderControl is part of a group. -->
-                <local:HierarchicalGroupLevelIndicatorPane DockPanel.Dock="Left" />
-                <local:GroupLevelIndicatorPane DockPanel.Dock="Left"
+            <local:HierarchicalGroupLevelIndicatorPane DockPanel.Dock="Left" />
+            <local:GroupLevelIndicatorPane DockPanel.Dock="Left"
                                            Indented="False"
                                            local:GroupLevelIndicatorPane.GroupLevel="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=(local:GroupLevelIndicatorPane.GroupLevel), Converter={StaticResource groupHeaderControlGroupLevelConverter}, ConverterParameter=-1}" />
 
-                <Grid>
-                    <Border Background="{StaticResource groupHeaderBackgroundBrush}" />
+            <Grid>
+               <Border Background="{StaticResource groupHeaderBackgroundBrush}" />
 
-                    <!-- Main Border for the GroupHeaderControl. It is Focusable to make the InputBindings work. -->
-                    <Border x:Name="mainBorder"
+               <!-- Main Border for the GroupHeaderControl. It is Focusable to make the InputBindings work. -->
+               <Border x:Name="mainBorder"
                        Background="Transparent"
                        BorderBrush="{TemplateBinding BorderBrush}"
                        BorderThickness="{TemplateBinding BorderThickness}"
@@ -882,94 +900,94 @@
                        Focusable="True"
                        FocusVisualStyle="{TemplateBinding FocusVisualStyle}">
 
-                        <!-- Define all the standard InputBindings for a GroupHeaderControl. -->
-                        <Border.InputBindings>
-                            <KeyBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
+                  <!-- Define all the standard InputBindings for a GroupHeaderControl. -->
+                  <Border.InputBindings>
+                     <KeyBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
                                  Key="Space" />
 
-                            <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
+                     <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
                                  Key="Right" />
 
-                            <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
+                     <KeyBinding Command="{x:Static local:DataGridCommands.ExpandGroup}"
                                  Key="Add" />
 
-                            <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
+                     <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
                                  Key="Left" />
 
-                            <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
+                     <KeyBinding Command="{x:Static local:DataGridCommands.CollapseGroup}"
                                  Key="Subtract" />
 
-                            <MouseBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
+                     <MouseBinding Command="{x:Static local:DataGridCommands.ToggleGroupExpansion}"
                                    MouseAction="LeftDoubleClick" />
 
-                        </Border.InputBindings>
+                  </Border.InputBindings>
 
-                        <DockPanel>
+                  <DockPanel>
 
-                            <!-- ToggleButton that is used to expand/collapse the group. -->
-                            <ToggleButton DockPanel.Dock="Left"
+                     <!-- ToggleButton that is used to expand/collapse the group. -->
+                     <ToggleButton DockPanel.Dock="Left"
                                    OverridesDefaultStyle="True"
                                    Template="{StaticResource groupExpanderToggleButtonTemplate}"
                                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                                    Focusable="False"
                                    IsChecked="{Binding RelativeSource={RelativeSource TemplatedParent},Path=Group.IsExpanded}" />
 
-                            <!-- ContentPresenter in charge of displaying this GroupHeaderControl's Content, which is
+                     <!-- ContentPresenter in charge of displaying this GroupHeaderControl's Content, which is
                     a Group by default. -->
-                            <ContentPresenter DockPanel.Dock="Left"
+                     <ContentPresenter DockPanel.Dock="Left"
                                        Margin="3,0,0,0"
                                        Content="{TemplateBinding Content}"
                                        ContentTemplate="{TemplateBinding ContentTemplate}"
                                        ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
                                        VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
-                        </DockPanel>
-                    </Border>
-                </Grid>
-            </DockPanel>
-        </views:PassiveLayoutDecorator>
+                  </DockPanel>
+               </Border>
+            </Grid>
+         </DockPanel>
+      </views:PassiveLayoutDecorator>
 
-        <ControlTemplate.Triggers>
-            <Trigger Property="local:DataGridControl.NavigationBehavior"
+      <ControlTemplate.Triggers>
+         <Trigger Property="local:DataGridControl.NavigationBehavior"
                   Value="None">
-                <Setter TargetName="mainBorder"
+            <Setter TargetName="mainBorder"
                     Property="Focusable"
                     Value="False" />
-            </Trigger>
-        </ControlTemplate.Triggers>
+         </Trigger>
+      </ControlTemplate.Triggers>
 
-    </ControlTemplate>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: ColumnManagerRow (copied from Common)
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewColumnManagerRowTemplate"
+   <ControlTemplate x:Key="tableflowViewColumnManagerRowTemplate"
                     TargetType="local:ColumnManagerRow">
 
-        <!-- A basic Row Template requires at least a Panel named "PART_CellsHost" to which the Row's cells will be added.
+      <!-- A basic Row Template requires at least a Panel named "PART_CellsHost" to which the Row's cells will be added.
            This Panel is usually placed inside a Border who is responsible for painting the gridlines. -->
 
-        <ControlTemplate.Resources>
-            <conv:ThicknessConverter x:Key="thicknessConverter"
+      <ControlTemplate.Resources>
+         <conv:ThicknessConverter x:Key="thicknessConverter"
                                   InverseValue="True" />
-        </ControlTemplate.Resources>
-
-        <!-- This Grid is used to layout the GroupLevelIndicatorPane placeholder and the CellsHost panel. -->
-        <Grid x:Name="rootGrid">
-            <Grid.ColumnDefinitions>
-                <!-- HierarchicalGroupLevelIndicatorPane -->
-                <ColumnDefinition Width="Auto" />
-                <!-- GroupLevelIndicatorPane -->
-                <ColumnDefinition Width="Auto" />
-                <ColumnDefinition Width="Auto" />
-
-                <!-- CellsHost panel -->
-                <ColumnDefinition Width="*" />
-            </Grid.ColumnDefinitions>
-
-            <!-- The border responsible for the visual outline of the row (gridlines and background)
+      </ControlTemplate.Resources>
+
+      <!-- This Grid is used to layout the GroupLevelIndicatorPane placeholder and the CellsHost panel. -->
+      <Grid x:Name="rootGrid">
+         <Grid.ColumnDefinitions>
+            <!-- HierarchicalGroupLevelIndicatorPane -->
+            <ColumnDefinition Width="Auto" />
+            <!-- GroupLevelIndicatorPane -->
+            <ColumnDefinition Width="Auto" />
+            <ColumnDefinition Width="Auto" />
+
+            <!-- CellsHost panel -->
+            <ColumnDefinition Width="*" />
+         </Grid.ColumnDefinitions>
+
+         <!-- The border responsible for the visual outline of the row (gridlines and background)
                        spans the GroupLevelIndicatorPane and CellsHost Panel. Those 2 elements are not children of
                        the Border because we don't want the border to be displayed in the GroupLevelIndicatorPane. -->
-            <Border x:Name="rootBorder"
+         <Border x:Name="rootBorder"
                  Grid.Column="1"
                  Grid.ColumnSpan="3"
                  views:TableView.CanScrollHorizontally="False"
@@ -978,18 +996,18 @@
                  BorderThickness="{TemplateBinding BorderThickness}"
                  Padding="{TemplateBinding Padding}" />
 
-            <!-- GroupLevelIndicatorPane is a placeholder for individual GroupLevelIndicator elements that are added
+         <!-- GroupLevelIndicatorPane is a placeholder for individual GroupLevelIndicator elements that are added
                        whenever this Row is part of a group. -->
-            <local:HierarchicalGroupLevelIndicatorPane views:TableView.CanScrollHorizontally="False"
+         <local:HierarchicalGroupLevelIndicatorPane views:TableView.CanScrollHorizontally="False"
                                                     Grid.Column="0"
                                                     Background="{TemplateBinding Background}" />
-            <local:GroupLevelIndicatorPane x:Name="groupLevelIndicatorPane"
+         <local:GroupLevelIndicatorPane x:Name="groupLevelIndicatorPane"
                                         views:TableView.CanScrollHorizontally="False"
                                         Grid.Column="1"
                                         Background="{TemplateBinding Background}" />
 
-            <!-- ToggleButton that is used to expand/collapse the group. -->
-            <Button x:Name="detailsToggle"
+         <!-- ToggleButton that is used to expand/collapse the group. -->
+         <Button x:Name="detailsToggle"
                  Template="{StaticResource detailsExpanderButtonTemplate}"
                  VerticalAlignment="Top"
                  Grid.Column="2"
@@ -1000,1141 +1018,1170 @@
                  Visibility="Collapsed"
                  views:TableView.CanScrollHorizontally="False" />
 
-            <Decorator x:Name="indentationDecorator"
+         <Decorator x:Name="indentationDecorator"
                     Grid.Column="3">
 
-                <!-- The PART_CellsHost part designates the Panel to which this Row's Cells should be added.-->
-                <views:FixedCellPanel x:Name="PART_CellsHost"
+            <!-- The PART_CellsHost part designates the Panel to which this Row's Cells should be added.-->
+            <views:FixedCellPanel x:Name="PART_CellsHost"
                                   ColumnStretchMinWidth="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).ColumnStretchMinWidth}"
                                   ColumnStretchMode="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).ColumnStretchMode}"
                                   FixedCellCount="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).FixedColumnCount, Mode=TwoWay}"
                                   FixedColumnDropMarkPen="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).FixedColumnDropMarkPen}"
                                   Margin="{TemplateBinding BorderThickness}" />
-            </Decorator>
-
-        </Grid>
+         </Decorator>
 
-        <ControlTemplate.Triggers>
+      </Grid>
 
-            <!-- When there are details, display the Toggle button for the expansion, collapsing of the details -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HasDetails}"
+      <ControlTemplate.Triggers>
+         <!-- When there are details, display the Toggle button for the expansion, collapsing of the details -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HasDetails}"
                           Value="True" />
 
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AllowDetailToggle}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AllowDetailToggle}"
                           Value="True" />
 
-                </MultiDataTrigger.Conditions>
+            </MultiDataTrigger.Conditions>
 
-                <Setter TargetName="detailsToggle"
+            <Setter TargetName="detailsToggle"
                     Property="Visibility"
                     Value="Hidden" />
 
-            </MultiDataTrigger>
+         </MultiDataTrigger>
 
-        </ControlTemplate.Triggers>
+      </ControlTemplate.Triggers>
 
-    </ControlTemplate>
+   </ControlTemplate>
 
-    <!--**************************
+   <!--**************************
     * TEMPLATE: GroupLevelIndicatorPane (copied from common)
     ************************** -->
-    <ControlTemplate x:Key="tableflowViewGroupLevelIndicatorPaneTemplate"
+   <ControlTemplate x:Key="tableflowViewGroupLevelIndicatorPaneTemplate"
                     TargetType="local:GroupLevelIndicatorPane">
-        <Grid>
+      <Grid>
 
-            <Border x:Name="horizontalBorder"
+         <Border x:Name="horizontalBorder"
                  Background="{TemplateBinding Background}"
                  BorderBrush="{TemplateBinding BorderBrush}"
                  BorderThickness="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
-            <Border x:Name="verticalBorder"
+         <Border x:Name="verticalBorder"
                  BorderBrush="{TemplateBinding BorderBrush}"
                  Padding="{TemplateBinding Padding}"
                  BorderThickness="0">
-                <StackPanel x:Name="PART_GroupLevelIndicatorHost"
+            <StackPanel x:Name="PART_GroupLevelIndicatorHost"
                         Orientation="Horizontal" />
-            </Border>
+         </Border>
 
-        </Grid>
-        <ControlTemplate.Triggers>
-            <MultiTrigger>
-                <MultiTrigger.Conditions>
+      </Grid>
+      <ControlTemplate.Triggers>
+         <MultiTrigger>
+            <MultiTrigger.Conditions>
 
-                    <Condition Property="CurrentIndicatorCount"
+               <Condition Property="CurrentIndicatorCount"
                           Value="0" />
 
-                    <Condition Property="IsLeaf"
+               <Condition Property="IsLeaf"
                           Value="False" />
-                </MultiTrigger.Conditions>
+            </MultiTrigger.Conditions>
 
-                <Setter TargetName="verticalBorder"
+            <Setter TargetName="verticalBorder"
                     Property="BorderThickness"
                     Value="0" />
-            </MultiTrigger>
+         </MultiTrigger>
 
-            <Trigger Property="ShowVerticalBorder"
+         <Trigger Property="ShowVerticalBorder"
                   Value="False">
-                <Setter TargetName="verticalBorder"
+            <Setter TargetName="verticalBorder"
                     Property="BorderThickness"
                     Value="0" />
-            </Trigger>
-        </ControlTemplate.Triggers>
-    </ControlTemplate>
-
-    <!-- =================================================================== -->
-    <!-- Styles required by some grid elements                               -->
-    <!-- =================================================================== -->
+         </Trigger>
+      </ControlTemplate.Triggers>
+   </ControlTemplate>
 
+   <!-- =================================================================== -->
+   <!-- Styles required by some grid elements                               -->
+   <!-- =================================================================== -->
 
-    <!--**************************
+   <!--**************************
     * STYLE: CellErrorStyle 
     ************************** -->
-    <Style x:Key="cellErrorStyle"
+   <Style x:Key="cellErrorStyle"
           TargetType="local:Cell">
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{StaticResource errorBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource errorForegroundBrush}" />
 
-        <Setter Property="ToolTip"
+      <Setter Property="ToolTip"
               Value="{Binding RelativeSource={RelativeSource Self},Path=ValidationError.ErrorContent}" />
 
-        <Style.Triggers>
-            <Trigger Property="IsValidationErrorRestrictive"
+      <Style.Triggers>
+         <Trigger Property="IsValidationErrorRestrictive"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource errorBackgroundBrush}" />
 
-            </Trigger>
+         </Trigger>
 
-            <Trigger Property="IsValidationErrorRestrictive"
+         <Trigger Property="IsValidationErrorRestrictive"
                   Value="False">
 
-                <Setter Property="Foreground"
+            <Setter Property="Foreground"
                     Value="{StaticResource warningForegroundBrush}" />
 
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource warningBackgroundBrush}" />
 
-            </Trigger>
-        </Style.Triggers>
+         </Trigger>
+      </Style.Triggers>
 
-    </Style>
+   </Style>
 
-    <!-- =================================================================== -->
-    <!-- Keyed Styles of grid elements                                       -->
-    <!-- =================================================================== -->
+   <!-- =================================================================== -->
+   <!-- Keyed Styles of grid elements                                       -->
+   <!-- =================================================================== -->
 
-    <!--**************************
+   <!--**************************
     * STYLE: DataGridControl 
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGridControlStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGridControlStyle"
           TargetType="local:DataGridControl">
 
+      <!-- TODO : for now do not use Aero2.NormalColor.Controls.xaml (see case 153892)  -->
+      <!--<Style.Resources>
+            <markup:DataGridThemeResourceDictionary Source="Resources/Aero2.NormalColor.Controls.xaml" />
+        </Style.Resources>-->
 
-        <Setter Property="BorderBrush"
+      <Setter Property="BorderBrush"
               Value="{StaticResource gridBorderBrush}" />
 
-        <Setter Property="BorderThickness"
+      <Setter Property="BorderThickness"
               Value="1" />
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{StaticResource defaultBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <!-- This is required to display gridlines of uniform thickness -->
-        <Setter Property="SnapsToDevicePixels"
+      <!-- This is required to display gridlines of uniform thickness -->
+      <Setter Property="SnapsToDevicePixels"
               Value="True" />
 
-        <Setter Property="CellErrorStyle"
+      <Setter Property="CellErrorStyle"
               Value="{StaticResource cellErrorStyle}" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewDataGridControlTemplate}" />
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: RowSelectorPane
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorRowSelectorPaneStyle"
+   <Style x:Key="tableflowViewAero2NormalColorRowSelectorPaneStyle"
           TargetType="local:RowSelectorPane">
 
-        <!-- same background as the ColumnManagerCells -->
-        <Setter Property="Background"
+      <!-- same background as the ColumnManagerCells -->
+      <Setter Property="Background"
               Value="{StaticResource columnManagerCellBackgroundBrush}" />
 
-        <Setter Property="TextElement.Foreground"
+      <Setter Property="TextElement.Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: RowSelector 
     ************************** -->
-    <conv:TypeToBooleanConverter x:Key="rowTypeConverter" />
-    <Style x:Key="tableflowViewAero2NormalColorRowSelectorStyle"
+   <conv:TypeToBooleanConverter x:Key="rowTypeConverter" />
+   <Style x:Key="tableflowViewAero2NormalColorRowSelectorStyle"
           TargetType="local:RowSelector">
 
-        <!-- Set the RowSelector's background to Transparent to make it hit-testable
+      <!-- Set the RowSelector's background to Transparent to make it hit-testable
            while preserving the background drawn by the underlying RowSelectorPane. -->
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="Transparent" />
 
-        <Setter Property="HorizontalContentAlignment"
+      <Setter Property="HorizontalContentAlignment"
               Value="Center" />
 
-        <Setter Property="VerticalContentAlignment"
+      <Setter Property="VerticalContentAlignment"
               Value="Top" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="2" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewRowSelectorTemplate}" />
 
-        <Style.Triggers>
+      <Style.Triggers>
 
-            <!-- We have to use triggers on the type of the Row associated with this 
+         <!-- We have to use triggers on the type of the Row associated with this 
               RowSelector instead of assigning a value to RowSelector.RowSelectorStyle 
               on each row type. This is to avoid a custom RowSelector.RowSelectorStyle
               set by a client of the DataGridControl to completely override the 
               RowSelector style (DefaultStyleKey). -->
 
-            <!-- When the Row is Current, display the current glyph in the RowSelector -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsCurrent}"
+         <!-- When the Row is Current, display the current glyph in the RowSelector -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsCurrent}"
                           Value="True" />
-                </MultiDataTrigger.Conditions>
-                <Setter Property="ContentTemplate"
+            </MultiDataTrigger.Conditions>
+            <Setter Property="ContentTemplate"
                     Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).CurrentItemGlyph}" />
-            </MultiDataTrigger>
+         </MultiDataTrigger>
 
-            <!-- When the Row is being edited, display the appropriate glyph in the RowSelector. -->
-            <Trigger Property="IsBeingEdited"
+         <!-- When the Row is being edited, display the appropriate glyph in the RowSelector. -->
+         <Trigger Property="IsBeingEdited"
                   Value="True">
-                <Setter Property="ContentTemplate"
+            <Setter Property="ContentTemplate"
                     Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).EditingRowGlyph}" />
 
-            </Trigger>
+         </Trigger>
 
-            <!-- When the Row has a validation error, display the appropriate glyph in the RowSelector. -->
-            <Trigger Property="HasValidationError"
+         <!-- When the Row has a validation error, display the appropriate glyph in the RowSelector. -->
+         <Trigger Property="HasValidationError"
                   Value="True">
-                <Setter Property="ContentTemplate"
+            <Setter Property="ContentTemplate"
                     Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).ValidationErrorGlyph}" />
-            </Trigger>
+         </Trigger>
+
 
-            <!-- Use default Button States colors on the RowSelector -->
-            <Trigger Property="IsMouseOver"
+         <!-- Use default Button States colors on the RowSelector -->
+         <Trigger Property="IsMouseOver"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource columnManagerCellMouseOverBackgroundBrush}" />
-            </Trigger>
-            <Trigger Property="IsPressed"
+         </Trigger>
+         <Trigger Property="IsPressed"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource columnManagerCellPressedBackgroundBrush}" />
-            </Trigger>
+         </Trigger>
 
-        </Style.Triggers>
-    </Style>
+      </Style.Triggers>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: Row Style
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorRowStyle"
+   <Style x:Key="tableflowViewAero2NormalColorRowStyle"
           TargetType="local:Row">
 
-        <Setter Property="FontFamily"
+      <Setter Property="FontFamily"
               Value="{StaticResource defaultFontFamily}" />
 
-        <Setter Property="FontSize"
+      <Setter Property="FontSize"
               Value="{StaticResource defaultFontSize}" />
 
-        <Setter Property="FocusVisualStyle"
+      <Setter Property="FocusVisualStyle"
               Value="{StaticResource tableflowViewRowFocusVisualStyle}" />
 
-        <Setter Property="SelectionBackground"
+      <Setter Property="SelectionBackground"
               Value="{StaticResource rowSelectionBackgroundBrush}" />
 
-        <Setter Property="SelectionForeground"
+      <Setter Property="SelectionForeground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="InactiveSelectionBackground"
+      <Setter Property="InactiveSelectionBackground"
               Value="{StaticResource rowInactiveSelectionBackgroundBrush}" />
 
-        <Setter Property="InactiveSelectionForeground"
+      <Setter Property="InactiveSelectionForeground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="BorderThickness"
+      <Setter Property="BorderThickness"
               Value="0" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewRowTemplate}" />
 
-        <Setter Property="Background"
-              Value="{StaticResource rowBackgroundBrush}" />
+      <Setter Property="Background"
+              Value="Transparent" />
 
-        <Style.Triggers>
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
 
-            <!-- Enabled/Disabled Odd datarow style alternation -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).IsAlternatingRowStyleEnabled}"
+      <Style.Triggers>
+
+         <!-- Enabled/Disabled Odd datarow style alternation -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).IsAlternatingRowStyleEnabled}"
                           Value="True" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridVirtualizingPanel.ItemIndex), Converter={x:Static conv:IndexToOddConverter.Singleton}}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridVirtualizingPanel.ItemIndex), Converter={x:Static conv:IndexToOddConverter.Singleton}}"
                           Value="True" />
-                </MultiDataTrigger.Conditions>
-                <Setter Property="Background"
+            </MultiDataTrigger.Conditions>
+            <Setter Property="Background"
                     Value="{StaticResource rowAlternatingBackgroundBrush}" />
-            </MultiDataTrigger>
+         </MultiDataTrigger>
 
-        </Style.Triggers>
-    </Style>
+      </Style.Triggers>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: DataRow 
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorDataRowStyle"
+   <Style x:Key="tableflowViewAero2NormalColorDataRowStyle"
           TargetType="local:DataRow"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowStyle}">
 
-        <Style.Triggers>
-            <!-- MouseOver + NotSelected -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
+      <Style.Triggers>
+         <!-- MouseOver + NotSelected -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
                           Value="Row" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
                           Value="False" />
-                </MultiDataTrigger.Conditions>
-                <Setter Property="Background"
+            </MultiDataTrigger.Conditions>
+            <Setter Property="Background"
                     Value="{StaticResource rowMouseOverBackgroundBrush}" />
-            </MultiDataTrigger>
+         </MultiDataTrigger>
 
-            <!-- MouseOver + Selected -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
+         <!-- MouseOver + Selected -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
                           Value="Row" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
                           Value="True" />
-                </MultiDataTrigger.Conditions>
-                <Setter Property="SelectionBackground"
+            </MultiDataTrigger.Conditions>
+            <Setter Property="SelectionBackground"
                     Value="{StaticResource rowMouseOverSelectionBackgroundBrush}" />
-            </MultiDataTrigger>
-        </Style.Triggers>
+         </MultiDataTrigger>
+      </Style.Triggers>
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: ColumnManagerRow
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorColumnManagerRowStyle"
+   <Style x:Key="tableflowViewAero2NormalColorColumnManagerRowStyle"
           TargetType="local:ColumnManagerRow"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowStyle}">
 
-        <!-- Use a different background and foreground than the base Row style. -->
-        <Setter Property="Background"
+      <!-- Use a different background and foreground than the base Row style. -->
+      <Setter Property="Background"
               Value="{StaticResource columnManagerCellBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="BorderBrush"
+      <Setter Property="BorderBrush"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="BorderThickness"
+      <Setter Property="BorderThickness"
               Value="0,1,0,1" />
 
-        <Setter Property="local:RowSelector.Visible"
+      <Setter Property="local:RowSelector.Visible"
               Value="False" />
 
-        <Setter Property="FontFamily"
+      <Setter Property="FontFamily"
               Value="{StaticResource defaultFontFamily}" />
 
-        <Setter Property="FontSize"
+      <Setter Property="FontSize"
               Value="{StaticResource defaultFontSize}" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="12" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerRowTemplate}" />
 
-        <Style.Triggers>
+      <Style.Triggers>
 
-            <Trigger Property="local:GroupLevelIndicatorPane.GroupLevel"
+         <Trigger Property="local:GroupLevelIndicatorPane.GroupLevel"
                   Value="-1">
-                <!-- We don't want to display the Group Margins for the ColumnManagerRow. -->
-                <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
+            <!-- We don't want to display the Group Margins for the ColumnManagerRow. -->
+            <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="False" />
-            </Trigger>
+         </Trigger>
 
-        </Style.Triggers>
+      </Style.Triggers>
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: Cell Style
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorCellStyle"
+   <Style x:Key="tableflowViewAero2NormalColorCellStyle"
           TargetType="local:Cell">
 
-        <Setter Property="CurrentBackground"
+      <Setter Property="CurrentBackground"
               Value="{StaticResource defaultBackgroundBrush}" />
 
-        <Setter Property="CurrentForeground"
+      <Setter Property="CurrentForeground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="SelectionBackground"
+      <Setter Property="SelectionBackground"
               Value="{StaticResource rowSelectionBackgroundBrush}" />
 
-        <Setter Property="SelectionForeground"
+      <Setter Property="SelectionForeground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="InactiveSelectionBackground"
+      <Setter Property="InactiveSelectionBackground"
               Value="{StaticResource rowInactiveSelectionBackgroundBrush}" />
 
-        <Setter Property="InactiveSelectionForeground"
+      <Setter Property="InactiveSelectionForeground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <!-- Set the Cell's background to Transparent to make it hit-testable
+      <!-- Set the Cell's background to Transparent to make it hit-testable
            while preserving the background drawn by the underlying Row. -->
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="Transparent" />
 
-        <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
-        <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
 
-        <Setter Property="Padding"
+      <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
+      <Setter Property="Width"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
+
+      <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
-        <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
+      <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
-        <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+      <Setter Property="BorderThickness"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
-        <Setter Property="BorderBrush"
+      <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewCellTemplate}" />
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: DataCell
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorDataCellStyle"
+   <Style x:Key="tableflowViewAero2NormalColorDataCellStyle"
           TargetType="local:DataCell"
           BasedOn="{StaticResource tableflowViewAero2NormalColorCellStyle}">
 
-        <Style.Triggers>
-            <!-- MouseOver + NotSelected -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
+      <Style.Triggers>
+         <!-- MouseOver + NotSelected -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
                           Value="Cell" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
                           Value="False" />
-                </MultiDataTrigger.Conditions>
-                <Setter Property="Background"
+            </MultiDataTrigger.Conditions>
+            <Setter Property="Background"
                     Value="{StaticResource rowMouseOverBackgroundBrush}" />
-            </MultiDataTrigger>
+         </MultiDataTrigger>
 
-            <!-- MouseOver + Selected -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
+         <!-- MouseOver + Selected -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.SelectionUnit}"
                           Value="Cell" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsSelected}"
                           Value="True" />
-                </MultiDataTrigger.Conditions>
-                <Setter Property="SelectionBackground"
+            </MultiDataTrigger.Conditions>
+            <Setter Property="SelectionBackground"
                     Value="{StaticResource rowMouseOverSelectionBackgroundBrush}" />
-            </MultiDataTrigger>
-        </Style.Triggers>
+         </MultiDataTrigger>
+      </Style.Triggers>
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: ColumnManagerCell
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorColumnManagerCellStyle"
+   <Style x:Key="tableflowViewAero2NormalColorColumnManagerCellStyle"
           TargetType="local:ColumnManagerCell">
 
-        <!-- Set the Cell's background to Transparent to make it hit-testable
+      <!-- Set the Cell's background to Transparent to make it hit-testable
            while preserving the background drawn by the underlying Row. -->
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="Transparent" />
 
-        <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
-        <Setter Property="Width"
+      <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
+      <Setter Property="Width"
               Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
-        <Setter Property="HorizontalContentAlignment"
-              Value="Left" />
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
 
-        <Style.Triggers>
+      <Style.Triggers>
 
-            <Trigger Property="IsBeingDragged"
+         <Trigger Property="IsBeingDragged"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource columnManagerCellPressedBackgroundBrush}" />
-            </Trigger>
+         </Trigger>
 
-        </Style.Triggers>
-    </Style>
+      </Style.Triggers>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: GroupByControl
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupByControlStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupByControlStyle"
           TargetType="local:GroupByControl">
 
-        <!-- If we don't specify a MinHeight, the default "size-to-content" behavior will arrange 
+      <!-- If we don't specify a MinHeight, the default "size-to-content" behavior will arrange 
            the control with a Height of 0, which makes it invisible and unusable.
            In a typical TableflowView, a height of at least 25 is appropriate for the GroupByControl. -->
-        <Setter Property="MinHeight"
+      <Setter Property="MinHeight"
               Value="25" />
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{StaticResource groupByControlBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="FontFamily"
+      <Setter Property="FontFamily"
               Value="{StaticResource defaultFontFamily}" />
 
-        <Setter Property="FontSize"
+      <Setter Property="FontSize"
               Value="{StaticResource defaultFontSize}" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="8" />
 
-        <Setter Property="BorderBrush"
+      <Setter Property="BorderBrush"
               Value="{StaticResource groupByControlBackgroundBrush}" />
 
-        <Setter Property="BorderThickness"
+      <Setter Property="BorderThickness"
               Value="1,1,1,0" />
 
-        <Setter Property="local:RowSelector.Visible"
+      <Setter Property="local:RowSelector.Visible"
               Value="False" />
 
-        <Setter Property="views:TableView.CanScrollHorizontally"
+      <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupByControlTemplate}" />
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: GroupByItem
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupByItemStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupByItemStyle"
           TargetType="local:GroupByItem">
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{StaticResource columnManagerCellBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="FontFamily"
+      <Setter Property="FontFamily"
               Value="{StaticResource defaultFontFamily}" />
 
-        <Setter Property="FontSize"
+      <Setter Property="FontSize"
               Value="{StaticResource defaultFontSize}" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupByItemTemplate}" />
 
-        <!-- Use default Button States colors on the GroupByItems -->
-        <Style.Triggers>
-            <Trigger Property="IsMouseOver"
+      <!-- Use default Button States colors on the GroupByItems -->
+      <Style.Triggers>
+         <Trigger Property="IsMouseOver"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource columnManagerCellMouseOverBackgroundBrush}" />
-            </Trigger>
-            <Trigger Property="IsPressed"
+         </Trigger>
+         <Trigger Property="IsPressed"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource columnManagerCellPressedBackgroundBrush}" />
-            </Trigger>
-        </Style.Triggers>
+         </Trigger>
+      </Style.Triggers>
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: GroupHeaderControl
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupHeaderControlStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupHeaderControlStyle"
           TargetType="local:GroupHeaderControl">
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="Transparent" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="FontFamily"
+      <Setter Property="FontFamily"
               Value="{StaticResource defaultFontFamily}" />
 
-        <Setter Property="FontSize"
+      <Setter Property="FontSize"
               Value="{StaticResource defaultFontSize}" />
 
-        <Setter Property="views:TableView.CanScrollHorizontally"
+      <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
-        <Setter Property="VerticalContentAlignment"
+      <Setter Property="VerticalContentAlignment"
               Value="Center" />
 
-        <!-- The GroupHeaderControl itself must not be focusable. The main Border inside its Template will
+      <Setter Property="SelectionBackground"
+              Value="{StaticResource rowSelectionBackgroundBrush}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{StaticResource defaultForegroundBrush}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{StaticResource rowInactiveSelectionBackgroundBrush}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{StaticResource defaultForegroundBrush}" />
+
+      <!-- The GroupHeaderControl itself must not be focusable. The main Border inside its Template will
            be made Focusable because it is holding the various InputBindings that make the
            GroupHeaderControl work. -->
-        <Setter Property="Focusable"
+      <Setter Property="Focusable"
               Value="False" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupHeaderControlTemplate}" />
 
-        <Style.Triggers>
+      <Style.Triggers>
 
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Content.IsBottomLevel}"
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Content.IsBottomLevel}"
                           Value="False" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Content.Level}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=Content.Level}"
                           Value="0" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AreGroupHeadersSticky}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AreGroupHeadersSticky}"
                           Value="True" />
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AreGroupsFlattened}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).AreGroupsFlattened}"
                           Value="True" />
-                </MultiDataTrigger.Conditions>
+            </MultiDataTrigger.Conditions>
 
-                <Setter Property="Template"
+            <Setter Property="Template"
                     Value="{StaticResource tableflowViewGroupHeaderTopLevelStickyControlTemplate}" />
 
-            </MultiDataTrigger>
+         </MultiDataTrigger>
 
-        </Style.Triggers>
+      </Style.Triggers>
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: GroupLevelIndicator
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupLevelIndicatorStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupLevelIndicatorStyle"
           TargetType="local:GroupLevelIndicator">
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="White" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="BorderThickness"
+      <Setter Property="BorderThickness"
               Value="0" />
 
-        <Setter Property="Width"
+      <Setter Property="Width"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).GroupLevelIndicatorWidth}" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupLevelIndicatorTemplate}" />
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: DetailIndicator
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorDetailIndicatorStyle"
+   <Style x:Key="tableflowViewAero2NormalColorDetailIndicatorStyle"
           TargetType="local:DetailIndicator">
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{x:Null}" />
 
-        <Setter Property="Width"
+      <Setter Property="Width"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).DetailIndicatorWidth}" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewDetailIndicatorTemplate}" />
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: GroupLevelIndicatorPane
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupLevelIndicatorPaneStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupLevelIndicatorPaneStyle"
           TargetType="local:GroupLevelIndicatorPane">
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupLevelIndicatorPaneTemplate}" />
 
-        <Setter Property="BorderBrush"
+      <Setter Property="BorderBrush"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Style.Triggers>
-            <MultiTrigger>
-                <MultiTrigger.Conditions>
-                    <Condition Property="IsLeaf"
+      <Style.Triggers>
+         <MultiTrigger>
+            <MultiTrigger.Conditions>
+               <Condition Property="IsLeaf"
                           Value="False" />
-                    <Condition Property="views:ViewBase.IsLastItem"
+               <Condition Property="views:ViewBase.IsLastItem"
                           Value="True" />
-                </MultiTrigger.Conditions>
+            </MultiTrigger.Conditions>
 
-                <Setter Property="Margin"
+            <Setter Property="Margin"
                     Value="0,0,0,-5" />
-            </MultiTrigger>
+         </MultiTrigger>
 
-        </Style.Triggers>
-    </Style>
+      </Style.Triggers>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: HierarchicalGroupLevelIndicatorPane
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupLevelIndicatorPaneStyle"
+   <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupLevelIndicatorPaneStyle"
           TargetType="local:HierarchicalGroupLevelIndicatorPane">
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewHierarchicalGroupLevelIndicatorPaneTemplate}" />
 
-        <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
+      <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
               Value="True" />
 
-        <Setter Property="local:GroupLevelIndicatorPane.ShowVerticalBorder"
+      <Setter Property="local:GroupLevelIndicatorPane.ShowVerticalBorder"
               Value="True" />
 
-        <Style.Triggers>
-            <Trigger Property="local:GroupLevelIndicatorPane.GroupLevel"
+      <Style.Triggers>
+         <Trigger Property="local:GroupLevelIndicatorPane.GroupLevel"
                   Value="-1">
 
-                <!-- Stop the propagation of the value set by the default style trigger of
+            <!-- Stop the propagation of the value set by the default style trigger of
                  the ColumnManagerRow -->
-                <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
+            <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
-            </Trigger>
-        </Style.Triggers>
-    </Style>
+         </Trigger>
+      </Style.Triggers>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: HierarchicalGroupByControlNode
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupByControlNodeStyle"
+   <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupByControlNodeStyle"
           TargetType="local:HierarchicalGroupByControlNode">
 
-        <Setter Property="StairHeight"
+      <Setter Property="StairHeight"
               Value="0" />
 
-        <Setter Property="ConnectionLineOffset"
+      <Setter Property="ConnectionLineOffset"
               Value="0" />
 
-        <Setter Property="ConnectionLineAlignment"
+      <Setter Property="ConnectionLineAlignment"
               Value="CenterToCenter" />
 
-        <Setter Property="Focusable"
+      <Setter Property="Focusable"
               Value="False" />
 
-        <Setter Property="Margin"
+      <Setter Property="Margin"
               Value="4" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewHierarchicalGroupByControlNodeTemplate}" />
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: HierarchicalGroupByControl
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupByControlStyle"
+   <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupByControlStyle"
           TargetType="local:HierarchicalGroupByControl">
 
-        <!-- If we don't specify a MinHeight, the default "size-to-content" behavior will arrange 
+      <!-- If we don't specify a MinHeight, the default "size-to-content" behavior will arrange 
            the control with a Height of 0, which makes it invisible and unusable.
            In a typical TableflowView, a height of at least 25 is appropriate for the GroupByControl. -->
-        <Setter Property="MinHeight"
+      <Setter Property="MinHeight"
               Value="25" />
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{StaticResource groupByControlBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="FontFamily"
+      <Setter Property="FontFamily"
               Value="{StaticResource defaultFontFamily}" />
 
-        <Setter Property="FontSize"
+      <Setter Property="FontSize"
               Value="{StaticResource defaultFontSize}" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="8" />
 
-        <Setter Property="BorderBrush"
+      <Setter Property="BorderBrush"
               Value="{StaticResource groupByControlBackgroundBrush}" />
 
-        <Setter Property="BorderThickness"
+      <Setter Property="BorderThickness"
               Value="1,1,1,0" />
 
-        <Setter Property="StairHeight"
+      <Setter Property="StairHeight"
               Value="0" />
 
-        <Setter Property="ConnectionLineOffset"
+      <Setter Property="ConnectionLineOffset"
               Value="0" />
 
-        <Setter Property="ConnectionLineAlignment"
+      <Setter Property="ConnectionLineAlignment"
               Value="CenterToCenter" />
 
-        <Setter Property="local:RowSelector.Visible"
+      <Setter Property="local:RowSelector.Visible"
               Value="False" />
 
-        <Setter Property="views:TableView.CanScrollHorizontally"
+      <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewCommonHierarchicalGroupByControlTemplate}" />
 
-        <Style.Triggers>
+      <Style.Triggers>
 
-            <!-- We use the old GroupByControl Template if there are no Details in the DataGridControl.ItemsSource -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
+         <!-- We use the old GroupByControl Template if there are no Details in the DataGridControl.ItemsSource -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
 
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HasDetails}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HasDetails}"
                           Value="False" />
 
-                    <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).ParentDataGridContext, Converter={StaticResource nullToBooleanConverter}}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).ParentDataGridContext, Converter={StaticResource nullToBooleanConverter}}"
                           Value="True" />
 
-                </MultiDataTrigger.Conditions>
+            </MultiDataTrigger.Conditions>
 
-                <Setter Property="Template"
+            <Setter Property="Template"
                     Value="{StaticResource tableflowViewCommonHierarchicalGroupByControlOldGroupByControlTemplate}" />
 
-            </MultiDataTrigger>
+         </MultiDataTrigger>
 
-        </Style.Triggers>
+      </Style.Triggers>
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: HierarchicalGroupByItem
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupByItemStyle"
+   <Style x:Key="tableflowViewAero2NormalColorHierarchicalGroupByItemStyle"
           TargetType="local:HierarchicalGroupByItem">
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{StaticResource columnManagerCellBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="FontFamily"
+      <Setter Property="FontFamily"
               Value="{StaticResource defaultFontFamily}" />
 
-        <Setter Property="FontSize"
+      <Setter Property="FontSize"
               Value="{StaticResource defaultFontSize}" />
 
-        <Setter Property="Padding"
+      <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
-        <Setter Property="Margin"
+      <Setter Property="Margin"
               Value="4,0,4,0" />
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewHierarchicalGroupByItemTemplate}" />
 
-        <!-- Use default Button States colors on the HierarchicalGroupByItems -->
-        <Style.Triggers>
-            <Trigger Property="IsMouseOver"
+      <!-- Use default Button States colors on the HierarchicalGroupByItems -->
+      <Style.Triggers>
+         <Trigger Property="IsMouseOver"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource columnManagerCellMouseOverBackgroundBrush}" />
-            </Trigger>
-            <Trigger Property="IsPressed"
+         </Trigger>
+         <Trigger Property="IsPressed"
                   Value="True">
-                <Setter Property="Background"
+            <Setter Property="Background"
                     Value="{StaticResource columnManagerCellPressedBackgroundBrush}" />
-            </Trigger>
-        </Style.Triggers>
-
-    </Style>
+         </Trigger>
+      </Style.Triggers>
 
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: ScrollTip
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorScrollTipStyle"
+   <Style x:Key="tableflowViewAero2NormalColorScrollTipStyle"
           TargetType="local:ScrollTip">
 
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource scrollTipTemplate}" />
 
-        <Setter Property="VerticalAlignment"
+      <Setter Property="VerticalAlignment"
               Value="Center" />
 
-        <Setter Property="HorizontalAlignment"
+      <Setter Property="HorizontalAlignment"
               Value="Right" />
 
-        <Setter Property="Background"
+      <Setter Property="Background"
               Value="{StaticResource groupHeaderBackgroundBrush}" />
 
-        <Setter Property="Foreground"
+      <Setter Property="Foreground"
               Value="{StaticResource defaultForegroundBrush}" />
 
-        <Setter Property="BorderBrush"
+      <Setter Property="BorderBrush"
               Value="{StaticResource defaultForegroundBrush}" />
 
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: GroupNavigationControl
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupNavigationControlStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupNavigationControlStyle"
           TargetType="local:GroupNavigationControl">
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupNavigationControlTemplate}" />
-    </Style>
+   </Style>
 
-    <!--**************************
+   <!--**************************
     * STYLE: GroupNavigationControlItem
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupNavigationControlItemStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupNavigationControlItemStyle"
           TargetType="{x:Type local:GroupNavigationControlItem}">
 
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="{x:Type local:GroupNavigationControlItem}">
-                    <Grid SnapsToDevicePixels="true">
-                        <Border x:Name="Border"
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type local:GroupNavigationControlItem}">
+               <Grid SnapsToDevicePixels="true">
+                  <Border x:Name="Border"
                           Background="Transparent" />
-                        <Border Margin="2">
-                            <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                  <Border Margin="2">
+                     <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
                                        VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
-                        </Border>
-                    </Grid>
-                    <ControlTemplate.Triggers>
+                  </Border>
+               </Grid>
+               <ControlTemplate.Triggers>
 
-                        <!-- Change IsSelected SelectedBackgroundBrush to set the selection color for the items -->
-                        <Trigger Property="IsMouseOver"
+                  <!-- Change IsSelected SelectedBackgroundBrush to set the selection color for the items -->
+                  <Trigger Property="IsMouseOver"
                            Value="true">
-                            <Setter Property="Background"
+                     <Setter Property="Background"
                              TargetName="Border"
                              Value="{StaticResource rowMouseOverSelectionBackgroundBrush}" />
 
-                            <Setter Property="Foreground"
+                     <Setter Property="Foreground"
                              Value="Black" />
-                        </Trigger>
+                  </Trigger>
 
-                        <Trigger Property="IsEnabled"
+                  <Trigger Property="IsEnabled"
                            Value="false">
-                            <Setter Property="Foreground"
+                     <Setter Property="Foreground"
                              Value="Gray" />
-                        </Trigger>
-                    </ControlTemplate.Triggers>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-    </Style>
-
-    <!--**************************
+                  </Trigger>
+               </ControlTemplate.Triggers>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+   <!--**************************
     * STYLE: GroupNavigationButton
     ************************** -->
-    <Style x:Key="tableflowViewAero2NormalColorGroupNavigationButtonStyle"
+   <Style x:Key="tableflowViewAero2NormalColorGroupNavigationButtonStyle"
           TargetType="local:GroupNavigationButton">
-        <Setter Property="Template"
+      <Setter Property="Template"
               Value="{StaticResource tableflowViewGroupNavigationButtonTemplate}" />
-    </Style>
+   </Style>
 
-    <!-- =================================================================== -->
-    <!-- Default values for the View                                         -->
-    <!-- =================================================================== -->
+   <!-- =================================================================== -->
+   <!-- Default values for the View                                         -->
+   <!-- =================================================================== -->
 
-    <Style x:Key="tableflowViewAero2NormalColorDefaultValues"
+   <Style x:Key="tableflowViewAero2NormalColorDefaultValues"
           TargetType="views:TableflowView">
 
-        <Setter Property="HorizontalGridLineBrush"
+      <Setter Property="HorizontalGridLineBrush"
               Value="{StaticResource gridLineBrush}" />
 
-        <Setter Property="HorizontalGridLineThickness"
+      <Setter Property="HorizontalGridLineThickness"
               Value="1" />
 
-        <Setter Property="GroupLevelIndicatorWidth"
+      <Setter Property="GroupLevelIndicatorWidth"
               Value="17" />
 
-        <Setter Property="DetailIndicatorWidth"
+      <Setter Property="DetailIndicatorWidth"
               Value="34" />
 
-        <Setter Property="ContainerHeight"
+      <Setter Property="ContainerHeight"
               Value="30" />
 
-        <Setter Property="DefaultDropMarkPen"
+      <Setter Property="DefaultDropMarkPen"
               Value="{StaticResource dropMarkPen}" />
 
-        <!-- Those glyphs are null by default on ViewBase, so every Theme should define
+      <!-- Those glyphs are null by default on ViewBase, so every Theme should define
            and set their own custom glyphs. -->
 
-        <Setter Property="AscendingSortGlyph"
+      <Setter Property="AscendingSortGlyph"
               Value="{StaticResource ascendingSortGlyph}" />
 
-        <Setter Property="DescendingSortGlyph"
+      <Setter Property="DescendingSortGlyph"
               Value="{StaticResource descendingSortGlyph}" />
 
-        <Setter Property="ExpandGroupGlyph"
+      <Setter Property="ExpandGroupGlyph"
               Value="{StaticResource expandGroupGlyph}" />
 
-        <Setter Property="CollapseGroupGlyph"
+      <Setter Property="CollapseGroupGlyph"
               Value="{StaticResource collapseGroupGlyph}" />
 
-        <Setter Property="CurrentItemGlyph"
+      <Setter Property="CurrentItemGlyph"
               Value="{StaticResource currentItemGlyph}" />
 
-        <Setter Property="EditingRowGlyph"
+      <Setter Property="EditingRowGlyph"
               Value="{StaticResource editingRowGlyph}" />
 
-        <Setter Property="ValidationErrorGlyph"
+      <Setter Property="ValidationErrorGlyph"
               Value="{StaticResource validationErrorGlyph}" />
 
-        <Setter Property="ConnectionStateLoadingGlyph"
+      <Setter Property="ConnectionStateLoadingGlyph"
               Value="{StaticResource connectionStateLoadingGlyph}" />
 
-        <Setter Property="ConnectionStateCommittingGlyph"
+      <Setter Property="ConnectionStateCommittingGlyph"
               Value="{StaticResource connectionStateLoadingGlyph}" />
 
-        <Setter Property="ConnectionStateErrorGlyph"
+      <Setter Property="ConnectionStateErrorGlyph"
               Value="{StaticResource connectionStateErrorGlyph}" />
 
-    </Style>
+   </Style>
 
-    <!-- =================================================================== -->
-    <!-- DefaultStyleKey declarations                                        -->
-    <!-- =================================================================== -->
+   <!-- =================================================================== -->
+   <!-- DefaultStyleKey declarations                                        -->
+   <!-- =================================================================== -->
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme}"
           TargetType="views:TableflowView"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDefaultValues}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DataGridControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DataGridControl}"
           TargetType="local:DataGridControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGridControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:RowSelectorPane}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:RowSelectorPane}"
           TargetType="local:RowSelectorPane"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowSelectorPaneStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:RowSelector}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:RowSelector}"
           TargetType="local:RowSelector"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowSelectorStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:Row}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:Row}"
           TargetType="local:Row"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DataRow}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DataRow}"
           TargetType="local:DataRow"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDataRowStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:ColumnManagerRow}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:ColumnManagerRow}"
           TargetType="local:ColumnManagerRow"
           BasedOn="{StaticResource tableflowViewAero2NormalColorColumnManagerRowStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:Cell}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:Cell}"
           TargetType="local:Cell"
           BasedOn="{StaticResource tableflowViewAero2NormalColorCellStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DataCell}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DataCell}"
           TargetType="local:DataCell"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDataCellStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:ColumnManagerCell}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:ColumnManagerCell}"
           TargetType="local:ColumnManagerCell"
           BasedOn="{StaticResource tableflowViewAero2NormalColorColumnManagerCellStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupByControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupByControl}"
           TargetType="local:GroupByControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupByControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupByItem}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupByItem}"
           TargetType="local:GroupByItem"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupByItemStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupHeaderControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupHeaderControl}"
           TargetType="local:GroupHeaderControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupHeaderControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupLevelIndicator}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupLevelIndicator}"
           TargetType="local:GroupLevelIndicator"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupLevelIndicatorStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DetailIndicator}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:DetailIndicator}"
           TargetType="local:DetailIndicator"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDetailIndicatorStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupLevelIndicatorPane}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupLevelIndicatorPane}"
           TargetType="local:GroupLevelIndicatorPane"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupLevelIndicatorPaneStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupLevelIndicatorPane}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupLevelIndicatorPane}"
           TargetType="local:HierarchicalGroupLevelIndicatorPane"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupLevelIndicatorPaneStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:ScrollTip}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:ScrollTip}"
           TargetType="local:ScrollTip"
           BasedOn="{StaticResource tableflowViewAero2NormalColorScrollTipStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupByControlNode}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupByControlNode}"
           TargetType="local:HierarchicalGroupByControlNode"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupByControlNodeStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupByControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupByControl}"
           TargetType="local:HierarchicalGroupByControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupByControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupByItem}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:HierarchicalGroupByItem}"
           TargetType="local:HierarchicalGroupByItem"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupByItemStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupNavigationButton}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupNavigationButton}"
           TargetType="local:GroupNavigationButton"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupNavigationButtonStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupNavigationControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupNavigationControl}"
           TargetType="local:GroupNavigationControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupNavigationControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupNavigationControlItem}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:Windows8Theme, TargetElementType=local:GroupNavigationControlItem}"
           TargetType="local:GroupNavigationControlItem"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupNavigationControlItemStyle}" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.Resources.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.Resources.xaml
index b6d63dc4..1b85cdb9 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.Resources.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.Resources.xaml
@@ -17,12 +17,12 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
-                    xmlns:cnv="clr-namespace:Xceed.Wpf.DataGrid.Converters">
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the standard graphics -->
-      <ResourceDictionary Source="Classic.systemcolor.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Classic.systemcolor.Graphics.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.systemcolor.Graphics.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.systemcolor.Graphics.xaml
index 2b23bfdd..cfb5dcd3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.systemcolor.Graphics.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/Resources/Classic.systemcolor.Graphics.xaml
@@ -15,12 +15,12 @@
   **********************************************************************************-->
 
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    >
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the standard graphics -->
-      <ResourceDictionary Source="../../Common/Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../../Common/Graphics.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableView.Classic.systemcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableView.Classic.systemcolor.xaml
index f095316d..3e8f4719 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableView.Classic.systemcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableView.Classic.systemcolor.xaml
@@ -19,19 +19,18 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant and color-scheme independant theme resources -->
-      <ResourceDictionary Source="Resources/Classic.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Classic.Resources.xaml" />
 
       <!-- Include the view independant and color-scheme dependant theme resources -->
-      <ResourceDictionary Source="Resources/Classic.systemcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Classic.systemcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -124,6 +123,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
       <!-- This Grid is used to position the resizer Thumb over the ColumnManagerCell -->
@@ -180,7 +181,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
 
                   </Border>
@@ -198,6 +198,7 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
                               <!-- Same ContentPresenter as in the base Cell Template. -->
@@ -693,7 +694,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Classic;V4.0.0.0;31bf3856ad364e35;component\themes/classic.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Classic;V4.0.0.0;31bf3856ad364e35;component\themes/classic.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -799,7 +800,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -810,11 +811,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -822,7 +826,7 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -912,18 +916,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -959,7 +972,10 @@
               Value="{StaticResource cellPadding}" />
 
       <Setter Property="HorizontalContentAlignment"
-              Value="Left" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
 
       <Setter Property="Template"
               Value="{StaticResource tableViewColumnManagerCellTemplate}" />
@@ -1048,6 +1064,18 @@
       <Setter Property="Foreground"
               Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1178,7 +1206,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableflowView.Classic.systemcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableflowView.Classic.systemcolor.xaml
index 8460e0b5..f2aa192d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableflowView.Classic.systemcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Classic/TableflowView.Classic.systemcolor.xaml
@@ -19,19 +19,18 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant and color-scheme independant theme resources -->
-      <ResourceDictionary Source="Resources/Classic.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Classic.Resources.xaml" />
 
       <!-- Include the view independant and color-scheme dependant theme resources -->
-      <ResourceDictionary Source="Resources/Classic.systemcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Classic.systemcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -302,6 +301,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
       <!-- This Grid is used to position the resizer Thumb over the ColumnManagerCell -->
@@ -310,7 +311,6 @@
          <Border  BorderBrush="{TemplateBinding BorderBrush}"
                   BorderThickness="{TemplateBinding BorderThickness}">
 
-
             <Grid>
 
                <Rectangle Fill="{DynamicResource {x:Static SystemColors.ControlLightBrushKey}}"
@@ -359,7 +359,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
 
                   </Border>
@@ -377,11 +376,12 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
-
                               <!-- Same ContentPresenter as in the base Cell Template. -->
-                                        <local:CellContentPresenter x:Name="PART_CellContentPresenter"  Grid.Column="0" />
+                              <local:CellContentPresenter x:Name="PART_CellContentPresenter"
+                                                          Grid.Column="0" />
 
                               <!-- ContentPresenter that is used to display the sort glyph.
                                       We explicitely set its Content property to Null to prevent the XAML parser
@@ -419,20 +419,21 @@
       </Grid>
 
       <ControlTemplate.Triggers>
-            <!-- The following triggers allows the content to correctly align to the center when the mouse is over the ColumnManagerCell and the HorizontalContentAlignment is Center -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Value="Visible"
+         <!-- The following triggers allows the content to correctly align to the center when the mouse is over the ColumnManagerCell and the HorizontalContentAlignment is Center -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Value="Visible"
                           Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
-                    <Condition Value="Center"
-                           Binding="{Binding RelativeSource={RelativeSource Self},
+               <Condition Value="Center"
+                          Binding="{Binding RelativeSource={RelativeSource Self},
                         Path=HorizontalContentAlignment}" />
-                </MultiDataTrigger.Conditions>
+            </MultiDataTrigger.Conditions>
 
-                <Setter TargetName="PART_CellContentPresenter"
-                    Property="Margin" Value="16,0,0,0"/>
-            </MultiDataTrigger>
-            <!-- Trigger related to the filteringToggleButton-->
+            <Setter TargetName="PART_CellContentPresenter"
+                    Property="Margin"
+                    Value="16,0,0,0" />
+         </MultiDataTrigger>
+         <!-- Trigger related to the filteringToggleButton-->
          <Trigger SourceName="toggleButton"
                   Property="IsMouseOver"
                   Value="True">
@@ -460,7 +461,6 @@
 
          </Trigger>
 
-
          <!-- The following 2 triggers allow the appropriate Sort Glyph to be displayed
               depending on the ParentColumn's SortDirection. -->
 
@@ -683,7 +683,6 @@
                     TargetType="local:HierarchicalGroupByItem">
       <Grid>
 
-
          <Border x:Name="outerBorder"
                  BorderBrush="{DynamicResource {x:Static SystemColors.ControlDarkDarkBrushKey}}"
                  Background="{DynamicResource {x:Static SystemColors.ControlLightLightBrushKey}}"
@@ -959,7 +958,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Classic;V4.0.0.0;31bf3856ad364e35;component\themes/classic.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Classic;V4.0.0.0;31bf3856ad364e35;component\themes/classic.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1065,7 +1064,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1076,17 +1075,20 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1176,18 +1178,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1223,7 +1234,10 @@
               Value="{StaticResource cellPadding}" />
 
       <Setter Property="HorizontalContentAlignment"
-              Value="Left" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Left}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
 
       <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
@@ -1304,7 +1318,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: GroupHeaderControl 
     ************************** -->
@@ -1317,6 +1330,18 @@
       <Setter Property="Foreground"
               Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1370,7 +1395,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: GroupLevelIndicator
     ************************** -->
@@ -1462,7 +1486,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
@@ -1738,7 +1762,6 @@
 
    </Style>
 
-
    <!-- =================================================================== -->
    <!-- DefaultStyleKey declarations                                        -->
    <!-- =================================================================== -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/Common.Resources.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/Common.Resources.xaml
index e950e273..8ae3a994 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/Common.Resources.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/Common.Resources.xaml
@@ -21,6 +21,8 @@
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
                     xmlns:scm="clr-namespace:System.ComponentModel;assembly=WindowsBase">
 
+    <cnv:StringFormatMultiConverter x:Key="stringFormatMultiConverter" />
+
    <!-- Style applied to the Thumbs that are used to resize the columns and rows.
         The Thumb's template is an empty Grid with a Transparent background to
         make it hit-testable. -->
@@ -92,12 +94,19 @@
 
          <TextBlock Text=": "
                     VerticalAlignment="Center" />
-         <ContentPresenter Content="{Binding Value}"
-                           ContentTemplate="{Binding RelativeSource={RelativeSource TemplatedParent},Path=DataContext.ValueTemplate}"
-                           ContentTemplateSelector="{Binding RelativeSource={RelativeSource TemplatedParent},Path=DataContext.ValueTemplateSelector}"
-                           VerticalAlignment="Center" />
-
-         <TextBlock Text=" ("
+            <ContentPresenter ContentTemplate="{Binding RelativeSource={RelativeSource TemplatedParent},Path=DataContext.ValueTemplate}"
+                              ContentTemplateSelector="{Binding RelativeSource={RelativeSource TemplatedParent},Path=DataContext.ValueTemplateSelector}"
+                              VerticalAlignment="Center">
+                <ContentPresenter.Content>
+                   <MultiBinding Converter="{StaticResource stringFormatMultiConverter}">
+                        <Binding Path="Value" />
+                        <Binding Path="DataContext.ValueStringFormat" RelativeSource="{RelativeSource TemplatedParent}" />
+                        <Binding Path="DataContext.ValueStringFormatCulture" RelativeSource="{RelativeSource TemplatedParent}" />
+                   </MultiBinding>
+                </ContentPresenter.Content>
+            </ContentPresenter>
+
+            <TextBlock Text=" ("
                     VerticalAlignment="Center" />
          <TextBlock Text="{Binding ItemCount}"
                     VerticalAlignment="Center" />
@@ -126,14 +135,23 @@
          <DataTemplate x:Key="detailedGroupItemContentTemplate">
             <StackPanel Orientation="Horizontal"
                         VerticalAlignment="Center">
-
-               <ContentControl Content="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).Value}"
-                               ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplate}"
-                               ContentTemplateSelector="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplateSelector}"
-                               TextBlock.FontWeight="Bold"
-                               VerticalAlignment="Center" />
-
-               <TextBlock Text=" ("
+                    <ContentControl ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplate}"
+                                    ContentTemplateSelector="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplateSelector}"
+                                    TextBlock.FontWeight="Bold"
+                                    VerticalAlignment="Center">
+                        <ContentControl.Content>
+                     <MultiBinding Converter="{StaticResource stringFormatMultiConverter}">
+                                <Binding Path="(local:GroupNavigationControl.Group).Value"
+                                         RelativeSource="{RelativeSource Self}"/>
+                                <Binding Path="(local:GroupNavigationControl.Group).ValueStringFormat"
+                                         RelativeSource="{RelativeSource Self}" />
+                                <Binding Path="(local:GroupNavigationControl.Group).ValueStringFormatCulture"
+                                         RelativeSource="{RelativeSource Self}" />
+                           </MultiBinding>
+                        </ContentControl.Content>
+                    </ContentControl>
+
+                    <TextBlock Text=" ("
                           VerticalAlignment="Center" />
                <TextBlock Text="{Binding ItemCount}"
                           VerticalAlignment="Center" />
@@ -158,10 +176,20 @@
          </DataTemplate>
 
          <DataTemplate x:Key="groupItemContentTemplate">
-            <ContentControl Content="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).Value}"
-                            ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplate}"
-                            ContentTemplateSelector="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplateSelector}" />
-         </DataTemplate>
+                <ContentControl ContentTemplate="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplate}"
+                                ContentTemplateSelector="{Binding RelativeSource={RelativeSource Self}, Path=(local:GroupNavigationControl.Group).ValueTemplateSelector}">
+                    <ContentControl.Content>
+                  <MultiBinding Converter="{StaticResource stringFormatMultiConverter}">
+                            <Binding Path="(local:GroupNavigationControl.Group).Value" 
+                                     RelativeSource="{RelativeSource Self}" />
+                            <Binding Path="(local:GroupNavigationControl.Group).ValueStringFormat"
+                                     RelativeSource="{RelativeSource Self}" />
+                            <Binding Path="(local:GroupNavigationControl.Group).ValueStringFormatCulture"
+                                     RelativeSource="{RelativeSource Self}" />
+                        </MultiBinding>
+                    </ContentControl.Content>
+                </ContentControl>
+            </DataTemplate>
 
          <DataTemplate x:Key="parentGroupTemplate">
             <local:GroupNavigationControl Group="{Binding}"
@@ -225,7 +253,7 @@
 
    <cnv:EmptyStringToBooleanConverter x:Key="emptyStringToBooleanConverter" />
 
-   <cnv:DefaultDataConverter x:Key="defaultDataConverter" />
+   <cnv:SourceDataConverter x:Key="sourceDataConverter" />
 
    <Thickness x:Key="cellPadding"
               Left="2"
@@ -236,6 +264,30 @@
    <!--**************************
    * Style: ListBoxItem Style (AutoFilter Options)
    **************************-->
+   <Style x:Key="defaultAutoFilteringCheckBoxItemStyle"
+          TargetType="ListBoxItem">
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type ListBoxItem}">
+
+               <Border Background="{TemplateBinding Background}"
+                       BorderBrush="{TemplateBinding BorderBrush}"
+                       BorderThickness="{TemplateBinding BorderThickness}">
+
+                  <CheckBox Content="{TemplateBinding Content}"
+                            ContentTemplate="{TemplateBinding ContentTemplate}"
+                            ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
+                            Focusable="False"
+                            TextElement.Foreground="{TemplateBinding Foreground}"
+                            IsChecked="{Binding RelativeSource={RelativeSource TemplatedParent},Path=IsSelected, Mode=TwoWay}"
+                            Margin="2,2,2,2"
+                            AutomationProperties.AutomationId="{Binding RelativeSource={RelativeSource Self}, Path=Content, Converter={StaticResource sourceDataConverter}}" />
+               </Border>
+
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
 
    <DataTemplate x:Key="connectionStateLoadingGlyph">
       <DataTemplate.Resources>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableView.GridElementTemplates.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableView.GridElementTemplates.xaml
index ca151164..4f83ac82 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableView.GridElementTemplates.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableView.GridElementTemplates.xaml
@@ -22,7 +22,7 @@
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
-      <ResourceDictionary Source="Common.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Common.Resources.xaml" />
    </ResourceDictionary.MergedDictionaries>
 
    <Style x:Key="tableViewRowFocusVisualStyle"
@@ -44,6 +44,7 @@
       </Setter>
    </Style>
 
+   <conv:NullToBooleanConverter x:Key="nullToBooleanConverter" />
    <conv:ThicknessConverter x:Key="inverseThicknessConverter"
                             InverseValue="True" />
 
@@ -579,6 +580,9 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+
+    <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -634,7 +638,6 @@
                                    Visibility="Collapsed"
                                    Margin="2,0,0,0"
                                    Opacity="0.5" />
-
                   </Grid>
 
                </Border>
@@ -660,7 +663,6 @@
                            <ContentPresenter x:Name="sortGlyphPresenter"
                                              Content="{x:Null}"
                                              ContentTemplate="{x:Null}" />
-
                         </StackPanel>
                      </Border>
 
@@ -682,7 +684,6 @@
                    Width="6"
                    HorizontalAlignment="Right" />
 
-
          </Grid>
 
       </Border>
@@ -982,8 +983,8 @@
                     Property="Focusable"
                     Value="False" />
          </Trigger>
-      </ControlTemplate.Triggers>
 
+      </ControlTemplate.Triggers>
    </ControlTemplate>
 
    <!--**************************
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableflowView.GridElementTemplates.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableflowView.GridElementTemplates.xaml
index 10c8aba6..f7f390c1 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableflowView.GridElementTemplates.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Common/TableflowView.GridElementTemplates.xaml
@@ -22,7 +22,7 @@
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
-      <ResourceDictionary Source="Common.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Common.Resources.xaml" />
    </ResourceDictionary.MergedDictionaries>
 
    <Style x:Key="tableflowViewRowFocusVisualStyle"
@@ -44,6 +44,7 @@
       </Setter>
    </Style>
 
+   <conv:NullToBooleanConverter x:Key="nullToBooleanConverter" />
    <conv:ThicknessConverter x:Key="inverseThicknessConverter"
                             InverseValue="True" />
 
@@ -258,7 +259,7 @@
             <MultiDataTrigger.Conditions>
 
                <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=IsSelected}"
-                          Value="True" />               
+                          Value="True" />
 
                <Condition Binding="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).DataGridControl.IsKeyboardFocusWithin}"
                           Value="True" />
@@ -413,6 +414,7 @@
       </Grid>
 
       <ControlTemplate.Triggers>
+
          <!-- When there are details, display the Toggle button for the expansion, collapsing of the details -->
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
@@ -604,6 +606,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+    <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -662,7 +666,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
 
                   </Border>
@@ -688,7 +691,6 @@
                               <ContentPresenter x:Name="sortGlyphPresenter"
                                                 Content="{x:Null}"
                                                 ContentTemplate="{x:Null}" />
-
                            </StackPanel>
                         </Border>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Controls/TableViewScrollViewer.generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Controls/TableViewScrollViewer.generic.xaml
index 65c12801..3cbf1aa0 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Controls/TableViewScrollViewer.generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Controls/TableViewScrollViewer.generic.xaml
@@ -26,7 +26,7 @@
               Value="Visible" />
 
       <Setter Property="HorizontalScrollBarVisibility"
-              Value="Auto" />
+              Value="{Binding HorizontalScrollBarVisibilityHint, RelativeSource={RelativeSource Self}}" />
 
       <Setter Property="CanContentScroll"
               Value="True" />
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/Resources/TableView.Luna.Graphics.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/Resources/TableView.Luna.Graphics.xaml
index 0347f042..e3cccaf6 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/Resources/TableView.Luna.Graphics.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/Resources/TableView.Luna.Graphics.xaml
@@ -16,12 +16,13 @@
 
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid">
+                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the standard graphics -->
-      <ResourceDictionary Source="../../Common/Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../../Common/Graphics.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.homestead.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.homestead.xaml
index 3a5e2aa3..6bdc4de0 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.homestead.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.homestead.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.homestead.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.homestead.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -271,6 +270,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -313,7 +314,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
 
                   </Border>
@@ -333,6 +333,7 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
                               <!-- Same ContentPresenter as in the base Cell Template. -->
@@ -991,7 +992,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.homestead.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.homestead.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1096,7 +1097,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1107,11 +1108,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -1119,7 +1123,7 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1209,18 +1213,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1255,6 +1268,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewColumnManagerCellTemplate}" />
 
@@ -1336,6 +1355,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1467,7 +1498,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.metallic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.metallic.xaml
index 82ac72e5..81dff704 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.metallic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.metallic.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.metallic.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.metallic.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -415,6 +414,7 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
 
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
@@ -457,7 +457,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
                   </Border>
 
@@ -476,6 +475,7 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
                               <!-- Same ContentPresenter as in the base Cell Template. -->
@@ -1277,7 +1277,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1382,7 +1382,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1393,11 +1393,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -1405,7 +1408,7 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1495,18 +1498,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1540,11 +1552,18 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewColumnManagerCellTemplate}" />
 
    </Style>
 
+
    <!--**************************
     * STYLE: GroupByControl 
     ************************** -->
@@ -1621,6 +1640,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1751,7 +1782,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.normalcolor.xaml
index dd59b194..9868cab5 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableView.Luna.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -419,6 +418,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -462,7 +463,6 @@
                                          Focusable="False"
                                          Visibility="Collapsed"
                                          Margin="2,0,0,0" />
-
                         </Grid>
 
                      </Grid>
@@ -483,6 +483,7 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
                               <!-- Same ContentPresenter as in the base Cell Template. -->
@@ -1280,7 +1281,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.normalcolor.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.normalcolor.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1384,7 +1385,7 @@
       <!-- The Row is responsible for drawing the horizontal gridlines. It draws only its top gridline,
            assuming that the bottom gridline will be drawn by its following row/element -->
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1395,11 +1396,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -1407,7 +1411,7 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1496,18 +1500,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1542,6 +1555,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewColumnManagerCellTemplate}" />
 
@@ -1623,6 +1642,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
@@ -1756,7 +1787,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.homestead.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.homestead.xaml
index f827c1a6..8710f1aa 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.homestead.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.homestead.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.homestead.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.homestead.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -495,6 +494,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -537,12 +538,10 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
 
                   </Border>
 
-
                   <!-- Since we use a very specific border arrangement to represent the ColumnManagerCell,
               we do not use the TemplatedParent's BorderBrush and BorderThickness properties.-->
                   <Border x:Name="rootBorder"
@@ -558,11 +557,12 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
-
                               <!-- Same ContentPresenter as in the base Cell Template. -->
-                                        <local:CellContentPresenter x:Name="PART_CellContentPresenter" Grid.Column="0" />
+                              <local:CellContentPresenter x:Name="PART_CellContentPresenter"
+                                                          Grid.Column="0" />
 
                               <!-- ContentPresenter that is used to display the sort glyph.
                                       We explicitely set its Content property to Null to prevent the XAML parser
@@ -628,27 +628,26 @@
                 Width="6"
                 HorizontalAlignment="Right" />
 
-
       </Grid>
 
       <ControlTemplate.Triggers>
 
-            <!-- The following triggers allows the content to correctly align to the center when the mouse is over the ColumnManagerCell and the HorizontalContentAlignment is Center -->
-            <MultiDataTrigger>
-                <MultiDataTrigger.Conditions>
-                    <Condition Value="Visible"
+         <!-- The following triggers allows the content to correctly align to the center when the mouse is over the ColumnManagerCell and the HorizontalContentAlignment is Center -->
+         <MultiDataTrigger>
+            <MultiDataTrigger.Conditions>
+               <Condition Value="Visible"
                           Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
-                    <Condition Value="Center"
-                           Binding="{Binding RelativeSource={RelativeSource Self},
+               <Condition Value="Center"
+                          Binding="{Binding RelativeSource={RelativeSource Self},
                         Path=HorizontalContentAlignment}" />
-                </MultiDataTrigger.Conditions>
-
-                <Setter TargetName="PART_CellContentPresenter"
-                    Property="Margin" Value="18,0,0,0"/>
-            </MultiDataTrigger>
+            </MultiDataTrigger.Conditions>
 
+            <Setter TargetName="PART_CellContentPresenter"
+                    Property="Margin"
+                    Value="18,0,0,0" />
+         </MultiDataTrigger>
 
-            <!-- Trigger related to the filteringToggleButton-->
+         <!-- Trigger related to the filteringToggleButton-->
          <Trigger SourceName="toggleButton"
                   Property="IsMouseOver"
                   Value="True">
@@ -1326,7 +1325,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.homestead.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.homestead.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1431,7 +1430,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1442,17 +1441,20 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1542,18 +1544,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1588,6 +1599,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
 
@@ -1669,6 +1686,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1721,7 +1750,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: GroupLevelIndicator
     ************************** -->
@@ -1814,7 +1842,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
@@ -1857,7 +1885,6 @@
       <Setter Property="Background"
               Value="{StaticResource groupByControlBackgroundBrush}" />
 
-
       <Setter Property="StairHeight"
               Value="0" />
 
@@ -2086,7 +2113,6 @@
 
    </Style>
 
-
    <!-- =================================================================== -->
    <!-- DefaultStyleKey declarations                                        -->
    <!-- =================================================================== -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.metallic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.metallic.xaml
index 303e4e46..69e3c257 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.metallic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.metallic.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.metallic.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.metallic.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -639,6 +638,7 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
 
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
@@ -681,7 +681,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
                   </Border>
 
@@ -700,11 +699,12 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
-
                               <!-- Same ContentPresenter as in the base Cell Template. -->
-                              <local:CellContentPresenter x:Name="PART_CellContentPresenter" Grid.Column="0" />
+                              <local:CellContentPresenter x:Name="PART_CellContentPresenter"
+                                                          Grid.Column="0" />
 
                               <!-- ContentPresenter that is used to display the sort glyph.
                                       We explicitely set its Content property to Null to prevent the XAML parser
@@ -716,7 +716,6 @@
                            </Grid>
                         </Border>
 
-
                      </Grid>
 
                   </Border>
@@ -775,7 +774,6 @@
 
                </Border>
 
-
             </Grid>
 
          </Border>
@@ -786,7 +784,6 @@
                 Width="6"
                 HorizontalAlignment="Left" />
 
-
          <!-- Thumb that is used to resize the Column. -->
          <Thumb x:Name="PART_ColumnResizerThumb"
                 Style="{StaticResource invisibleThumbStyle}"
@@ -803,12 +800,13 @@
                <Condition Value="Visible"
                           Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
                <Condition Value="Center"
-                           Binding="{Binding RelativeSource={RelativeSource Self},
+                          Binding="{Binding RelativeSource={RelativeSource Self},
                         Path=HorizontalContentAlignment}" />
             </MultiDataTrigger.Conditions>
 
             <Setter TargetName="PART_CellContentPresenter"
-                    Property="Margin" Value="18,0,0,0"/>
+                    Property="Margin"
+                    Value="18,0,0,0" />
          </MultiDataTrigger>
 
          <!-- Trigger related to the filteringToggleButton-->
@@ -1609,7 +1607,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1714,7 +1712,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1725,17 +1723,20 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1764,6 +1765,7 @@
           BasedOn="{StaticResource tableflowViewLunaMetallicRowStyle}">
    </Style>
 
+
    <!--**************************
     * STYLE: ColumnManagerRow 
     ************************** -->
@@ -1825,18 +1827,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1871,6 +1882,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
 
@@ -1955,6 +1972,18 @@
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
@@ -2005,7 +2034,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: GroupLevelIndicator
     ************************** -->
@@ -2097,7 +2125,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
@@ -2137,11 +2165,9 @@
    <Style x:Key="tableflowViewLunaMetallicHierarchicalGroupByControlStyle"
           TargetType="local:HierarchicalGroupByControl">
 
-
       <Setter Property="Background"
               Value="{StaticResource groupByControlBackgroundBrush}" />
 
-
       <Setter Property="StairHeight"
               Value="0" />
 
@@ -2160,7 +2186,6 @@
       <Setter Property="Template"
               Value="{StaticResource tableflowViewCommonHierarchicalGroupByControlTemplate}" />
 
-
       <Style.Triggers>
 
          <!-- We use the old GroupByControl Template if there are no Details in the DataGridControl.ItemsSource -->
@@ -2247,7 +2272,6 @@
       <Setter Property="HorizontalAlignment"
               Value="Right" />
 
-
    </Style>
 
    <!--**************************
@@ -2372,7 +2396,6 @@
 
    </Style>
 
-
    <!-- =================================================================== -->
    <!-- DefaultStyleKey declarations                                        -->
    <!-- =================================================================== -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.normalcolor.xaml
index 2e9e40c8..abf88b76 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Luna/TableflowView.Luna.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Luna.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Luna.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Luna.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -642,6 +641,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -686,10 +687,8 @@
                                          Visibility="Collapsed"
                                          Margin="2,0,0,0"
                                          Opacity="0.5" />
-
                         </Grid>
 
-
                      </Grid>
                   </Border>
 
@@ -708,11 +707,12 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
-
                               <!-- Same ContentPresenter as in the base Cell Template. -->
-                              <local:CellContentPresenter x:Name="PART_CellContentPresenter" Grid.Column="0" />
+                              <local:CellContentPresenter x:Name="PART_CellContentPresenter"
+                                                          Grid.Column="0" />
 
                               <!-- ContentPresenter that is used to display the sort glyph.
                                       We explicitely set its Content property to Null to prevent the XAML parser
@@ -775,7 +775,6 @@
                        HorizontalAlignment="Right"
                        Width="1" />
 
-
                <Border x:Name="isPressedDarkInnerHighlight"
                        BorderThickness="1,1,0,0"
                        Margin="1,0,1,0">
@@ -806,12 +805,13 @@
                <Condition Value="Visible"
                           Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
                <Condition Value="Center"
-                           Binding="{Binding RelativeSource={RelativeSource Self},
+                          Binding="{Binding RelativeSource={RelativeSource Self},
                         Path=HorizontalContentAlignment}" />
             </MultiDataTrigger.Conditions>
 
             <Setter TargetName="PART_CellContentPresenter"
-                    Property="Margin" Value="18,0,0,0"/>
+                    Property="Margin"
+                    Value="18,0,0,0" />
          </MultiDataTrigger>
 
          <!-- Trigger related to the filteringToggleButton-->
@@ -1610,7 +1610,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.normalcolor.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.normalcolor.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1714,7 +1714,7 @@
       <!-- The Row is responsible for drawing the horizontal gridlines. It draws only its top gridline,
            assuming that the bottom gridline will be drawn by its following row/element -->
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1725,17 +1725,20 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1824,18 +1827,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1870,6 +1882,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
 
@@ -1951,6 +1969,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
@@ -2007,7 +2037,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: GroupLevelIndicator
     ************************** -->
@@ -2099,7 +2128,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
@@ -2142,7 +2171,6 @@
       <Setter Property="Background"
               Value="{StaticResource groupByControlBackgroundBrush}" />
 
-
       <Setter Property="StairHeight"
               Value="0" />
 
@@ -2371,7 +2399,6 @@
 
    </Style>
 
-
    <!-- =================================================================== -->
    <!-- DefaultStyleKey declarations                                        -->
    <!-- =================================================================== -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/Resources/TableView.Royale.Graphics.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/Resources/TableView.Royale.Graphics.xaml
index 3a857c9f..65d5fa30 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/Resources/TableView.Royale.Graphics.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/Resources/TableView.Royale.Graphics.xaml
@@ -16,12 +16,13 @@
 
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid">
+                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Royale uses the same graphics as Luna, so reuse the same ResourceDictionary. -->
-      <ResourceDictionary Source="../../Luna/Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../../Luna/Resources/TableView.Luna.Graphics.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableView.Royale.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableView.Royale.normalcolor.xaml
index d8033381..f2ae1df3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableView.Royale.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableView.Royale.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Royale.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Royale.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Royale.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Royale.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Royale.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Royale.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -397,6 +396,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -437,7 +438,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
                   </Border>
 
@@ -456,6 +456,7 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
                               <!-- Same ContentPresenter as in the base Cell Template. -->
@@ -1246,7 +1247,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Royale;V4.0.0.0;31bf3856ad364e35;component\themes/royale.normalcolor.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Royale;V4.0.0.0;31bf3856ad364e35;component\themes/royale.normalcolor.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1351,7 +1352,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1362,11 +1363,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -1374,7 +1378,7 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1464,18 +1468,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1510,6 +1523,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewColumnManagerCellTemplate}" />
 
@@ -1591,6 +1610,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1721,7 +1752,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableflowView.Royale.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableflowView.Royale.normalcolor.xaml
index 203ef8d7..d17e8839 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableflowView.Royale.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Royale/TableflowView.Royale.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Royale.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Royale.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Royale.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Royale.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Royale.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Royale.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -617,10 +616,11 @@
 
    </ControlTemplate>
 
-
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -661,7 +661,6 @@
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0"
                                       Opacity="0.5" />
-
                      </Grid>
                   </Border>
 
@@ -680,11 +679,12 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
-
                               <!-- Same ContentPresenter as in the base Cell Template. -->
-                              <local:CellContentPresenter Grid.Column="0" x:Name="PART_CellContentPresenter" />
+                              <local:CellContentPresenter Grid.Column="0"
+                                                          x:Name="PART_CellContentPresenter" />
 
                               <!-- ContentPresenter that is used to display the sort glyph.
                                    We explicitely set its Content property to Null to prevent the XAML parser
@@ -768,7 +768,6 @@
                 Width="6"
                 HorizontalAlignment="Right" />
 
-
       </Grid>
       <ControlTemplate.Triggers>
 
@@ -778,15 +777,15 @@
                <Condition Value="Visible"
                           Binding="{Binding ElementName=toggleButton, Path=Visibility}" />
                <Condition Value="Center"
-                           Binding="{Binding RelativeSource={RelativeSource Self},
+                          Binding="{Binding RelativeSource={RelativeSource Self},
                         Path=HorizontalContentAlignment}" />
             </MultiDataTrigger.Conditions>
 
             <Setter TargetName="PART_CellContentPresenter"
-                    Property="Margin" Value="18,0,0,0"/>
+                    Property="Margin"
+                    Value="18,0,0,0" />
          </MultiDataTrigger>
 
-
          <!-- Trigger related to the filteringToggleButton-->
          <Trigger SourceName="toggleButton"
                   Property="IsMouseOver"
@@ -1577,7 +1576,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Royale;V4.0.0.0;31bf3856ad364e35;component\themes/royale.normalcolor.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Royale;V4.0.0.0;31bf3856ad364e35;component\themes/royale.normalcolor.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1682,7 +1681,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1693,17 +1692,20 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1793,18 +1795,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1839,6 +1850,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
 
@@ -1920,6 +1937,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1973,7 +2002,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: GroupLevelIndicator
     ************************** -->
@@ -2065,7 +2093,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
@@ -2178,7 +2206,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: ScrollTip
     ************************** -->
@@ -2337,7 +2364,6 @@
 
    </Style>
 
-
    <!-- =================================================================== -->
    <!-- DefaultStyleKey declarations                                        -->
    <!-- =================================================================== -->
@@ -2402,7 +2428,6 @@
           TargetType="local:DetailIndicator"
           BasedOn="{StaticResource tableflowViewRoyaleNormalColorDetailIndicatorStyle}" />
 
-
    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, ThemeType=views:RoyaleNormalColorTheme, TargetElementType=local:GroupLevelIndicatorPane}"
           TargetType="local:GroupLevelIndicatorPane"
           BasedOn="{StaticResource tableflowViewRoyaleNormalColorGroupLevelIndicatorPaneStyle}" />
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/TableView.Windows7.Graphics.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/TableView.Windows7.Graphics.xaml
index cc58d12d..a3250856 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/TableView.Windows7.Graphics.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/TableView.Windows7.Graphics.xaml
@@ -17,15 +17,15 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the standard graphics -->
-      <utils:XceedResourceDictionary XceedSource="/Xceed.Wpf.DataGrid;component\themes/Common/Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../../Common/Graphics.xaml" />
 
       <!-- Needs Windows7 Resources -->
-      <ResourceDictionary Source="Windows7.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Windows7.Resources.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/Windows7.Controls.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/Windows7.Controls.xaml
index f9617b1b..1540eb3d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/Windows7.Controls.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/Resources/Windows7.Controls.xaml
@@ -17,12 +17,13 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     xmlns:s="clr-namespace:System;assembly=mscorlib"
-                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid">
+                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Windows7.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Windows7.Resources.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableView.Windows7.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableView.Windows7.xaml
index 52ce2918..b0a3d3eb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableView.Windows7.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableView.Windows7.xaml
@@ -20,22 +20,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Windows7.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Windows7.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Windows7.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Windows7.Graphics.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
       <!-- Control Styles used in the Grid Control -->
-      <ResourceDictionary Source="Resources/Windows7.Controls.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Windows7.Controls.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -314,11 +313,10 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewWindows7ColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
-      <ControlTemplate.Resources>
-         <conv:SortingDirectionToBooleanConverter x:Key="isSortedConverter" />
-      </ControlTemplate.Resources>
 
       <!-- We don't use the base Cell Template for the ColumnManagerCell because it need more elements
            to function properly: a Thumb named "PART_ColumnResizerThumb" that is used to resize the
@@ -412,7 +410,6 @@
                                    VerticalAlignment="Stretch"
                                    Margin="2,0,0,0"
                                    Opacity="0.5" />
-
                   </Grid>
 
                   <Grid HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
@@ -426,13 +423,15 @@
                      <!-- ContentPresenter that is used to display the sort glyph.
                         We explicitely set its Content property to Null to prevent the XAML parser
                         from implicitely setting it to its TemplatedParent's Content. -->
-                     <ContentPresenter x:Name="sortGlyphPresenter"
-                                       Content="{x:Null}"
-                                       ContentTemplate="{x:Null}"
-                                       TextElement.Foreground="#FFFFFFFF"
-                                       HorizontalAlignment="Center"
-                                       VerticalAlignment="Center"
-                                       Grid.Row="0" />
+                     <StackPanel Orientation="Horizontal"
+                                 Grid.Row="0"
+                                 VerticalAlignment="Center"
+                                 HorizontalAlignment="Center">
+                        <ContentPresenter x:Name="sortGlyphPresenter"
+                                          Content="{x:Null}"
+                                          ContentTemplate="{x:Null}"
+                                          TextElement.Foreground="#FFFFFFFF"/>
+                     </StackPanel>
 
                      <!-- Same ContentPresenter as in the base Cell Template. -->
                      <local:CellContentPresenter VerticalAlignment="Center"
@@ -1881,7 +1880,7 @@
           TargetType="local:DataGridControl">
 
       <Style.Resources>
-         <ResourceDictionary Source="Resources/Windows7.Controls.xaml" />
+         <markup:DataGridThemeResourceDictionary Source="Resources/Windows7.Controls.xaml" />
       </Style.Resources>
 
       <Setter Property="BorderBrush"
@@ -2014,7 +2013,7 @@
       <!-- The Row is responsible for drawing the horizontal gridlines. It draws only its top gridline,
            assuming that the bottom gridline will be drawn by its following row/element -->
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -2025,11 +2024,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -2127,15 +2129,24 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -2173,6 +2184,12 @@
       <Setter Property="Padding"
               Value="4,3,0,7" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewWindows7ColumnManagerCellTemplate}" />
 
@@ -2251,6 +2268,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{StaticResource rowSelectionBackgroundBrush}" />
+
+      <Setter Property="SelectionForeground"
+              Value="Black" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{StaticResource rowInactiveSelectionBackgroundBrush}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
@@ -2371,7 +2400,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableflowView.Windows7.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableflowView.Windows7.xaml
index 2a9c291b..fd2b5f2b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableflowView.Windows7.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Windows7/TableflowView.Windows7.xaml
@@ -20,22 +20,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Windows7.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Windows7.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Windows7.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Windows7.Graphics.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
       <!-- Control Styles used in the Grid Control -->
-      <ResourceDictionary Source="Resources/Windows7.Controls.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Windows7.Controls.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -541,11 +540,10 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewWindows7ColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
-      <ControlTemplate.Resources>
-         <conv:SortingDirectionToBooleanConverter x:Key="isSortedConverter" />
-      </ControlTemplate.Resources>
 
       <!-- We don't use the base Cell Template for the ColumnManagerCell because it need more elements
            to function properly: a Thumb named "PART_ColumnResizerThumb" that is used to resize the
@@ -639,7 +637,6 @@
                                    VerticalAlignment="Stretch"
                                    Margin="2,0,0,0"
                                    Opacity="0.5" />
-
                   </Grid>
 
                   <Grid HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
@@ -653,13 +650,15 @@
                      <!-- ContentPresenter that is used to display the sort glyph.
                         We explicitely set its Content property to Null to prevent the XAML parser
                         from implicitely setting it to its TemplatedParent's Content. -->
-                     <ContentPresenter x:Name="sortGlyphPresenter"
-                                       Content="{x:Null}"
-                                       ContentTemplate="{x:Null}"
-                                       TextElement.Foreground="#FFFFFFFF"
-                                       HorizontalAlignment="Center"
-                                       VerticalAlignment="Center"
-                                       Grid.Row="0" />
+                     <StackPanel Orientation="Horizontal"
+                                 Grid.Row="0"
+                                 VerticalAlignment="Center"
+                                 HorizontalAlignment="Center">
+                        <ContentPresenter x:Name="sortGlyphPresenter"
+                                          Content="{x:Null}"
+                                          ContentTemplate="{x:Null}"
+                                          TextElement.Foreground="#FFFFFFFF" />
+                     </StackPanel>
 
                      <!-- Same ContentPresenter as in the base Cell Template. -->
                      <local:CellContentPresenter VerticalAlignment="Center"
@@ -686,6 +685,16 @@
 
       <ControlTemplate.Triggers>
 
+         <!-- Trigger related to the filteringToggleButton-->
+         <Trigger SourceName="toggleButton"
+                  Property="IsMouseOver"
+                  Value="True">
+
+            <Setter TargetName="toggleButton"
+                    Property="Opacity"
+                    Value="1" />
+         </Trigger>
+
          <!-- The following 2 triggers allow to display the appropriate Sort Glyph
               depending on the ParentColumn's SortDirection. -->
 
@@ -1736,7 +1745,6 @@
 
    </ControlTemplate>
 
-
    <!--**************************
     * TEMPLATE: HierarchicalGroupByItem
     ************************** -->
@@ -1837,7 +1845,6 @@
 
    </ControlTemplate>
 
-
    <!--**************************
     * TEMPLATE: ColumnManagerRow 
     ************************** -->
@@ -2244,7 +2251,7 @@
 
       <!-- Include ControlTemplates of common controls -->
       <Style.Resources>
-         <ResourceDictionary Source="Resources/Windows7.Controls.xaml" />
+         <markup:DataGridThemeResourceDictionary Source="Resources/Windows7.Controls.xaml" />
       </Style.Resources>
 
       <Setter Property="BorderBrush"
@@ -2377,7 +2384,7 @@
       <!-- The Row is responsible for drawing the horizontal gridlines. It draws only its top gridline,
            assuming that the bottom gridline will be drawn by its following row/element -->
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -2388,11 +2395,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <!-- Enabled/Disabled Odd datarow style alternation -->
@@ -2488,15 +2498,24 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -2534,6 +2553,12 @@
       <Setter Property="Padding"
               Value="4,3,0,7" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewWindows7ColumnManagerCellTemplate}" />
 
@@ -2612,6 +2637,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{StaticResource rowSelectionBackgroundBrush}" />
+
+      <Setter Property="SelectionForeground"
+              Value="Black" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{StaticResource rowInactiveSelectionBackgroundBrush}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="views:TableView.CanScrollHorizontally"
               Value="False" />
 
@@ -2744,7 +2781,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/Resources/TableView.Zune.Graphics.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/Resources/TableView.Zune.Graphics.xaml
index d04e009c..78b5a5c9 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/Resources/TableView.Zune.Graphics.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/Resources/TableView.Zune.Graphics.xaml
@@ -16,12 +16,13 @@
 
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid">
+                    xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
+                    xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Zune uses the same graphics as Luna, so reuse the same ResourceDictionary. -->
-      <ResourceDictionary Source="../../Luna/Resources/TableView.Luna.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../../Luna/Resources/TableView.Luna.Graphics.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableView.Zune.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableView.Zune.normalcolor.xaml
index 8cf416ef..82fb9ba0 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableView.Zune.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableView.Zune.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Zune.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Zune.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Zune.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Zune.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Zune.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Zune.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -364,6 +363,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -425,6 +426,7 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
                               <!-- Same ContentPresenter as in the base Cell Template. -->
@@ -1064,7 +1066,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1169,7 +1171,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1180,11 +1182,14 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
             <Setter Property="Margin"
                     Value="0,0,0,5" />
          </DataTrigger>
@@ -1192,7 +1197,7 @@
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1282,18 +1287,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1328,6 +1342,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableViewColumnManagerCellTemplate}" />
 
@@ -1409,6 +1429,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1540,7 +1572,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
@@ -1653,7 +1685,6 @@
 
    </Style>
 
-
    <!--**************************
     * STYLE: ScrollTip
     ************************** -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableflowView.Zune.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableflowView.Zune.normalcolor.xaml
index 80822a0e..012793a7 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableflowView.Zune.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/Zune/TableflowView.Zune.normalcolor.xaml
@@ -19,22 +19,21 @@
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:conv="clr-namespace:Xceed.Wpf.DataGrid.Converters"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:utils="clr-namespace:Xceed.Utils.Wpf.Markup">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
 
       <!-- Include the view independant, color-scheme independant, theme resources -->
-      <ResourceDictionary Source="Resources/Zune.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Zune.Resources.xaml" />
 
       <!-- Include the view dependant, color-scheme independant, theme graphics -->
-      <ResourceDictionary Source="Resources/TableView.Zune.Graphics.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/TableView.Zune.Graphics.xaml" />
 
       <!-- Include the view independant, color-scheme dependant, theme resources -->
-      <ResourceDictionary Source="Resources/Zune.normalcolor.Resources.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="Resources/Zune.normalcolor.Resources.xaml" />
 
       <!-- Include the standard grid element templates -->
-      <ResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="../Common/TableflowView.GridElementTemplates.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
@@ -574,6 +573,8 @@
    <!--**************************
     * TEMPLATE: ColumnManagerCell 
     ************************** -->
+   <conv:SortingDirectionToBooleanConverter x:Key="SortingDirectionToBooleanConverter" />
+
    <ControlTemplate x:Key="tableflowViewColumnManagerCellTemplate"
                     TargetType="local:ColumnManagerCell">
 
@@ -615,7 +616,6 @@
                                       Focusable="False"
                                       Visibility="Collapsed"
                                       Margin="2,0,0,0" />
-
                      </Grid>
 
                   </Border>
@@ -635,6 +635,7 @@
                               <Grid.ColumnDefinitions>
                                  <ColumnDefinition Width="*" />
                                  <ColumnDefinition Width="Auto" />
+                                 <ColumnDefinition Width="Auto" />
                               </Grid.ColumnDefinitions>
 
                               <!-- Same ContentPresenter as in the base Cell Template. -->
@@ -1397,7 +1398,7 @@
       <Style.Resources>
          <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-               <ResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
+               <markup:FrameworkThemeResourceDictionary Source="/PresentationFramework.Luna;V4.0.0.0;31bf3856ad364e35;component\themes/luna.metallic.xaml" />
             </ResourceDictionary.MergedDictionaries>
          </ResourceDictionary>
       </Style.Resources>
@@ -1502,7 +1503,7 @@
            assuming that the bottom gridline will be drawn by its following row/element -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineBrush}" />
@@ -1513,17 +1514,20 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <Style.Triggers>
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(views:ViewBase.IsLastItem)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
          </DataTrigger>
 
          <DataTrigger Binding="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.HasExpandedDetails)}"
                       Value="True">
             <Setter Property="BorderThickness"
-                    Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Top, Bottom'}" />
+                    Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).HorizontalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Top, Bottom'}" />
 
          </DataTrigger>
 
@@ -1613,18 +1617,27 @@
       <Setter Property="Background"
               Value="Transparent" />
 
+      <Setter Property="Foreground"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentForeground}" />
+
       <!-- In TableflowView, each Cell has the same width as its ParentColum's ActualWidth -->
       <Setter Property="Width"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=ParentColumn.ActualWidth}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.ActualWidth}" />
 
       <Setter Property="Padding"
               Value="{StaticResource cellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <!-- The Cell is responsible for drawing the vertical gridlines. It draws only its right gridline, 
            assuming that the left gridline will have been drawn by its preceding cell -->
 
       <Setter Property="BorderThickness"
-              Value="{Binding RelativeSource={RelativeSource Self},Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness,Converter={StaticResource thicknessConverter},ConverterParameter='Right'}" />
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineThickness, Converter={StaticResource thicknessConverter}, ConverterParameter='Right'}" />
 
       <Setter Property="BorderBrush"
               Value="{Binding RelativeSource={RelativeSource Self}, Path=(local:DataGridControl.DataGridContext).VerticalGridLineBrush}" />
@@ -1659,6 +1672,12 @@
       <Setter Property="Padding"
               Value="{StaticResource columnManagerCellPadding}" />
 
+      <Setter Property="HorizontalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellHorizontalContentAlignment, FallbackValue=Stretch}" />
+
+      <Setter Property="VerticalContentAlignment"
+              Value="{Binding RelativeSource={RelativeSource Self}, Path=ParentColumn.CellVerticalContentAlignment, FallbackValue=Stretch}" />
+
       <Setter Property="Template"
               Value="{StaticResource tableflowViewColumnManagerCellTemplate}" />
 
@@ -1740,6 +1759,18 @@
       <Setter Property="Foreground"
               Value="{StaticResource headerForegroundBrush}" />
 
+      <Setter Property="SelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" />
+
+      <Setter Property="SelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.HighlightTextBrushKey}}" />
+
+      <Setter Property="InactiveSelectionBackground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionBrushKey}}" />
+
+      <Setter Property="InactiveSelectionForeground"
+              Value="{DynamicResource {x:Static SystemColors.InactiveCaptionTextBrushKey}}" />
+
       <Setter Property="BorderBrush"
               Value="{StaticResource gridLineBrush}" />
 
@@ -1885,7 +1916,7 @@
                   Value="-1">
 
             <!-- Stop the propagation of the value set by the default style trigger of
-                 the ColumnManagerRow . -->
+                 the ColumnManagerRow -->
             <Setter Property="local:GroupLevelIndicatorPane.ShowIndicators"
                     Value="True" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero.normalcolor.xaml
index e286b3f5..316e120c 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero.normalcolor.xaml
@@ -23,8 +23,8 @@
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml"/>
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml"/>
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -33,8 +33,9 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Aero/TableflowView.Aero.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Aero/TableView.Aero.normalcolor.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero/TableflowView.Aero.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero/TableView.Aero.normalcolor.xaml"/>
+
    </ResourceDictionary.MergedDictionaries>
 
    <!-- Generic theme for TableView -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero2.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero2.normalcolor.xaml
index 27940002..07bf18da 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero2.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/aero2.normalcolor.xaml
@@ -20,117 +20,205 @@
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
                     xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
-    <ResourceDictionary.MergedDictionaries>
-        <!-- Style definitions for specific controls (things that are not grid elements) -->
+   <ResourceDictionary.MergedDictionaries>
+      <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-        <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml"/>
-        <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml"/>
 
-        <!-- For each specific systeme theme ResourceDictionary, we only need to include 
+      <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
            we have include all xaml theme files of the product to make the forcing of a 
            theme work. And it works because, when the DefaultStyleKey is not found in the 
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-        <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Aero2/TableflowView.Aero2.normalcolor.xaml" />
-    </ResourceDictionary.MergedDictionaries>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero2/TableflowView.Aero2.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero2/TableView.Aero2.normalcolor.xaml"/>
 
-    <!-- Generic theme for TableflowView -->
+   </ResourceDictionary.MergedDictionaries>
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView}"
+   <!-- Generic theme for TableView -->
+
+   <!--<Style x:Key="{markup:ThemeKey TargetViewType=views:TableView}"
+          TargetType="views:TableView"
+          BasedOn="{StaticResource tableViewAero2NormalColorDefaultValues}" />
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:DataGridControl}"
+          TargetType="local:DataGridControl"
+          BasedOn="{StaticResource tableViewAero2NormalColorGridControlStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:RowSelectorPane}"
+          TargetType="local:RowSelectorPane"
+          BasedOn="{StaticResource tableViewAero2NormalColorRowSelectorPaneStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:RowSelector}"
+          TargetType="local:RowSelector"
+          BasedOn="{StaticResource tableViewAero2NormalColorRowSelectorStyle}" />
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:Row}"
+          TargetType="local:Row"
+          BasedOn="{StaticResource tableViewAero2NormalColorRowStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:DataRow}"
+          TargetType="local:DataRow"
+          BasedOn="{StaticResource tableViewAero2NormalColorDataRowStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:ColumnManagerRow}"
+          TargetType="local:ColumnManagerRow"
+          BasedOn="{StaticResource tableViewAero2NormalColorColumnManagerRowStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:Cell}"
+          TargetType="local:Cell"
+          BasedOn="{StaticResource tableViewAero2NormalColorCellStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:DataCell}"
+          TargetType="local:DataCell"
+          BasedOn="{StaticResource tableViewAero2NormalColorDataCellStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:ColumnManagerCell}"
+          TargetType="local:ColumnManagerCell"
+          BasedOn="{StaticResource tableViewAero2NormalColorColumnManagerCellStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:GroupByControl}"
+          TargetType="local:GroupByControl"
+          BasedOn="{StaticResource tableViewAero2NormalColorGroupByControlStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:GroupByItem}"
+          TargetType="local:GroupByItem"
+          BasedOn="{StaticResource tableViewAero2NormalColorGroupByItemStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:GroupHeaderControl}"
+          TargetType="local:GroupHeaderControl"
+          BasedOn="{StaticResource tableViewAero2NormalColorGroupHeaderControlStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:GroupLevelIndicator}"
+          TargetType="local:GroupLevelIndicator"
+          BasedOn="{StaticResource tableViewAero2NormalColorGroupLevelIndicatorStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:DetailIndicator}"
+          TargetType="local:DetailIndicator"
+          BasedOn="{StaticResource tableViewAero2NormalColorDetailIndicatorStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:HierarchicalGroupLevelIndicatorPane}"
+          TargetType="local:HierarchicalGroupLevelIndicatorPane"
+          BasedOn="{StaticResource tableViewAero2NormalColorHierarchicalGroupLevelIndicatorPaneStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:GroupLevelIndicatorPane}"
+          TargetType="local:GroupLevelIndicatorPane"
+          BasedOn="{StaticResource tableViewAero2NormalColorGroupLevelIndicatorPaneStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:ScrollTip}"
+          TargetType="local:ScrollTip"
+          BasedOn="{StaticResource tableViewAero2NormalColorScrollTipStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:HierarchicalGroupByControlNode}"
+          TargetType="local:HierarchicalGroupByControlNode"
+          BasedOn="{StaticResource tableViewAero2NormalColorHierarchicalGroupByControlNodeStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:HierarchicalGroupByControl}"
+          TargetType="local:HierarchicalGroupByControl"
+          BasedOn="{StaticResource tableViewAero2NormalColorHierarchicalGroupByControlStyle}"/>
+
+    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableView, TargetElementType=local:HierarchicalGroupByItem}"
+          TargetType="local:HierarchicalGroupByItem"
+          BasedOn="{StaticResource tableViewAero2NormalColorHierarchicalGroupByItemStyle}"/> -->
+
+   <!-- Generic theme for TableflowView -->
+
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView}"
           TargetType="views:TableflowView"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDefaultValues}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DataGridControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DataGridControl}"
           TargetType="local:DataGridControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGridControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:RowSelectorPane}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:RowSelectorPane}"
           TargetType="local:RowSelectorPane"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowSelectorPaneStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:RowSelector}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:RowSelector}"
           TargetType="local:RowSelector"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowSelectorStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:Row}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:Row}"
           TargetType="local:Row"
           BasedOn="{StaticResource tableflowViewAero2NormalColorRowStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DataRow}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DataRow}"
           TargetType="local:DataRow"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDataRowStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:ColumnManagerRow}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:ColumnManagerRow}"
           TargetType="local:ColumnManagerRow"
           BasedOn="{StaticResource tableflowViewAero2NormalColorColumnManagerRowStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:Cell}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:Cell}"
           TargetType="local:Cell"
           BasedOn="{StaticResource tableflowViewAero2NormalColorCellStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DataCell}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DataCell}"
           TargetType="local:DataCell"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDataCellStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:ColumnManagerCell}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:ColumnManagerCell}"
           TargetType="local:ColumnManagerCell"
           BasedOn="{StaticResource tableflowViewAero2NormalColorColumnManagerCellStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupByControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupByControl}"
           TargetType="local:GroupByControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupByControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupByItem}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupByItem}"
           TargetType="local:GroupByItem"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupByItemStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupHeaderControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupHeaderControl}"
           TargetType="local:GroupHeaderControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupHeaderControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupLevelIndicator}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupLevelIndicator}"
           TargetType="local:GroupLevelIndicator"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupLevelIndicatorStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DetailIndicator}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:DetailIndicator}"
           TargetType="local:DetailIndicator"
           BasedOn="{StaticResource tableflowViewAero2NormalColorDetailIndicatorStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupLevelIndicatorPane}"
-          TargetType="local:GroupLevelIndicatorPane"
-          BasedOn="{StaticResource tableflowViewAero2NormalColorGroupLevelIndicatorPaneStyle}" />
-
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupLevelIndicatorPane}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupLevelIndicatorPane}"
           TargetType="local:HierarchicalGroupLevelIndicatorPane"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupLevelIndicatorPaneStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:ScrollTip}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupLevelIndicatorPane}"
+          TargetType="local:GroupLevelIndicatorPane"
+          BasedOn="{StaticResource tableflowViewAero2NormalColorGroupLevelIndicatorPaneStyle}" />
+
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:ScrollTip}"
           TargetType="local:ScrollTip"
           BasedOn="{StaticResource tableflowViewAero2NormalColorScrollTipStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupByControlNode}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupByControlNode}"
           TargetType="local:HierarchicalGroupByControlNode"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupByControlNodeStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupByControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupByControl}"
           TargetType="local:HierarchicalGroupByControl"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupByControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupByItem}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:HierarchicalGroupByItem}"
           TargetType="local:HierarchicalGroupByItem"
           BasedOn="{StaticResource tableflowViewAero2NormalColorHierarchicalGroupByItemStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupNavigationButton}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupNavigationButton}"
           TargetType="{x:Type local:GroupNavigationButton}"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupNavigationButtonStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupNavigationControl}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupNavigationControl}"
           TargetType="{x:Type local:GroupNavigationControl}"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupNavigationControlStyle}" />
 
-    <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupNavigationControlItem}"
+   <Style x:Key="{markup:ThemeKey TargetViewType=views:TableflowView, TargetElementType=local:GroupNavigationControlItem}"
           TargetType="{x:Type local:GroupNavigationControlItem}"
           BasedOn="{StaticResource tableflowViewAero2NormalColorGroupNavigationControlItemStyle}" />
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/classic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/classic.xaml
index 7ab4e629..3c1da49d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/classic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/classic.xaml
@@ -23,8 +23,8 @@
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml"/>
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml"/>
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -33,8 +33,9 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Classic/TableflowView.Classic.systemcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Classic/TableView.Classic.systemcolor.xaml"/>
+      <markup:DataGridThemeResourceDictionary Source="/themes/Classic/TableflowView.Classic.systemcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Classic/TableView.Classic.systemcolor.xaml"/>
+
    </ResourceDictionary.MergedDictionaries>
 
    <!-- Generic theme for TableView -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/generic.xaml
index 14b9b2b8..09f861ac 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/generic.xaml
@@ -18,14 +18,13 @@
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     xmlns:local="clr-namespace:Xceed.Wpf.DataGrid"
                     xmlns:markup="clr-namespace:Xceed.Wpf.DataGrid.Markup"
-                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views"
-                    xmlns:print="clr-namespace:Xceed.Wpf.DataGrid.Print">
+                    xmlns:views="clr-namespace:Xceed.Wpf.DataGrid.Views">
 
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml" />
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -34,35 +33,38 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Aero/TableflowView.Aero.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Aero/TableView.Aero.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero/TableflowView.Aero.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero/TableView.Aero.normalcolor.xaml" />
 
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Classic/TableflowView.Classic.systemcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Classic/TableView.Classic.systemcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Classic/TableflowView.Classic.systemcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Classic/TableView.Classic.systemcolor.xaml" />
 
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableflowView.Luna.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableView.Luna.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableflowView.Luna.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableView.Luna.normalcolor.xaml" />
 
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableflowView.Luna.homestead.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableView.Luna.homestead.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableflowView.Luna.homestead.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableView.Luna.homestead.xaml" />
 
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableflowView.Luna.metallic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableView.Luna.metallic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableflowView.Luna.metallic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableView.Luna.metallic.xaml" />
 
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Royale/TableflowView.Royale.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Royale/TableView.Royale.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Royale/TableflowView.Royale.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Royale/TableView.Royale.normalcolor.xaml" />
 
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Zune/TableflowView.Zune.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Zune/TableView.Zune.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Zune/TableflowView.Zune.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Zune/TableView.Zune.normalcolor.xaml" />
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Windows7/TableflowView.Windows7.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Windows7/TableView.Windows7.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Windows7/TableflowView.Windows7.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Windows7/TableView.Windows7.xaml" />
+
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero2/TableflowView.Aero2.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Aero2/TableView.Aero2.normalcolor.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.homestead.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.homestead.xaml
index 8610113d..0b5bb85f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.homestead.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.homestead.xaml
@@ -23,8 +23,8 @@
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml" />
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -33,8 +33,8 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableflowView.Luna.homestead.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableView.Luna.homestead.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableflowView.Luna.homestead.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableView.Luna.homestead.xaml" />
 
    </ResourceDictionary.MergedDictionaries>
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.metallic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.metallic.xaml
index 23de20e4..f1893424 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.metallic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.metallic.xaml
@@ -23,8 +23,8 @@
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml" />
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -33,8 +33,9 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableflowView.Luna.metallic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableView.Luna.metallic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableflowView.Luna.metallic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableView.Luna.metallic.xaml" />
+
    </ResourceDictionary.MergedDictionaries>
 
    <!-- Generic theme for TableView -->
@@ -221,5 +222,4 @@
           TargetType="{x:Type local:GroupNavigationControlItem}"
           BasedOn="{StaticResource tableflowViewLunaMetallicGroupNavigationControlItemStyle}" />
 
-
 </ResourceDictionary>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.normalcolor.xaml
index 5138ae3d..4dafadcb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/luna.normalcolor.xaml
@@ -23,8 +23,8 @@
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml" />
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -33,8 +33,9 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableflowView.Luna.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Luna/TableView.Luna.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableflowView.Luna.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Luna/TableView.Luna.normalcolor.xaml" />
+
    </ResourceDictionary.MergedDictionaries>
 
    <!-- Generic theme for TableView -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/royale.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/royale.normalcolor.xaml
index 64913c8d..26796eb1 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/royale.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/royale.normalcolor.xaml
@@ -23,8 +23,8 @@
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml" />
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -33,8 +33,9 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Royale/TableflowView.Royale.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Royale/TableView.Royale.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Royale/TableflowView.Royale.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Royale/TableView.Royale.normalcolor.xaml" />
+
    </ResourceDictionary.MergedDictionaries>
 
    <!-- Generic theme for TableView -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/zune.normalcolor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/zune.normalcolor.xaml
index 33ae60cc..322f7d20 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/zune.normalcolor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/themes/zune.normalcolor.xaml
@@ -23,8 +23,8 @@
    <ResourceDictionary.MergedDictionaries>
       <!-- Style definitions for specific controls (things that are not grid elements) -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/FixedColumnSplitter.generic.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Controls/TableViewScrollViewer.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/FixedColumnSplitter.generic.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Controls/TableViewScrollViewer.generic.xaml" />
 
       <!-- For each specific systeme theme ResourceDictionary, we only need to include 
            the xaml associated to the theme (to make the "BasedOn" work). However, here 
@@ -33,8 +33,9 @@
            specific ResourceDictionary, WPF looks in the generic.xaml ResourceDictionary. 
            That way, we don't have to maintain this list in all the xaml files. -->
 
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Zune/TableflowView.Zune.normalcolor.xaml" />
-      <ResourceDictionary Source="/Xceed.Wpf.DataGrid;;;component\themes/Zune/TableView.Zune.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Zune/TableflowView.Zune.normalcolor.xaml" />
+      <markup:DataGridThemeResourceDictionary Source="/themes/Zune/TableView.Zune.normalcolor.xaml" />
+
    </ResourceDictionary.MergedDictionaries>
 
    <!-- Generic theme for TableView -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DataGridView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DataGridView.xaml.txt
index ee3841e4..b7cb3f8f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DataGridView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DataGridView.xaml.txt
@@ -97,7 +97,8 @@
         </Grid.Resources>
 
         <xcdg:DataGridControl x:Name="_dataGrid"
-                            ItemsSource="{Binding Source={StaticResource cvsOrders}}" >           
+                            ItemsSource="{Binding Source={StaticResource cvsOrders}}" 
+                              AllowDrag="True">           
             <xcdg:DataGridControl.View>
                 <xcdg:TableflowView FixedColumnCount="2" />
             </xcdg:DataGridControl.View>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DateTimeView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DateTimeView.xaml.txt
index 135d7669..70b2bcf7 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DateTimeView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/DateTimeView.xaml.txt
@@ -47,6 +47,11 @@
                 <x:Type TypeName="Visibility" />
             </ObjectDataProvider.MethodParameters>
         </ObjectDataProvider>
+       <ObjectDataProvider x:Key="enumKind" MethodName="GetValues" ObjectType="{x:Type sys:Enum}">
+            <ObjectDataProvider.MethodParameters>
+                <x:Type TypeName="sys:DateTimeKind" />
+            </ObjectDataProvider.MethodParameters>
+        </ObjectDataProvider>
     </local:DemoView.Resources>
     <Grid>
         <Grid.RowDefinitions>
@@ -68,6 +73,7 @@
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
+               <RowDefinition Height="Auto" />
             </Grid.RowDefinitions>
             <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
@@ -86,10 +92,12 @@
             <CheckBox x:Name="_autoCloseCalendar" Grid.Row="3" Grid.Column="1" IsChecked="False" VerticalAlignment="Center" Margin="5,5,25,5"/>    
             <TextBlock Text="ClipValueToMinMax:" Grid.Row="4" Grid.Column="0" VerticalAlignment="Center"/>
             <CheckBox x:Name="_clipValueToMinMax" Grid.Row="4" Grid.Column="1" IsChecked="False" VerticalAlignment="Center" Margin="5,5,25,5"/>
-            <TextBlock Text="TimePickerVisibility:" Grid.Row="5" Grid.Column="0" VerticalAlignment="Center"/>
-            <ComboBox x:Name="_timePickerVisibility" Grid.Row="5" Grid.Column="1" SelectedIndex="0" ItemsSource="{Binding Source={StaticResource enumVisibility}}" Width="190" Margin="5,5,25,5"/>
-            <TextBlock Text="TimePickerShowButtonSpinner:" Grid.Row="6" Grid.Column="0" VerticalAlignment="Center"/>
-            <CheckBox x:Name="_timePickerShowButtonSpinner" Grid.Row="6" Grid.Column="1" IsChecked="True" VerticalAlignment="Center" Margin="5,5,25,5"/>
+            <TextBlock Text="Kind:" Grid.Row="5" Grid.Column="0" VerticalAlignment="Center"/>
+            <ComboBox x:Name="_kind" Grid.Row="5" Grid.Column="1" SelectedIndex="2" ItemsSource="{Binding Source={StaticResource enumKind}}" Width="190" Margin="5,5,25,5"/>
+             <TextBlock Text="TimePickerVisibility:" Grid.Row="6" Grid.Column="0" VerticalAlignment="Center"/>
+            <ComboBox x:Name="_timePickerVisibility" Grid.Row="6" Grid.Column="1" SelectedIndex="0" ItemsSource="{Binding Source={StaticResource enumVisibility}}" Width="190" Margin="5,5,25,5"/>
+            <TextBlock Text="TimePickerShowButtonSpinner:" Grid.Row="7" Grid.Column="0" VerticalAlignment="Center"/>
+            <CheckBox x:Name="_timePickerShowButtonSpinner" Grid.Row="7" Grid.Column="1" IsChecked="True" VerticalAlignment="Center" Margin="5,5,25,5"/>
 
             <TextBlock Text="TimeFormat:" Grid.Row="0" Grid.Column="2" VerticalAlignment="Center" />
             <ComboBox x:Name="_timeFormat" Grid.Row="0" Grid.Column="3" SelectedIndex="1" ItemsSource="{Binding Source={StaticResource enumTimeFormatData}}" Width="190" Margin="5"/>
@@ -121,7 +129,8 @@
                                  TimePickerVisibility="{Binding Source={x:Reference _timePickerVisibility}, Path=SelectedItem}"
                                  TimePickerShowButtonSpinner="{Binding IsChecked, ElementName=_timePickerShowButtonSpinner}"
                                  Minimum="{Binding Value, ElementName=_minimum}"
-                                 Maximum="{Binding Value, ElementName=_maximum}"/>
+                                 Maximum="{Binding Value, ElementName=_maximum}"
+                                 Kind="{Binding SelectedItem, ElementName=_kind}"/>
         </StackPanel>
 
         <StackPanel Grid.Row="1" Grid.Column="1" HorizontalAlignment="Stretch">
@@ -131,6 +140,7 @@
                         <RowDefinition Height="Auto" />
                         <RowDefinition Height="Auto" />
                         <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
                     </Grid.RowDefinitions>
                     <Grid.ColumnDefinitions>
                         <ColumnDefinition Width="Auto"/>
@@ -143,10 +153,12 @@
                     <xctk:DateTimeUpDown x:Name="_endTime" Grid.Row="1" Grid.Column="1" Format="ShortTime" Value="17:00" Width="100" Margin="5"/>
                     <TextBlock Text="TimeInterval:" Grid.Row="2" VerticalAlignment="Center" />
                     <xctk:DateTimeUpDown x:Name="_timeInterval" Grid.Row="2" Grid.Column="1" Format="Custom" FormatString="H:mm" Value="0:30" Width="100" Margin="5"/>
-                </Grid>
-            </GroupBox>
+                    <TextBlock Grid.Row="3" Text="MaxDropDownHeight:" VerticalAlignment="Center" />
+                    <xctk:DoubleUpDown x:Name="_maxDropDownHeight" Grid.Row="3" Grid.Column="1" Width="100" Value="130" DefaultValue="130" AllowInputSpecialValues="PositiveInfinity" Minimum="0" />
+                 </Grid>
+              </GroupBox>
 
-            <StackPanel>
+              <StackPanel>
                 <TextBlock Text="TimePicker Usage: " Style="{StaticResource Header}" />
                 <xctk:TimePicker x:Name="_timePicker"
                                  VerticalAlignment="Top"
@@ -158,8 +170,9 @@
                                  TimeInterval="{Binding Source={x:Reference _timeInterval}, Path=Value, Converter={StaticResource dateTimeToTimeSpanConverter}}"
                                  ClipValueToMinMax="{Binding IsChecked, ElementName=_clipValueToMinMax}"
                                  Minimum="{Binding Value, ElementName=_minimum}"
-                                 Maximum="{Binding Value, ElementName=_maximum}"/>
-         </StackPanel>
+                                 Maximum="{Binding Value, ElementName=_maximum}"
+                                 MaxDropDownHeight="{Binding Value, ElementName=_maxDropDownHeight}"/>
+           </StackPanel>
         </StackPanel>
     </Grid>
 </local:DemoView>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/NumericView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/NumericView.xaml.txt
index a422bd53..e383b8ff 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/NumericView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/NumericView.xaml.txt
@@ -45,7 +45,9 @@
             <numeric:FormatObject Value="P2" DisplayValue="Percent" />
         </x:Array>
 
-        <DataTemplate x:Key="FormatStringItemTemplate">
+        <xctk:InverseBoolConverter x:Key="InverseBoolConverter" />
+
+         <DataTemplate x:Key="FormatStringItemTemplate">
             <TextBlock Text="{Binding DisplayValue}" />
         </DataTemplate>
 
@@ -54,6 +56,12 @@
                 <x:Type TypeName="xctk:AllowedSpecialValues" />
             </ObjectDataProvider.MethodParameters>
         </ObjectDataProvider>
+       
+        <ObjectDataProvider x:Key="ButtonSpinnerLocationComboBox" MethodName="GetValues" ObjectType="{x:Type sys:Enum}">
+            <ObjectDataProvider.MethodParameters>
+                <x:Type TypeName="xctk:Location" />
+            </ObjectDataProvider.MethodParameters>
+        </ObjectDataProvider>
 
         <ObjectDataProvider x:Key="ParsingNumberStyleComboBox" MethodName="GetValues" ObjectType="{x:Type sys:Enum}">
             <ObjectDataProvider.MethodParameters>
@@ -96,6 +104,7 @@
                        <RowDefinition Height="Auto" />
                        <RowDefinition Height="Auto" />
                        <RowDefinition Height="Auto" />
+                       <RowDefinition Height="Auto" />
                     </Grid.RowDefinitions>
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="Auto" />
@@ -117,18 +126,23 @@
 
                    <TextBlock Text="Show Button Spinner:" Grid.Row="1" VerticalAlignment="Center" />
                    <CheckBox Grid.Row="1" Grid.Column="1" IsChecked="{Binding ShowButtonSpinner, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center" />
+                  
+                   <TextBlock Text="Is Read Only:" Grid.Row="2" VerticalAlignment="Center" ToolTip="Prevent from using button spinners or editing text." />
+                   <CheckBox Grid.Row="2" Grid.Column="1" IsChecked="{Binding IsReadOnly, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center" />
 
-                   <TextBlock Text="Allow Spin:" Grid.Row="2" VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="2" Grid.Column="1" IsChecked="{Binding AllowSpin, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center" />
-
-                   <TextBlock Text="Clip Value to Min Max:" Grid.Row="3"  VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="3" Grid.Column="1" IsChecked="{Binding ClipValueToMinMax, ElementName=_doubleUpDown, Mode=TwoWay}" ClickMode="Press" Margin="5" VerticalAlignment="Center"/>
-
-                   <TextBlock Text="Is Read Only:" Grid.Row="4" VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="4" Grid.Column="1" IsChecked="{Binding IsReadOnly, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center" />
+                   <TextBlock Text="Allow Spin:" Grid.Row="3" VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="3" Grid.Column="1" IsChecked="{Binding AllowSpin, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center"
+                             IsEnabled="{Binding IsReadOnly, ElementName=_doubleUpDown, Converter={StaticResource InverseBoolConverter}}" />
+                  
+                   <TextBlock Text="Allow TextInput:" Grid.Row="4" VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="4" Grid.Column="1" IsChecked="{Binding AllowTextInput, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center"
+                             IsEnabled="{Binding IsReadOnly, ElementName=_doubleUpDown, Converter={StaticResource InverseBoolConverter}}"/>
                   
-                   <TextBlock Text="DisplayDefaultValueOnEmptyText:" Grid.Row="5" VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="5" Grid.Column="1" IsChecked="{Binding DisplayDefaultValueOnEmptyText, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center" />
+                   <TextBlock Text="Clip Value to Min Max:" Grid.Row="5"  VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="5" Grid.Column="1" IsChecked="{Binding ClipValueToMinMax, ElementName=_doubleUpDown, Mode=TwoWay}" ClickMode="Press" Margin="5" VerticalAlignment="Center"/>
+                  
+                   <TextBlock Text="DisplayDefaultValueOnEmptyText:" Grid.Row="6" VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="6" Grid.Column="1" IsChecked="{Binding DisplayDefaultValueOnEmptyText, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center" />
 
                     <!-- 2nd column -->
                    <TextBlock Grid.Column="2" Text="CultureInfo:" VerticalAlignment="Center" Margin="10,0,0,0" />
@@ -145,27 +159,30 @@
 
                    <TextBlock Grid.Column="2" Grid.Row="4" Text="Maximum" VerticalAlignment="Center" Margin="10,0,0,0"/>
                    <xctk:DoubleUpDown Grid.Column="3" Grid.Row="4" Value="{Binding Maximum, ElementName=_doubleUpDown}" AllowInputSpecialValues="PositiveInfinity" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
-
+     
                    <!-- 3rd column -->
-                   <TextBlock Grid.Column="4" Text="ParsingNumberStyle:" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <ComboBox Grid.Column="5" ItemsSource="{Binding Source={StaticResource ParsingNumberStyleComboBox}}" SelectedValue="{Binding ParsingNumberStyle, ElementName=_doubleUpDown}" ToolTip="{StaticResource parsingNumberStyleTooltip}" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Grid.Column="4" Text="ButtonSpinnerLocation:" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <ComboBox Grid.Column="5" ItemsSource="{Binding Source={StaticResource ButtonSpinnerLocationComboBox}}" SelectedValue="{Binding ButtonSpinnerLocation, ElementName=_doubleUpDown}" HorizontalAlignment="Stretch" Margin="5" />
+                  
+                   <TextBlock Grid.Column="4" Grid.Row="1" Text="ParsingNumberStyle:" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <ComboBox Grid.Column="5" Grid.Row="1" ItemsSource="{Binding Source={StaticResource ParsingNumberStyleComboBox}}" SelectedValue="{Binding ParsingNumberStyle, ElementName=_doubleUpDown}" ToolTip="{StaticResource parsingNumberStyleTooltip}" HorizontalAlignment="Stretch" Margin="5" />
 
-                   <TextBlock Text="Watermark:" Grid.Column="4" Grid.Row="1" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <TextBox Grid.Column="5" Grid.Row="1" HorizontalAlignment="Stretch" Margin="5" Text="{Binding Watermark, ElementName=_doubleUpDown}" />
+                   <TextBlock Text="Watermark:" Grid.Column="4" Grid.Row="2" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <TextBox Grid.Column="5" Grid.Row="2" HorizontalAlignment="Stretch" Margin="5" Text="{Binding Watermark, ElementName=_doubleUpDown}" />
 
-                   <TextBlock Text="Default Value:" Grid.Column="4" Grid.Row="2" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="2" Value="{Binding DefaultValue, ElementName=_doubleUpDown}" AllowInputSpecialValues="Any" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Text="Default Value:" Grid.Column="4" Grid.Row="3" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="3" Value="{Binding DefaultValue, ElementName=_doubleUpDown}" AllowInputSpecialValues="Any" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
 
-                   <TextBlock Text="Value:" Grid.Column="4" Grid.Row="3" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="3" Value="{Binding Value, ElementName=_doubleUpDown, ValidatesOnExceptions=True}" AllowInputSpecialValues="Any" Style="{StaticResource ControlInError}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Text="Value:" Grid.Column="4" Grid.Row="4" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="4" Value="{Binding Value, ElementName=_doubleUpDown, ValidatesOnExceptions=True}" AllowInputSpecialValues="Any" Style="{StaticResource ControlInError}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
 
-                   <TextBlock Text="Text:" Grid.Column="4" Grid.Row="4" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <TextBox Grid.Column="5" Grid.Row="4" Text="{Binding Text, ElementName=_doubleUpDown}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Text="Text:" Grid.Column="4" Grid.Row="5" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <TextBox Grid.Column="5" Grid.Row="5" Text="{Binding Text, ElementName=_doubleUpDown}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
                    
                    <!-- last rows -->
-                   <TextBlock Text="(DoubleUpDown and SingleUpDown support the AllowInputSpecialValues property)" Grid.Row="6" Grid.ColumnSpan="6" VerticalAlignment="Center" Margin="0,5,0,0"/>
-                   <TextBlock Text="Allow Input Special Values:" VerticalAlignment="Center" Grid.Row="7" Grid.ColumnSpan="2"/>
-                   <ComboBox Grid.Column="2" Grid.Row="7" Grid.ColumnSpan="2" ItemsSource="{Binding Source={StaticResource AllowInputSpecialValuesComboBox}}" SelectedValue="{Binding AllowInputSpecialValues, ElementName=_doubleUpDown}" ToolTip="{StaticResource allowInputSpecialValuesTooltip}" Margin="5" Width="108"/>
+                   <TextBlock Text="(DoubleUpDown and SingleUpDown support the AllowInputSpecialValues property)" Grid.Row="7" Grid.ColumnSpan="6" VerticalAlignment="Center" Margin="0,5,0,0"/>
+                   <TextBlock Text="Allow Input Special Values:" VerticalAlignment="Center" Grid.Row="8" Grid.ColumnSpan="2"/>
+                   <ComboBox Grid.Column="2" Grid.Row="8" Grid.ColumnSpan="2" ItemsSource="{Binding Source={StaticResource AllowInputSpecialValuesComboBox}}" SelectedValue="{Binding AllowInputSpecialValues, ElementName=_doubleUpDown}" ToolTip="{StaticResource allowInputSpecialValuesTooltip}" Margin="5" Width="108"/>
                 </Grid>
            </GroupBox>
 
@@ -177,6 +194,7 @@
                                   ClipValueToMinMax="False"
                                   ShowButtonSpinner="True" 
                                   AllowSpin="True"
+                                  AllowTextInput="True"
                                   IsReadOnly="False" 
                                   MouseWheelActiveOnFocus="True"
                                   CultureInfo="en-US"
@@ -185,6 +203,7 @@
                                   Maximum="100"
                                   Minimum="0"
                                   DisplayDefaultValueOnEmptyText="False"
+                                  ButtonSpinnerLocation="Right"
                                   ParsingNumberStyle="Any"
                                   Watermark="Enter Text"
                                   DefaultValue="10"
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.cs.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.cs.txt
index 566f8e74..e9971830 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.cs.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.cs.txt
@@ -46,7 +46,6 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.PropertyGrid.Views
       };
 
       this.DataContext = person;
-
     }
   }
 
@@ -64,11 +63,14 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.PropertyGrid.Views
     [Category( "Information" )]
     [Description( "This property uses the [DisplayName(\"Is a Men\")] attribute to customize the name of this property." )]
     [DisplayName( "Is male" )]
-    public bool IsMale { get; protected set; }
+    public bool IsMale { get; set; }
 
     [Category( "Information" )]
-    [Description( "This property uses the [Editor(..)] attribute to provide a custom editor using the 'FirstNameEditor' class" )]
+    [Description( "This property uses the [Editor(..)] attribute to provide a custom editor using the 'FirstNameEditor' class. In the Plus version, it also depends on the IsMale property to change its foreground and source." )]
     [Editor( typeof( FirstNameEditor ), typeof( FirstNameEditor ) )]
+#if !OPEN_SOURCE
+    [DependsOn( "IsMale" )]
+#endif
     public string FirstName { get; set; }
 
     [Category( "Information" )]
@@ -153,17 +155,36 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.PropertyGrid.Views
   {
     public FrameworkElement ResolveEditor( Xceed.Wpf.Toolkit.PropertyGrid.PropertyItem propertyItem )
     {
+#if !OPEN_SOURCE
+      ComboBox comboBox = new ComboBox();
+      if( ( ( Person )propertyItem.Instance ).IsMale )
+      {
+        comboBox.Foreground = new SolidColorBrush( Colors.Green );
+        comboBox.ItemsSource = new List<string>() {"Tom", "Mark", "Bryan"};
+      }
+      else
+      {
+        comboBox.Foreground = new SolidColorBrush( Colors.Red );
+        comboBox.ItemsSource = new List<string>() { "Kathy", "Christine", "Tammy" };
+      }
+      comboBox.SelectedIndex = 0;
+#else
       TextBox textBox = new TextBox();
       textBox.Background = new SolidColorBrush( Colors.Red );
-
+#endif
       //create the binding from the bound property item to the editor
       var _binding = new Binding( "Value" ); //bind to the Value property of the PropertyItem
       _binding.Source = propertyItem;
       _binding.ValidatesOnExceptions = true;
       _binding.ValidatesOnDataErrors = true;
       _binding.Mode = propertyItem.IsReadOnly ? BindingMode.OneWay : BindingMode.TwoWay;
+#if !OPEN_SOURCE
+      BindingOperations.SetBinding( comboBox, ComboBox.SelectedItemProperty, _binding );
+      return comboBox;
+#else
       BindingOperations.SetBinding( textBox, TextBox.TextProperty, _binding );
       return textBox;
+#endif
     }
   }
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.txt
index 58d28838..2b34bdbd 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridAttributesView.xaml.txt
@@ -55,6 +55,8 @@
          <LineBreak/>
          <LineBreak/>
          Plus edition Only:
+         <LineBreak />
+         DependsOnAttribute
          <LineBreak/>
          (Not demoed here. See corresponding samples)
          <LineBreak />
@@ -89,7 +91,8 @@
       </StackPanel>
       
       <xctk:PropertyGrid Grid.Row="1" x:Name="_propertyGrid" Width="450" MaxHeight="650" Margin="10" 
-                         SelectedObject="{Binding}">
+                         SelectedObject="{Binding}"
+                         ShowDescriptionByTooltip="True">
       </xctk:PropertyGrid>      
       
    </Grid>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridPropertiesSourceView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridPropertiesSourceView.xaml.txt
index 453a7b23..6d1718a0 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridPropertiesSourceView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/PropertyGridPropertiesSourceView.xaml.txt
@@ -86,7 +86,7 @@
          </xctk:PropertyGrid.Resources>
          
          <xctk:PropertyGrid.EditorDefinitions>
-            <!-- The property with the name "SecondText" will have this special editor. -->
+            <!-- The property with the name "Second string" will have this special editor. -->
             <xctk:EditorTextDefinition TargetProperties="Second string"
                                        FontStyle="Italic"
                                        FontWeight="Bold" >
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RadialGaugeView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RadialGaugeView.xaml.txt
index 695125bb..79a676a1 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RadialGaugeView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RadialGaugeView.xaml.txt
@@ -452,7 +452,7 @@
                                  <ToolTip.Template>
                                     <ControlTemplate TargetType="{x:Type ToolTip}">
                                        <ContentPresenter Content="{Binding ActualValue, RelativeSource={RelativeSource AncestorType={x:Type xctk:RadialGauge}}}"
-                                                         ContentTemplate="{Binding PointerTooltipTemplate, RelativeSource={RelativeSource AncestorType={x:Type xctk:RadialGauge}}, TargetNullValue={StaticResource DefaultPointerTooltipTemplate}}" />
+                                                         ContentTemplate="{Binding PointerTooltipTemplate, RelativeSource={RelativeSource AncestorType={x:Type xctk:RadialGauge}}}" />
                                     </ControlTemplate>
                                  </ToolTip.Template>
                               </ToolTip>
@@ -1007,4 +1007,4 @@
     <Image Source="..\OpenSourceImages\Gauge.png" Width="600" Height="400"/>
    ##END-->
 
-</local:DemoView>
\ No newline at end of file
+</local:DemoView>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.cs.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.cs.txt
index 20ad2985..8b375314 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.cs.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.cs.txt
@@ -17,6 +17,8 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
+using System.Windows.Controls;
+using System.Windows.Media;
 
 namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.RangeSlider.Views
 {
@@ -29,5 +31,32 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.RangeSlider.Views
     {
       InitializeComponent();
     }
+
+    private void RangeStyleComboBox_SelectionChanged( object sender, SelectionChangedEventArgs e )
+    {
+      if( e.AddedItems.Count > 0 && e.AddedItems[ 0 ] is ComboBoxItem)
+      {
+        ComboBoxItem item = e.AddedItems[ 0 ] as ComboBoxItem;
+        //A style different from null is chosen
+        if( item.Tag != null )
+        {
+          //LowerRangeBackground is Transparent, force a color
+          if( object.Equals( sender, lowerRangeStyleComboBox ) && ((SolidColorBrush)_rangeSlider.LowerRangeBackground).Color.Equals( Colors.Transparent) )
+          {
+            _rangeSlider.LowerRangeBackground = new SolidColorBrush( Colors.Green );
+          }
+          //RangeBackground is Transparent, force a color
+          else if( object.Equals( sender, rangeStyleComboBox ) && ( ( SolidColorBrush )_rangeSlider.RangeBackground ).Color.Equals( Colors.Transparent ) )
+          {
+            _rangeSlider.RangeBackground = new SolidColorBrush( Colors.Blue );
+          }
+          //HigherRangeBackground is Transparent, force a color
+          else if( object.Equals( sender, higherRangeStyleComboBox ) && ( ( SolidColorBrush )_rangeSlider.HigherRangeBackground ).Color.Equals( Colors.Transparent ) )
+          {
+            _rangeSlider.HigherRangeBackground = new SolidColorBrush( Colors.Green );
+          }
+        }
+      }
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.txt
index 7a67d9b2..24377799 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/RangeSliderView.xaml.txt
@@ -18,14 +18,12 @@
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:sys="clr-namespace:System;assembly=mscorlib"
                 xmlns:local="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer"
-                xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer.Samples.RangeSlider.Converters"
                 xmlns:xctkconv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters;assembly=Xceed.Wpf.Toolkit"
                 xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
                 Title="RangeSlider">
 
    <local:DemoView.Resources>
 
-      <conv:IntegerToBoolConverter x:Key="IntegerToBoolConverter" />
       <xctkconv:SolidColorBrushToColorConverter x:Key="SolidColorBrushToColorConverter" />
 
       <Style x:Key="LowerRangeStyle1"
@@ -36,7 +34,6 @@
                <ControlTemplate  TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -71,7 +68,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Ellipse Fill="Black"/>
                      <Ellipse x:Name="MainBorder"
                               Fill="{TemplateBinding Background}"
                               Opacity="1" />
@@ -106,7 +102,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="19">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -173,7 +168,6 @@
                <ControlTemplate  TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -202,7 +196,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Ellipse Fill="Black" />
                      <Ellipse x:Name="MainBorder"
                               Fill="{TemplateBinding Background}" />
                   </Grid>
@@ -230,7 +223,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="19">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -301,7 +293,6 @@
                <ControlTemplate  TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -336,7 +327,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Ellipse Fill="Black" />
                      <Ellipse x:Name="MainBorder"
                               Fill="{TemplateBinding Background}"
                               Opacity="1" />
@@ -372,7 +362,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="19">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -566,7 +555,6 @@
                        Margin="10,5,5,5" />
             <xctk:ColorPicker Grid.Row="2"
                               Grid.Column="3"
-                              IsEnabled="{Binding SelectedIndex, ElementName=lowerRangeStyleComboBox, Converter={StaticResource IntegerToBoolConverter}}"
                               SelectedColor="{Binding LowerRangeBackground, ElementName=_rangeSlider, Converter={StaticResource SolidColorBrushToColorConverter}}"
                               VerticalAlignment="Center"
                               Margin="5" />
@@ -578,7 +566,6 @@
                        Margin="10,5,5,5" />
             <xctk:ColorPicker Grid.Row="3"
                               Grid.Column="3"
-                              IsEnabled="{Binding SelectedIndex, ElementName=rangeStyleComboBox, Converter={StaticResource IntegerToBoolConverter}}"
                               SelectedColor="{Binding RangeBackground, ElementName=_rangeSlider, Converter={StaticResource SolidColorBrushToColorConverter}}"
                               VerticalAlignment="Center"
                               Margin="5" />
@@ -590,7 +577,6 @@
                        Margin="10,5,5,5" />
             <xctk:ColorPicker Grid.Row="4"
                               Grid.Column="3"
-                              IsEnabled="{Binding SelectedIndex, ElementName=higherRangeStyleComboBox, Converter={StaticResource IntegerToBoolConverter}}"
                               SelectedColor="{Binding HigherRangeBackground, ElementName=_rangeSlider, Converter={StaticResource SolidColorBrushToColorConverter}}"
                               VerticalAlignment="Center"
                               Margin="5" />
@@ -605,6 +591,7 @@
                       SelectedIndex="0"
                       SelectedValue="{Binding LowerRangeStyle, ElementName=_rangeSlider}"
                       SelectedValuePath="Tag"
+                      SelectionChanged="RangeStyleComboBox_SelectionChanged"
                       VerticalAlignment="Center"
                       Margin="5">
                <ComboBoxItem Content="Default"
@@ -628,6 +615,7 @@
                       SelectedIndex="0"
                       SelectedValue="{Binding RangeStyle, ElementName=_rangeSlider}"
                       SelectedValuePath="Tag"
+                      SelectionChanged="RangeStyleComboBox_SelectionChanged"
                       VerticalAlignment="Center"
                       Margin="5">
                <ComboBoxItem Content="Default"
@@ -651,6 +639,7 @@
                       SelectedIndex="0"
                       SelectedValue="{Binding HigherRangeStyle, ElementName=_rangeSlider}"
                       SelectedValuePath="Tag"
+                      SelectionChanged="RangeStyleComboBox_SelectionChanged"
                       VerticalAlignment="Center"
                       Margin="5">
                <ComboBoxItem Content="Default"
@@ -669,7 +658,6 @@
                   Margin="10">
          <TextBlock Text="Usage:"
                     Style="{StaticResource Header}" />
-
          <xctk:RangeSlider x:Name="_rangeSlider"
                            HorizontalAlignment="Center"
                            VerticalAlignment="Center"
@@ -678,17 +666,32 @@
                            LowerValue="30"
                            HigherValue="70"
                            Step="1"
-                           Width="600"
-                           Height="225"
                            Orientation="Horizontal"
                            LowerThumbBackground="#FFF0F0F0"
                            HigherThumbBackground="#FFF0F0F0"
-                           RangeBackground="Black"
-                           HigherRangeBackground="Blue"
-                           LowerRangeBackground="Blue"
+                           RangeBackground="Transparent"
+                           HigherRangeBackground="Transparent"
+                           LowerRangeBackground="Transparent"
                            HigherRangeStyle="{x:Null}"
                            RangeStyle="{x:Null}"
-                           LowerRangeStyle="{x:Null}" />
+                           LowerRangeStyle="{x:Null}">
+            <xctk:RangeSlider.Resources>
+               <Style TargetType="xctk:RangeSlider">
+                  <Style.Triggers>
+                     <Trigger Property="Orientation"
+                              Value="Horizontal">
+                        <Setter Property="Width"
+                                Value="600" />
+                     </Trigger>
+                     <Trigger Property="Orientation"
+                              Value="Vertical">
+                        <Setter Property="Height"
+                                Value="225" />
+                     </Trigger>
+                  </Style.Triggers>
+               </Style>
+            </xctk:RangeSlider.Resources>
+         </xctk:RangeSlider>
       </StackPanel>
    </Grid>
 </local:DemoView>
\ No newline at end of file
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StylableWindowView.xaml.cs.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StyleableWindowView.xaml.cs.txt
similarity index 78%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StylableWindowView.xaml.cs.txt
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StyleableWindowView.xaml.cs.txt
index 97c60872..c0407f5a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StylableWindowView.xaml.cs.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StyleableWindowView.xaml.cs.txt
@@ -34,28 +34,28 @@ using Xceed.Wpf.Toolkit.Primitives;
 namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views
 {
   /// <summary>
-  /// Interaction logic for StylableWindowView.xaml
+  /// Interaction logic for StyleableWindowView.xaml
   /// </summary>
-  public partial class StylableWindowView : DemoView
+  public partial class StyleableWindowView : DemoView
   {
     private const string StandardMsgBoxTitle = "Standard MessageBox";
     private const string StyledMsgBoxTitle = "Extended WPF Toolkit styled MessageBox";
-    private const string StylableWindowTitle = "Extended WPF Toolkit StylableWindow";
+    private const string StyleableWindowTitle = "Extended WPF Toolkit StyleableWindow";
     private const string StandardMsgBoxMessage = "The standard system MessageBox will always have this look. No styling is possible.";
     private const string StyledMsgBoxMessage = "The Toolkit MessageBox allows you to style it in order to integrate it into your application colors and styles.";
-    private const string StylableWindowContent = "This is a StylableWindow that has the same functionality as a normal window.";
+    private const string StyleableWindowContent = "This is a StyleableWindow that has the same functionality as a normal window.";
     private const string MessageBoxStyleKey = "messageBoxStyle";
     private const string WindowControlStyleKey = "windowControlStyle";
     private const string WindowButtonStyle = "FancyButtonStyle";
 #if OPEN_SOURCE
-    private const string StylableWindowMessage = "StylableWindow is a standalone window that can be styled just like ChildWindow or MessageBox. This is a feature of the \"Plus\" version.";
+    private const string StyleableWindowMessage = "StyleableWindow is a standalone window that can be styled just like ChildWindow or MessageBox. This is a feature of the \"Plus\" version.";
 #else
-    private const string StylableWindowNoStyleKey = "stylableWindowNoStyle";
-    private const string StylableWindowStyleKey = "stylableWindowStyle";
-    private StylableWindow _stylableWindow;
+    private const string StyleableWindowNoStyleKey = "styleableWindowNoStyle";
+    private const string StyleableWindowStyleKey = "styleableWindowStyle";
+    private StyleableWindow _styleableWindow;
 #endif
 
-    public StylableWindowView()
+    public StyleableWindowView()
     {
       InitializeComponent();
 #if !OPEN_SOURCE
@@ -68,57 +68,57 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views
     private void OnSampleUnloaded( object sender, RoutedEventArgs e )
     {
       //# Be sure to close the window
-      if( _stylableWindow != null )
+      if( _styleableWindow != null )
       {
-        _stylableWindow.Close();
+        _styleableWindow.Close();
       }
     }
 #endif
 
-    private void OnStylableWindow_Click( object sender, RoutedEventArgs e )
+    private void OnStyleableWindow_Click( object sender, RoutedEventArgs e )
     {
 #if OPEN_SOURCE
       var msgBox = new Xceed.Wpf.Toolkit.MessageBox();
       msgBox.DataContext = this.DataContext;
-      msgBox.Text = StylableWindowMessage;
+      msgBox.Text = StyleableWindowMessage;
       msgBox.Caption = StyledMsgBoxTitle;
       msgBox.Style = ( _enableStyleCheckBox.IsChecked.GetValueOrDefault() ) ? ( Style )this.Resources[ MessageBoxStyleKey ] : null;
       msgBox.ShowDialog();
 #else
-      if( _stylableWindow == null )
+      if( _styleableWindow == null )
       {
-        _stylableWindow = new StylableWindow();
-        _stylableWindow.Width = 500;
-        _stylableWindow.Height = 300;
-        _stylableWindow.Title = StylableWindowTitle;
-        _stylableWindow.DataContext = this.DataContext;
-        _stylableWindow.Left = Application.Current.MainWindow.Left + ( Application.Current.MainWindow.ActualWidth / 2 );
-        _stylableWindow.Top = Application.Current.MainWindow.Top + ( Application.Current.MainWindow.ActualHeight / 2 );
-        _stylableWindow.Closed += new EventHandler( OnStylableWindowClosed );
-        _stylableWindow.Topmost = true;
-
-        _stylableWindow.Content = new TextBlock()
+        _styleableWindow = new StyleableWindow();
+        _styleableWindow.Width = 500;
+        _styleableWindow.Height = 300;
+        _styleableWindow.Title = StyleableWindowTitle;
+        _styleableWindow.DataContext = this.DataContext;
+        _styleableWindow.Left = Application.Current.MainWindow.Left + ( Application.Current.MainWindow.ActualWidth / 2 );
+        _styleableWindow.Top = Application.Current.MainWindow.Top + ( Application.Current.MainWindow.ActualHeight / 2 );
+        _styleableWindow.Closed += new EventHandler( OnStyleableWindowClosed );
+        _styleableWindow.Topmost = true;
+
+        _styleableWindow.Content = new TextBlock()
         {
-          Text = StylableWindowContent,
+          Text = StyleableWindowContent,
           TextWrapping = TextWrapping.Wrap
         };
 
-        _stylableWindow.Style = ( _enableStyleCheckBox.IsChecked.GetValueOrDefault() )
-          ? ( Style )this.Resources[ StylableWindowStyleKey ]
-          : ( Style )this.Resources[ StylableWindowNoStyleKey ];
+        _styleableWindow.Style = ( _enableStyleCheckBox.IsChecked.GetValueOrDefault() )
+          ? ( Style )this.Resources[ StyleableWindowStyleKey ]
+          : ( Style )this.Resources[ StyleableWindowNoStyleKey ];
 
-        _stylableWindow.Show();
+        _styleableWindow.Show();
       }
 #endif
     }
 
 #if !OPEN_SOURCE
-    private void OnStylableWindowClosed( object sender, EventArgs e )
+    private void OnStyleableWindowClosed( object sender, EventArgs e )
     {
-      _stylableWindow.Closed -= new EventHandler( OnStylableWindowClosed );
-      _stylableWindow.Style = null;
-      _stylableWindow.DataContext = null;
-      _stylableWindow = null;
+      _styleableWindow.Closed -= new EventHandler( OnStyleableWindowClosed );
+      _styleableWindow.Style = null;
+      _styleableWindow.DataContext = null;
+      _styleableWindow = null;
     }
 #endif
     private void StandardMessageBoxButton_Click( object sender, RoutedEventArgs e )
@@ -152,11 +152,11 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views
       }
       
 #if !OPEN_SOURCE
-      if( _stylableWindow != null )
+      if( _styleableWindow != null )
       {
-        _stylableWindow.Style = ( styled )
-          ? ( Style )this.Resources[ StylableWindowStyleKey ]
-          : ( Style )this.Resources[ StylableWindowNoStyleKey ];
+        _styleableWindow.Style = ( styled )
+          ? ( Style )this.Resources[ StyleableWindowStyleKey ]
+          : ( Style )this.Resources[ StyleableWindowNoStyleKey ];
       }
 #endif
     }
@@ -164,7 +164,7 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views
 
   /// <summary>
   /// This model will allow to share the style values between our MessageBox, 
-  /// ChildWindow and StylableWindow controls
+  /// ChildWindow and StyleableWindow controls
   /// </summary>
   public class WindowModel : DependencyObject
   {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StylableWindowView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StyleableWindowView.xaml.txt
similarity index 91%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StylableWindowView.xaml.txt
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StyleableWindowView.xaml.txt
index a7de8655..271bc3f8 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StylableWindowView.xaml.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/StyleableWindowView.xaml.txt
@@ -13,7 +13,7 @@
    Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
 
   **************************************************************************************-->
-<local:DemoView x:Class="Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views.StylableWindowView"
+<local:DemoView x:Class="Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views.StyleableWindowView"
                  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                  xmlns:local="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer"
@@ -21,13 +21,13 @@
                  xmlns:res="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Resources"
                  xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Converters"
                  xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
-                 Title="StylableWindows" >
+                 Title="StyleableWindows" >
    <local:DemoView.Description>
       <Paragraph FontSize="14" FontFamily="Segoe">
          <Run>It is possible to style ChildWindow controls as well as MessageBox controls. All the chrome of their window can be styled (color, thickness, opacity); their action buttons can also be styled.</Run>
          <LineBreak />
          <LineBreak />
-         <Run>The "Plus" version provides a new control called StylableWindow, which consists of a window that has all the functions of a normal window, but which can be styled in the same way as ChildWindow or MessageBox.</Run>
+         <Run>The "Plus" version provides a new control called StyleableWindow, which consists of a window that has all the functions of a normal window, but which can be styled in the same way as ChildWindow or MessageBox.</Run>
          <!--##INCLUDE_OPEN_SOURCE
             <LineBreak />
             <Hyperlink NavigateUri="http://www.xceed.com/Extended_WPF_Toolkit_Intro.html" RequestNavigate="Hyperlink_RequestNavigate">
@@ -73,8 +73,8 @@
          </Style>
 
          <!--##EXCLUDE_OPEN_SOURCE-->
-         <!--Style for the StylableWindow-->
-         <Style x:Key="stylableWindowNoStyle" TargetType="xctk:StylableWindow" >
+         <!--Style for the StyleableWindow-->
+         <Style x:Key="styleableWindowNoStyle" TargetType="xctk:StyleableWindow" >
             <Setter Property="Icon" Value="..\Resources\xceed_icon.png" />
             <Setter Property="CloseButtonVisibility" Value="{Binding CloseButtonVisibility}" />
             <Setter Property="WindowStyleOverride" Value="{Binding WindowStyle}" />
@@ -82,7 +82,7 @@
             <Setter Property="Width" Value="375" />
             <Setter Property="Height" Value="150" />
          </Style>
-         <Style x:Key="stylableWindowStyle" TargetType="xctk:StylableWindow" BasedOn="{StaticResource stylableWindowNoStyle}">
+         <Style x:Key="styleableWindowStyle" TargetType="xctk:StyleableWindow" BasedOn="{StaticResource styleableWindowNoStyle}">
             <Setter Property="WindowBackground" Value="{Binding WindowBackground}" />
             <Setter Property="WindowBorderBrush" Value="{Binding WindowBorderBrush}" />
             <Setter Property="WindowInactiveBackground" Value="{Binding WindowInactiveBackground}" />
@@ -103,7 +103,7 @@
 
    <local:DemoView.DataContext>
       <!--A model containing the brushes and other properties was created to share theses values
-      between ChildWindow, MessageBox, and StylableWindow.-->
+      between ChildWindow, MessageBox, and StyleableWindow.-->
       <view:WindowModel
          WindowBackground="#FFEFAC27"
          WindowBorderBrush="Black"
@@ -160,9 +160,9 @@
                   <Button Content="Show Toolkit MessageBox" Click="StyledMessageBoxButton_Click" Margin="10" Width="150" Height="30"/>
                </StackPanel>
             </GroupBox>
-            <GroupBox Header="Stylable Window" DockPanel.Dock="Top" Margin="5" HorizontalAlignment="Stretch" >
+            <GroupBox Header="Styleable Window" DockPanel.Dock="Top" Margin="5" HorizontalAlignment="Stretch" >
                <Button Width="160" Height="30" Margin="10" HorizontalAlignment="Center"
-                       Content="Show" Click="OnStylableWindow_Click" >
+                       Content="Show" Click="OnStyleableWindow_Click" >
                   <!--##INCLUDE_OPEN_SOURCE                  
                   <Button.ContentTemplate>
                      <DataTemplate>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/ThemingDataGridView.xaml.cs.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/ThemingDataGridView.xaml.cs.txt
index 41d03d50..e8b97ede 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/ThemingDataGridView.xaml.cs.txt
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/ThemingDataGridView.xaml.cs.txt
@@ -120,7 +120,7 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.Theming.Views
       _dataGrid.View.Theme = dataGridTheme;
     }
 
-    private void ChangeMetroTheme( MetroThemeResourceDictionaryBase metroDataGridThemeResourceDictionary )
+    private void ChangeMetroTheme( DataGridMetroThemeResourceDictionaryBase metroDataGridThemeResourceDictionary )
     {
       _accentColorPanel.Visibility = Visibility.Visible;
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.cs.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.cs.txt
new file mode 100644
index 00000000..0b24203e
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.cs.txt
@@ -0,0 +1,152 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2014 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using System.ComponentModel;
+using System.Data;
+using System.Collections.ObjectModel;
+#if !OPEN_SOURCE
+using Xceed.Wpf.Themes;
+using Xceed.Wpf.Toolkit.Themes.Office2007;
+using Xceed.Wpf.Toolkit.Themes.Metro;
+using Xceed.Wpf.Themes.Metro;
+using Xceed.Wpf.Samples.SampleData;
+#endif
+
+
+namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.TokenizedTextBox.Views
+{
+  /// <summary>
+  /// Interaction logic for TokenizedTextBoxView.xaml
+  /// </summary>
+  public partial class TokenizedTextBoxView : DemoView
+  {
+#if !OPEN_SOURCE
+    #region Members
+
+    private static ObservableCollection<Record> m_Records;
+
+    #endregion
+#endif
+
+    public TokenizedTextBoxView()
+    {
+
+#if !OPEN_SOURCE
+      InitDataSource();
+      DataContext = this;
+#endif
+      InitializeComponent();
+    }
+
+#if !OPEN_SOURCE
+    void InitDataSource()
+    {
+      NorthwindCollections northwind = new NorthwindCollections();
+      m_Records = new ObservableCollection<Record>();
+      foreach( var employee in northwind.Employees )
+      {
+        m_Records.Add( new Record( employee.FirstName, employee.LastName ) );
+      }
+    }
+
+
+    public static ObservableCollection<Record> EmployeeList
+    {
+      get
+      {
+        return m_Records;
+      }
+    }
+
+    private void OnDeleteToken( object sender, RoutedEventArgs e )
+    {
+      object item = ( ( FrameworkElement )e.OriginalSource ).DataContext;
+      this.customTokenizedTextBox.SelectedItems.Remove( item );
+    }
+#endif
+  }
+
+#if !OPEN_SOURCE
+  public class Record : INotifyPropertyChanged
+  {
+    public Record()
+    {
+    }
+
+    public Record( string pFirstName, string pLastName )
+    {
+      FirstName = pFirstName;
+      LastName = pLastName;
+    }
+
+    private string m_firstName;
+    public string FirstName
+    {
+      get
+      {
+        return m_firstName;
+      }
+      set
+      {
+        m_firstName = value;
+        OnPropertyChanged( "FirstName" );
+      }
+    }
+
+    private string m_lastName;
+    public string LastName
+    {
+      get
+      {
+        return m_lastName;
+      }
+      set
+      {
+        m_lastName = value;
+        OnPropertyChanged( "LastName" );
+      }
+    }
+
+
+    #region INotifyPropertyChanged Members
+
+    public event PropertyChangedEventHandler PropertyChanged;
+
+    protected void OnPropertyChanged( string name )
+    {
+      PropertyChangedEventHandler handler = PropertyChanged;
+      if( handler != null )
+      {
+        handler( this, new PropertyChangedEventArgs( name ) );
+      }
+    }
+    #endregion
+  }
+#endif
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.txt b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.txt
new file mode 100644
index 00000000..79f2f0cd
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/CodeFiles/TokenizedTextBoxView.xaml.txt
@@ -0,0 +1,327 @@
+<!--*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2014 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************-->
+<local:DemoView x:Class="Xceed.Wpf.Toolkit.LiveExplorer.Samples.TokenizedTextBox.Views.TokenizedTextBoxView"
+                xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                xmlns:sys="clr-namespace:System;assembly=mscorlib"
+                xmlns:local="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer"
+                xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
+                xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters;assembly=Xceed.Wpf.Toolkit"
+                Title="TokenizedTextBox">
+
+   <local:DemoView.Description>
+      <Paragraph FontSize="14"
+                 FontFamily="Segoe">
+         <Run>The TokenizedTextBox lets you display a series of values as tokens. If an ItemsSource is specified, an AutoComplete popup will appear with a filtered list of valid values during edition.</Run>
+         <!--##INCLUDE_OPEN_SOURCE
+            <LineBreak />
+            <LineBreak />
+            <Run>This feature is only available in the "Plus" version.</Run>
+            <LineBreak />
+            <Hyperlink NavigateUri="http://www.xceed.com/Extended_WPF_Toolkit_Intro.html" RequestNavigate="Hyperlink_RequestNavigate">
+               Click here for more details about Xceed Extended WPF Toolkit Plus.
+            </Hyperlink>
+          ##END-->
+      </Paragraph>
+   </local:DemoView.Description>
+
+   <!--##EXCLUDE_OPEN_SOURCE-->
+   <Grid>
+      <Grid.RowDefinitions>
+         <RowDefinition Height="Auto" />
+         <RowDefinition Height="*" />
+      </Grid.RowDefinitions>
+
+      <GroupBox Header="Features"
+                  Margin="5">
+
+         <GroupBox.Resources>
+            <Style TargetType="TextBlock">
+               <Setter Property="Width" Value="150" />
+               <Setter Property="Margin" Value="0,5,0,5" />
+            </Style>
+            <Style x:Key="SubHeader" TargetType="TextBlock">
+               <Setter Property="Margin" Value="0,10,0,0" />
+               <Setter Property="Foreground" Value="Orange" />
+               <Setter Property="TextElement.FontWeight" Value="Bold" />
+            </Style>
+         </GroupBox.Resources>
+
+         <Grid Margin="5,0,0,5">
+
+            <Grid.ColumnDefinitions>
+               <ColumnDefinition Width="4*" />
+               <ColumnDefinition Width="6*" />
+            </Grid.ColumnDefinitions>
+
+            <Grid.RowDefinitions>
+               <RowDefinition Height="Auto" />
+               <RowDefinition Height="Auto" />
+               <RowDefinition Height="Auto" />
+            </Grid.RowDefinitions>
+
+            <StackPanel Grid.Column="0">
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="Is Valid:" />
+                  <TextBlock Width="80"
+                             Margin="0,5,0,0"
+                             ToolTip="False if there is some text segments within the TokenizedTextBox that are&#x0a;not yet resolved to a valid item and added to the TokenizedTextBox.SelectedItems collection.&#x0a;&#x0a;In this sample this value is linked to the Default TokenizedTextBox only."
+                             Text="{Binding IsValid, ElementName=defaultTokenizedTextBox}">
+                  </TextBlock>
+               </StackPanel>
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="Allow Invalid Values:" />
+                  <CheckBox x:Name="chkAllowInvalidValues"
+                            Width="80"
+                            Margin="0,5,0,0"
+                            IsChecked="{Binding AllowInvalidValues, ElementName=defaultTokenizedTextBox}" />
+               </StackPanel>
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="Allow Duplicate Values:" />
+                  <CheckBox x:Name="chkAllowDuplicateValues"
+                            Width="80"
+                            Margin="0,5,0,0"
+                            IsChecked="{Binding AllowDuplicateValues, ElementName=defaultTokenizedTextBox}" />
+               </StackPanel>
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="Token Delimiter:" />
+                  <TextBox Width="15"
+                           Margin="0,5,0,0"
+                           MaxLength="1"
+                           Text="{Binding TokenDelimiter, ElementName=defaultTokenizedTextBox, UpdateSourceTrigger=PropertyChanged}" />
+               </StackPanel>
+
+            </StackPanel>
+
+            <StackPanel x:Name="panel1"
+                        Grid.Column="1">
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="TokenDisplayMemberPath:" />
+                  <TextBox x:Name="txtValueMemberPath"
+                           Width="200"
+                           Margin="0,5,0,0"
+                           IsEnabled="False"
+                           Text="{Binding TokenDisplayMemberPath, ElementName=defaultTokenizedTextBox}" />
+               </StackPanel>
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="DisplayMemberPath:" />
+                  <TextBox x:Name="txtDisplayMemberPath"
+                           Width="200"
+                           Margin="0,5,0,0"
+                           IsEnabled="False"
+                           Text="{Binding DisplayMemberPath, ElementName=defaultTokenizedTextBox}" />
+               </StackPanel>
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="SearchMemberPaths:" />
+                  <TextBox x:Name="txtSearchMemberPath"
+                           Width="200"
+                           Margin="0,5,0,0"
+                           IsEnabled="False"
+                           Text="{Binding SearchMemberPaths, ElementName=defaultTokenizedTextBox}" />
+               </StackPanel>
+
+            </StackPanel>
+
+            <StackPanel x:Name="panel2"
+                        Grid.Column="1"
+                        Visibility="Collapsed">
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="ValueMemberPath:" />
+                  <TextBox x:Name="txtHiddenValueMemberPath"
+                           Width="200"
+                           Margin="0,5,0,0"
+                           IsEnabled="False"
+                           Text="" />
+               </StackPanel>
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="DisplayMemberPath:" />
+                  <TextBox x:Name="txtHiddenDisplayMemberPath"
+                           Width="200"
+                           Margin="0,5,0,0"
+                           IsEnabled="False"
+                           Text="" />
+               </StackPanel>
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="SearchMemberPaths:" />
+                  <TextBox x:Name="txtHiddenSearchMemberPath"
+                           Width="200"
+                           Margin="0,5,0,0"
+                           IsEnabled="False"
+                           Text="" />
+               </StackPanel>
+
+            </StackPanel>
+
+            <StackPanel Grid.Row="1"
+                        Grid.ColumnSpan="2">
+
+               <StackPanel Orientation="Horizontal">
+                  <TextBlock Text="Text:" />
+                  <TextBox x:Name="txtValue"
+                           Width="477"
+                           Margin="0,5,0,0"
+                           Text="{Binding Text, ElementName=defaultTokenizedTextBox}" />
+               </StackPanel>
+
+            </StackPanel>
+            <DockPanel Grid.Row="2"
+                       Grid.ColumnSpan="2"
+                       HorizontalAlignment="Stretch">
+               <TextBlock Text="SelectedItems:"
+                          DockPanel.Dock="Left" />
+               <Border BorderBrush="Gray"
+                       BorderThickness="1"
+                       Margin="5,5,0,0"
+                       Height="60"
+                       Width="477"
+                       SnapsToDevicePixels="True">
+                  <ScrollViewer>
+                     <ItemsControl ItemsSource="{Binding SelectedItems, ElementName=defaultTokenizedTextBox}"
+                                   HorizontalAlignment="Stretch">
+                        <ItemsControl.ItemsPanel>
+                           <ItemsPanelTemplate>
+                              <WrapPanel />
+                           </ItemsPanelTemplate>
+                        </ItemsControl.ItemsPanel>
+                        <ItemsControl.ItemTemplate>
+                           <DataTemplate>
+                              <Border BorderThickness="1"
+                                      BorderBrush="Gray"
+                                      SnapsToDevicePixels="True"
+                                      Margin="3">
+                                 <StackPanel Orientation="Horizontal"
+                                             Margin="3">
+                                    <TextBlock Text="{Binding FirstName, FallbackValue=(String}"
+                                               Margin="0,0,5,0" />
+                                    <TextBlock Text="{Binding LastName, FallbackValue=Value)}" />
+                                 </StackPanel>
+                              </Border>
+                           </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                     </ItemsControl>
+                  </ScrollViewer>
+               </Border>
+            </DockPanel>
+         </Grid>
+      </GroupBox>
+
+      <StackPanel x:Name="_samplePanel" 
+                    Grid.Row="1" 
+                    Margin="10">
+
+         <TextBlock Text="Default:" 
+                       Margin="10"
+                       Style="{StaticResource Header}" />
+
+         <xctk:TokenizedTextBox x:Name="defaultTokenizedTextBox" 
+                                   Margin="10" 
+                                   Width="500"
+                                   HorizontalAlignment="Left"
+                                   AllowInvalidValues="False"
+                                   TokenDelimiter=";"
+                                   TokenDisplayMemberPath="FirstName"
+                                   DisplayMemberPath="LastName"
+                                   SearchMemberPaths="FirstName,LastName"
+                                   ItemsSource="{Binding Path=EmployeeList}" />
+
+         <TextBlock Text="Customized:" 
+                       Margin="10"
+                       Style="{StaticResource Header}" />
+
+         <xctk:TokenizedTextBox x:Name="customTokenizedTextBox"
+                                Margin="10"
+                                Width="500"
+                                HorizontalAlignment="Left"
+                                TokenDisplayMemberPath="{Binding TokenDisplayMemberPath, ElementName=defaultTokenizedTextBox}"
+                                AllowDuplicateValues="{Binding AllowDuplicateValues, ElementName=defaultTokenizedTextBox}"
+                                TokenDelimiter="{Binding TokenDelimiter, ElementName=defaultTokenizedTextBox}"
+                                SearchMemberPaths="{Binding SearchMemberPaths, ElementName=defaultTokenizedTextBox}"
+                                ItemsSource="{Binding Path=EmployeeList}">
+
+
+            <xctk:TokenizedTextBox.ItemTemplate>
+               <DataTemplate>
+                  <StackPanel Orientation="Horizontal"
+                              ToolTip="This item's Italic font style was set using the ItemTemplate property">
+                     <TextBlock Text="{Binding FirstName}" FontStyle="Italic"/>
+                     <TextBlock Text="{Binding LastName}" FontStyle="Italic"
+                                Margin="5,0,0,0"/>
+                  </StackPanel>
+               </DataTemplate>
+            </xctk:TokenizedTextBox.ItemTemplate>
+            <xctk:TokenizedTextBox.TokenItemTemplate>
+               <DataTemplate>
+                  <StackPanel Orientation="Horizontal"
+                              ToolTip="This item's Bold font style was set using the TokenItemTemplate property">
+                     <TextBlock Text="{Binding FirstName}"
+                                FontWeight="Bold" />
+                     <TextBlock Text="{Binding LastName}"
+                                FontWeight="Bold"
+                                Margin="5,0,0,0" />
+                  </StackPanel>
+               </DataTemplate>
+            </xctk:TokenizedTextBox.TokenItemTemplate>
+            <xctk:TokenizedTextBox.TokenItemContainerStyle>
+               <Style TargetType="{x:Type xctk:TokenItem}">
+                  <Setter Property="Template">
+                     <Setter.Value>
+                        <ControlTemplate TargetType="{x:Type xctk:TokenItem}">
+                           <DockPanel>
+                              <Button DockPanel.Dock="Right"
+                                      Margin="2,0,0,0"
+                                      Padding="0"
+                                      BorderThickness="1"
+                                      BorderBrush="Gray"
+                                      KeyboardNavigation.IsTabStop="False"
+                                      Click="OnDeleteToken"
+                                      ToolTip="This button was added using the TokenItemContainerStyle property">
+                                 <Grid>
+                                    <Path Stroke="Red"
+                                          StrokeThickness="2"
+                                          Data="M 1,1 L 10,10" />
+                                    <Path Stroke="Red"
+                                          StrokeThickness="2"
+                                          Data="M 1,10 L 10,1" />
+                                 </Grid>
+                              </Button>
+                              <ContentPresenter />
+                           </DockPanel>
+                        </ControlTemplate>
+                     </Setter.Value>
+                  </Setter>
+               </Style>
+            </xctk:TokenizedTextBox.TokenItemContainerStyle>
+
+         </xctk:TokenizedTextBox>
+
+      </StackPanel>
+   </Grid>
+   <!--##END-->
+
+   <!--##INCLUDE_OPEN_SOURCE
+    <Image Source="..\OpenSourceImages\TokenizedTextBox.png" Width="600" Height="400"/>
+   ##END-->
+</local:DemoView>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/MainWindow.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/MainWindow.xaml
index 2c85e339..c7d75241 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/MainWindow.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/MainWindow.xaml
@@ -23,8 +23,8 @@
         AllowsTransparency="False"
         Icon="App.ico"
         Title="Extended WPF Toolkit - LiveExplorer"
-        Height="768"
-        Width="1290">
+        Height="778"
+        Width="1300">
    <Window.Resources>
       <ResourceDictionary>
          <ResourceDictionary.MergedDictionaries>
@@ -545,6 +545,10 @@
                                               SampleType="{x:Type samples:Text.Views.RichTextboxView}" />
                <core:LiveExplorerTreeViewItem Header="WatermarkTextBox"
                                               SampleType="{x:Type samples:Text.Views.WatermarkTextboxView}" />
+               <core:LiveExplorerTreeViewItem Header="TokenizedTextBox"
+                                              SampleType="{x:Type samples:TokenizedTextBox.Views.TokenizedTextBoxView}"
+                                              IsNewFeature="True"
+                                              IsPlusOnlyFeature="True" />
             </core:LiveExplorerTreeViewItem>
             <core:LiveExplorerTreeViewItem Header="RangeSlider"
                                            SampleType="{x:Type samples:RangeSlider.Views.RangeSliderView}"/>
@@ -553,7 +557,6 @@
                                            IsPlusOnlyFeature="True"/>
             <core:LiveExplorerTreeViewItem Header="ToggleSwitch"
                                            SampleType="{x:Type samples:ToggleSwitch.Views.ToggleSwitchView}"
-                                           IsNewFeature="True"
                                            IsPlusOnlyFeature="True" />
             <core:LiveExplorerTreeViewItem Header="Enumeration"
                                            SampleType="{x:Type samples:Button.Views.ButtonSpinnerView}" />
@@ -592,8 +595,8 @@
          <core:LiveExplorerTreeViewItem Header="Windows"
                                         Style="{StaticResource TreeViewHeaderStyle}"
                                         ItemContainerStyle="{StaticResource TreeViewItemStyle}">
-            <core:LiveExplorerTreeViewItem Header="StylableWindows"
-                                           SampleType="{x:Type samples:Window.Views.StylableWindowView}" />
+            <core:LiveExplorerTreeViewItem Header="StyleableWindows"
+                                           SampleType="{x:Type samples:Window.Views.StyleableWindowView}" />
             <core:LiveExplorerTreeViewItem Header="ChildWindow"
                                            SampleType="{x:Type samples:Window.Views.ChildWindowView}" />
             <core:LiveExplorerTreeViewItem Header="WindowContainer"
@@ -642,8 +645,10 @@
                                            IsPlusOnlyFeature="True" />
             <core:LiveExplorerTreeViewItem Header="SwitchPanel"
                                            SampleType="{x:Type samples:Panels.Views.SwitchPanelView}" />
-         </core:LiveExplorerTreeViewItem>
-         <core:LiveExplorerTreeViewItem Header="Theming"
+            </core:LiveExplorerTreeViewItem>
+
+
+           <core:LiveExplorerTreeViewItem Header="Theming"
                                         Style="{StaticResource TreeViewHeaderStyle}"
                                         ItemContainerStyle="{StaticResource TreeViewItemStyle}">
             <core:LiveExplorerTreeViewItem Header="Extended Toolkit controls"
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/AssemblyInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/AssemblyInfo.cs
index 5ed183d5..ef210ffe 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/AssemblyInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/AssemblyInfo.cs
@@ -49,8 +49,8 @@ using System.Windows;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion( "2.3.*" )]
-[assembly: AssemblyFileVersion( "2.3.0.0" )]
+[assembly: AssemblyVersion( "2.4.*" )]
+[assembly: AssemblyFileVersion( "2.4.0.0" )]
 
 #pragma warning disable 1699
 [assembly: AssemblyDelaySign( false )]
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/Resources.resx b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/Resources.resx
index e012d985..7d7b6a33 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/Resources.resx
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Properties/Resources.resx
@@ -106,12 +106,12 @@
     <value>text/microsoft-resx</value>
   </resheader>
   <resheader name="version">
-    <value>2.3</value>
+    <value>2.4</value>
   </resheader>
   <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.3.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.4.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.3.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.4.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
 </root>
\ No newline at end of file
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DataGrid/Views/DataGridView.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DataGrid/Views/DataGridView.xaml
index 15a1eb35..598da0b3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DataGrid/Views/DataGridView.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DataGrid/Views/DataGridView.xaml
@@ -97,7 +97,8 @@
         </Grid.Resources>
 
         <xcdg:DataGridControl x:Name="_dataGrid"
-                            ItemsSource="{Binding Source={StaticResource cvsOrders}}" >           
+                            ItemsSource="{Binding Source={StaticResource cvsOrders}}" 
+                              AllowDrag="True">           
             <xcdg:DataGridControl.View>
                 <xcdg:TableflowView FixedColumnCount="2" />
             </xcdg:DataGridControl.View>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DateTime/Views/DateTimeView.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DateTime/Views/DateTimeView.xaml
index 6af5c431..15d3cacc 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DateTime/Views/DateTimeView.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/DateTime/Views/DateTimeView.xaml
@@ -47,6 +47,11 @@
                 <x:Type TypeName="Visibility" />
             </ObjectDataProvider.MethodParameters>
         </ObjectDataProvider>
+       <ObjectDataProvider x:Key="enumKind" MethodName="GetValues" ObjectType="{x:Type sys:Enum}">
+            <ObjectDataProvider.MethodParameters>
+                <x:Type TypeName="sys:DateTimeKind" />
+            </ObjectDataProvider.MethodParameters>
+        </ObjectDataProvider>
     </local:DemoView.Resources>
     <Grid>
         <Grid.RowDefinitions>
@@ -68,6 +73,7 @@
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
+               <RowDefinition Height="Auto" />
             </Grid.RowDefinitions>
             <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
@@ -86,10 +92,12 @@
             <CheckBox x:Name="_autoCloseCalendar" Grid.Row="3" Grid.Column="1" IsChecked="False" VerticalAlignment="Center" Margin="5,5,25,5"/>    
             <TextBlock Text="ClipValueToMinMax:" Grid.Row="4" Grid.Column="0" VerticalAlignment="Center"/>
             <CheckBox x:Name="_clipValueToMinMax" Grid.Row="4" Grid.Column="1" IsChecked="False" VerticalAlignment="Center" Margin="5,5,25,5"/>
-            <TextBlock Text="TimePickerVisibility:" Grid.Row="5" Grid.Column="0" VerticalAlignment="Center"/>
-            <ComboBox x:Name="_timePickerVisibility" Grid.Row="5" Grid.Column="1" SelectedIndex="0" ItemsSource="{Binding Source={StaticResource enumVisibility}}" Width="190" Margin="5,5,25,5"/>
-            <TextBlock Text="TimePickerShowButtonSpinner:" Grid.Row="6" Grid.Column="0" VerticalAlignment="Center"/>
-            <CheckBox x:Name="_timePickerShowButtonSpinner" Grid.Row="6" Grid.Column="1" IsChecked="True" VerticalAlignment="Center" Margin="5,5,25,5"/>
+            <TextBlock Text="Kind:" Grid.Row="5" Grid.Column="0" VerticalAlignment="Center"/>
+            <ComboBox x:Name="_kind" Grid.Row="5" Grid.Column="1" SelectedIndex="2" ItemsSource="{Binding Source={StaticResource enumKind}}" Width="190" Margin="5,5,25,5"/>
+             <TextBlock Text="TimePickerVisibility:" Grid.Row="6" Grid.Column="0" VerticalAlignment="Center"/>
+            <ComboBox x:Name="_timePickerVisibility" Grid.Row="6" Grid.Column="1" SelectedIndex="0" ItemsSource="{Binding Source={StaticResource enumVisibility}}" Width="190" Margin="5,5,25,5"/>
+            <TextBlock Text="TimePickerShowButtonSpinner:" Grid.Row="7" Grid.Column="0" VerticalAlignment="Center"/>
+            <CheckBox x:Name="_timePickerShowButtonSpinner" Grid.Row="7" Grid.Column="1" IsChecked="True" VerticalAlignment="Center" Margin="5,5,25,5"/>
 
             <TextBlock Text="TimeFormat:" Grid.Row="0" Grid.Column="2" VerticalAlignment="Center" />
             <ComboBox x:Name="_timeFormat" Grid.Row="0" Grid.Column="3" SelectedIndex="1" ItemsSource="{Binding Source={StaticResource enumTimeFormatData}}" Width="190" Margin="5"/>
@@ -121,7 +129,8 @@
                                  TimePickerVisibility="{Binding Source={x:Reference _timePickerVisibility}, Path=SelectedItem}"
                                  TimePickerShowButtonSpinner="{Binding IsChecked, ElementName=_timePickerShowButtonSpinner}"
                                  Minimum="{Binding Value, ElementName=_minimum}"
-                                 Maximum="{Binding Value, ElementName=_maximum}"/>
+                                 Maximum="{Binding Value, ElementName=_maximum}"
+                                 Kind="{Binding SelectedItem, ElementName=_kind}"/>
         </StackPanel>
 
         <StackPanel Grid.Row="1" Grid.Column="1" HorizontalAlignment="Stretch">
@@ -131,6 +140,7 @@
                         <RowDefinition Height="Auto" />
                         <RowDefinition Height="Auto" />
                         <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
                     </Grid.RowDefinitions>
                     <Grid.ColumnDefinitions>
                         <ColumnDefinition Width="Auto"/>
@@ -143,10 +153,12 @@
                     <xctk:DateTimeUpDown x:Name="_endTime" Grid.Row="1" Grid.Column="1" Format="ShortTime" Value="17:00" Width="100" Margin="5"/>
                     <TextBlock Text="TimeInterval:" Grid.Row="2" VerticalAlignment="Center" />
                     <xctk:DateTimeUpDown x:Name="_timeInterval" Grid.Row="2" Grid.Column="1" Format="Custom" FormatString="H:mm" Value="0:30" Width="100" Margin="5"/>
-                </Grid>
-            </GroupBox>
+                    <TextBlock Grid.Row="3" Text="MaxDropDownHeight:" VerticalAlignment="Center" />
+                    <xctk:DoubleUpDown x:Name="_maxDropDownHeight" Grid.Row="3" Grid.Column="1" Width="100" Value="130" DefaultValue="130" AllowInputSpecialValues="PositiveInfinity" Minimum="0" />
+                 </Grid>
+              </GroupBox>
 
-            <StackPanel>
+              <StackPanel>
                 <TextBlock Text="TimePicker Usage: " Style="{StaticResource Header}" />
                 <xctk:TimePicker x:Name="_timePicker"
                                  VerticalAlignment="Top"
@@ -158,8 +170,9 @@
                                  TimeInterval="{Binding Source={x:Reference _timeInterval}, Path=Value, Converter={StaticResource dateTimeToTimeSpanConverter}}"
                                  ClipValueToMinMax="{Binding IsChecked, ElementName=_clipValueToMinMax}"
                                  Minimum="{Binding Value, ElementName=_minimum}"
-                                 Maximum="{Binding Value, ElementName=_maximum}"/>
-         </StackPanel>
+                                 Maximum="{Binding Value, ElementName=_maximum}"
+                                 MaxDropDownHeight="{Binding Value, ElementName=_maxDropDownHeight}"/>
+           </StackPanel>
         </StackPanel>
     </Grid>
 </local:DemoView>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Numeric/Views/NumericView.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Numeric/Views/NumericView.xaml
index e427b107..e5a8d8d9 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Numeric/Views/NumericView.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Numeric/Views/NumericView.xaml
@@ -45,7 +45,9 @@
             <numeric:FormatObject Value="P2" DisplayValue="Percent" />
         </x:Array>
 
-        <DataTemplate x:Key="FormatStringItemTemplate">
+        <xctk:InverseBoolConverter x:Key="InverseBoolConverter" />
+
+         <DataTemplate x:Key="FormatStringItemTemplate">
             <TextBlock Text="{Binding DisplayValue}" />
         </DataTemplate>
 
@@ -55,6 +57,12 @@
             </ObjectDataProvider.MethodParameters>
         </ObjectDataProvider>
 
+        <ObjectDataProvider x:Key="ButtonSpinnerLocationComboBox" MethodName="GetValues" ObjectType="{x:Type sys:Enum}">
+            <ObjectDataProvider.MethodParameters>
+                <x:Type TypeName="xctk:Location" />
+            </ObjectDataProvider.MethodParameters>
+        </ObjectDataProvider>
+
         <ObjectDataProvider x:Key="ParsingNumberStyleComboBox" MethodName="GetValues" ObjectType="{x:Type sys:Enum}">
             <ObjectDataProvider.MethodParameters>
                 <x:Type TypeName="sys:Globalization.NumberStyles" />
@@ -96,6 +104,7 @@
                        <RowDefinition Height="Auto" />
                        <RowDefinition Height="Auto" />
                        <RowDefinition Height="Auto" />
+                       <RowDefinition Height="Auto" />
                     </Grid.RowDefinitions>
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="Auto" />
@@ -118,17 +127,22 @@
                    <TextBlock Text="Show Button Spinner:" Grid.Row="1" VerticalAlignment="Center" />
                    <CheckBox Grid.Row="1" Grid.Column="1" IsChecked="{Binding ShowButtonSpinner, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center" />
 
-                   <TextBlock Text="Allow Spin:" Grid.Row="2" VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="2" Grid.Column="1" IsChecked="{Binding AllowSpin, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center" />
+                   <TextBlock Text="Is Read Only:" Grid.Row="2" VerticalAlignment="Center" ToolTip="Prevent from using button spinners or editing text." />
+                   <CheckBox Grid.Row="2" Grid.Column="1" IsChecked="{Binding IsReadOnly, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center" />
 
-                   <TextBlock Text="Clip Value to Min Max:" Grid.Row="3"  VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="3" Grid.Column="1" IsChecked="{Binding ClipValueToMinMax, ElementName=_doubleUpDown, Mode=TwoWay}" ClickMode="Press" Margin="5" VerticalAlignment="Center"/>
+                   <TextBlock Text="Allow Spin:" Grid.Row="3" VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="3" Grid.Column="1" IsChecked="{Binding AllowSpin, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center"
+                             IsEnabled="{Binding IsReadOnly, ElementName=_doubleUpDown, Converter={StaticResource InverseBoolConverter}}" />
 
-                   <TextBlock Text="Is Read Only:" Grid.Row="4" VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="4" Grid.Column="1" IsChecked="{Binding IsReadOnly, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center" />
+                   <TextBlock Text="Allow TextInput:" Grid.Row="4" VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="4" Grid.Column="1" IsChecked="{Binding AllowTextInput, ElementName=_doubleUpDown}"  ClickMode="Press" Margin="5" VerticalAlignment="Center"
+                             IsEnabled="{Binding IsReadOnly, ElementName=_doubleUpDown, Converter={StaticResource InverseBoolConverter}}"/>
 
-                   <TextBlock Text="DisplayDefaultValueOnEmptyText:" Grid.Row="5" VerticalAlignment="Center" />
-                   <CheckBox Grid.Row="5" Grid.Column="1" IsChecked="{Binding DisplayDefaultValueOnEmptyText, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center" />
+                   <TextBlock Text="Clip Value to Min Max:" Grid.Row="5"  VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="5" Grid.Column="1" IsChecked="{Binding ClipValueToMinMax, ElementName=_doubleUpDown, Mode=TwoWay}" ClickMode="Press" Margin="5" VerticalAlignment="Center"/>
+
+                   <TextBlock Text="DisplayDefaultValueOnEmptyText:" Grid.Row="6" VerticalAlignment="Center" />
+                   <CheckBox Grid.Row="6" Grid.Column="1" IsChecked="{Binding DisplayDefaultValueOnEmptyText, ElementName=_doubleUpDown}" ClickMode="Press" Margin="5" VerticalAlignment="Center" />
 
                     <!-- 2nd column -->
                    <TextBlock Grid.Column="2" Text="CultureInfo:" VerticalAlignment="Center" Margin="10,0,0,0" />
@@ -147,25 +161,28 @@
                    <xctk:DoubleUpDown Grid.Column="3" Grid.Row="4" Value="{Binding Maximum, ElementName=_doubleUpDown}" AllowInputSpecialValues="PositiveInfinity" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
 
                    <!-- 3rd column -->
-                   <TextBlock Grid.Column="4" Text="ParsingNumberStyle:" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <ComboBox Grid.Column="5" ItemsSource="{Binding Source={StaticResource ParsingNumberStyleComboBox}}" SelectedValue="{Binding ParsingNumberStyle, ElementName=_doubleUpDown}" ToolTip="{StaticResource parsingNumberStyleTooltip}" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Grid.Column="4" Text="ButtonSpinnerLocation:" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <ComboBox Grid.Column="5" ItemsSource="{Binding Source={StaticResource ButtonSpinnerLocationComboBox}}" SelectedValue="{Binding ButtonSpinnerLocation, ElementName=_doubleUpDown}" HorizontalAlignment="Stretch" Margin="5" />
+
+                   <TextBlock Grid.Column="4" Grid.Row="1" Text="ParsingNumberStyle:" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <ComboBox Grid.Column="5" Grid.Row="1" ItemsSource="{Binding Source={StaticResource ParsingNumberStyleComboBox}}" SelectedValue="{Binding ParsingNumberStyle, ElementName=_doubleUpDown}" ToolTip="{StaticResource parsingNumberStyleTooltip}" HorizontalAlignment="Stretch" Margin="5" />
 
-                   <TextBlock Text="Watermark:" Grid.Column="4" Grid.Row="1" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <TextBox Grid.Column="5" Grid.Row="1" HorizontalAlignment="Stretch" Margin="5" Text="{Binding Watermark, ElementName=_doubleUpDown}" />
+                   <TextBlock Text="Watermark:" Grid.Column="4" Grid.Row="2" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <TextBox Grid.Column="5" Grid.Row="2" HorizontalAlignment="Stretch" Margin="5" Text="{Binding Watermark, ElementName=_doubleUpDown}" />
 
-                   <TextBlock Text="Default Value:" Grid.Column="4" Grid.Row="2" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="2" Value="{Binding DefaultValue, ElementName=_doubleUpDown}" AllowInputSpecialValues="Any" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Text="Default Value:" Grid.Column="4" Grid.Row="3" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="3" Value="{Binding DefaultValue, ElementName=_doubleUpDown}" AllowInputSpecialValues="Any" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
 
-                   <TextBlock Text="Value:" Grid.Column="4" Grid.Row="3" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="3" Value="{Binding Value, ElementName=_doubleUpDown, ValidatesOnExceptions=True}" AllowInputSpecialValues="Any" Style="{StaticResource ControlInError}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Text="Value:" Grid.Column="4" Grid.Row="4" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <xctk:DoubleUpDown Grid.Column="5" Grid.Row="4" Value="{Binding Value, ElementName=_doubleUpDown, ValidatesOnExceptions=True}" AllowInputSpecialValues="Any" Style="{StaticResource ControlInError}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
 
-                   <TextBlock Text="Text:" Grid.Column="4" Grid.Row="4" VerticalAlignment="Center" Margin="10,0,0,0"/>
-                   <TextBox Grid.Column="5" Grid.Row="4" Text="{Binding Text, ElementName=_doubleUpDown}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
+                   <TextBlock Text="Text:" Grid.Column="4" Grid.Row="5" VerticalAlignment="Center" Margin="10,0,0,0"/>
+                   <TextBox Grid.Column="5" Grid.Row="5" Text="{Binding Text, ElementName=_doubleUpDown}" VerticalAlignment="Center" HorizontalAlignment="Stretch" Margin="5" />
 
                    <!-- last rows -->
-                   <TextBlock Text="(DoubleUpDown and SingleUpDown support the AllowInputSpecialValues property)" Grid.Row="6" Grid.ColumnSpan="6" VerticalAlignment="Center" Margin="0,5,0,0"/>
-                   <TextBlock Text="Allow Input Special Values:" VerticalAlignment="Center" Grid.Row="7" Grid.ColumnSpan="2"/>
-                   <ComboBox Grid.Column="2" Grid.Row="7" Grid.ColumnSpan="2" ItemsSource="{Binding Source={StaticResource AllowInputSpecialValuesComboBox}}" SelectedValue="{Binding AllowInputSpecialValues, ElementName=_doubleUpDown}" ToolTip="{StaticResource allowInputSpecialValuesTooltip}" Margin="5" Width="108"/>
+                   <TextBlock Text="(DoubleUpDown and SingleUpDown support the AllowInputSpecialValues property)" Grid.Row="7" Grid.ColumnSpan="6" VerticalAlignment="Center" Margin="0,5,0,0"/>
+                   <TextBlock Text="Allow Input Special Values:" VerticalAlignment="Center" Grid.Row="8" Grid.ColumnSpan="2"/>
+                   <ComboBox Grid.Column="2" Grid.Row="8" Grid.ColumnSpan="2" ItemsSource="{Binding Source={StaticResource AllowInputSpecialValuesComboBox}}" SelectedValue="{Binding AllowInputSpecialValues, ElementName=_doubleUpDown}" ToolTip="{StaticResource allowInputSpecialValuesTooltip}" Margin="5" Width="108"/>
                 </Grid>
            </GroupBox>
 
@@ -177,6 +194,7 @@
                                   ClipValueToMinMax="False"
                                   ShowButtonSpinner="True" 
                                   AllowSpin="True"
+                                  AllowTextInput="True"
                                   IsReadOnly="False" 
                                   MouseWheelActiveOnFocus="True"
                                   CultureInfo="en-US"
@@ -185,6 +203,7 @@
                                   Maximum="100"
                                   Minimum="0"
                                   DisplayDefaultValueOnEmptyText="False"
+                                  ButtonSpinnerLocation="Right"
                                   ParsingNumberStyle="Any"
                                   Watermark="Enter Text"
                                   DefaultValue="10"
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml
index e415721e..2bcd5fa5 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml
@@ -55,6 +55,8 @@
          <LineBreak/>
          <LineBreak/>
          Plus edition Only:
+         <LineBreak />
+         DependsOnAttribute
          <LineBreak/>
          (Not demoed here. See corresponding samples)
          <LineBreak />
@@ -89,7 +91,8 @@
       </StackPanel>
 
       <xctk:PropertyGrid Grid.Row="1" x:Name="_propertyGrid" Width="450" MaxHeight="650" Margin="10" 
-                         SelectedObject="{Binding}">
+                         SelectedObject="{Binding}"
+                         ShowDescriptionByTooltip="True">
       </xctk:PropertyGrid>      
 
    </Grid>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml.cs
index d170913d..3e4f6621 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/PropertyGrid/Views/PropertyGridAttributesView.xaml.cs
@@ -46,7 +46,6 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.PropertyGrid.Views
       };
 
       this.DataContext = person;
-
     }
   }
 
@@ -61,10 +60,10 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.PropertyGrid.Views
     [Category( "Information" )]
     [Description( "This property uses the [DisplayName(\"Is a Men\")] attribute to customize the name of this property." )]
     [DisplayName( "Is male" )]
-    public bool IsMale { get; protected set; }
+    public bool IsMale { get; set; }
 
     [Category( "Information" )]
-    [Description( "This property uses the [Editor(..)] attribute to provide a custom editor using the 'FirstNameEditor' class" )]
+    [Description( "This property uses the [Editor(..)] attribute to provide a custom editor using the 'FirstNameEditor' class. In the Plus version, it also depends on the IsMale property to change its foreground and source." )]
     [Editor( typeof( FirstNameEditor ), typeof( FirstNameEditor ) )]
     public string FirstName { get; set; }
 
@@ -151,7 +150,6 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.PropertyGrid.Views
     {
       TextBox textBox = new TextBox();
       textBox.Background = new SolidColorBrush( Colors.Red );
-
       //create the binding from the bound property item to the editor
       var _binding = new Binding( "Value" ); //bind to the Value property of the PropertyItem
       _binding.Source = propertyItem;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml
index 80358c2e..9c37982d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml
@@ -18,14 +18,12 @@
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:sys="clr-namespace:System;assembly=mscorlib"
                 xmlns:local="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer"
-                xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer.Samples.RangeSlider.Converters"
                 xmlns:xctkconv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters;assembly=Xceed.Wpf.Toolkit"
                 xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
                 Title="RangeSlider">
 
    <local:DemoView.Resources>
 
-      <conv:IntegerToBoolConverter x:Key="IntegerToBoolConverter" />
       <xctkconv:SolidColorBrushToColorConverter x:Key="SolidColorBrushToColorConverter" />
 
       <Style x:Key="LowerRangeStyle1"
@@ -36,7 +34,6 @@
                <ControlTemplate  TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -71,7 +68,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Ellipse Fill="Black"/>
                      <Ellipse x:Name="MainBorder"
                               Fill="{TemplateBinding Background}"
                               Opacity="1" />
@@ -106,7 +102,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="19">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -173,7 +168,6 @@
                <ControlTemplate  TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -202,7 +196,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Ellipse Fill="Black" />
                      <Ellipse x:Name="MainBorder"
                               Fill="{TemplateBinding Background}" />
                   </Grid>
@@ -230,7 +223,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="19">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -301,7 +293,6 @@
                <ControlTemplate  TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -336,7 +327,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="10">
-                     <Ellipse Fill="Black" />
                      <Ellipse x:Name="MainBorder"
                               Fill="{TemplateBinding Background}"
                               Opacity="1" />
@@ -372,7 +362,6 @@
                <ControlTemplate TargetType="{x:Type RepeatButton}">
                   <Grid x:Name="MainGrid"
                         Height="19">
-                     <Rectangle Fill="Black" />
                      <Rectangle x:Name="MainBorder"
                                 Fill="{TemplateBinding Background}"
                                 Opacity="1" />
@@ -566,7 +555,6 @@
                        Margin="10,5,5,5" />
             <xctk:ColorPicker Grid.Row="2"
                               Grid.Column="3"
-                              IsEnabled="{Binding SelectedIndex, ElementName=lowerRangeStyleComboBox, Converter={StaticResource IntegerToBoolConverter}}"
                               SelectedColor="{Binding LowerRangeBackground, ElementName=_rangeSlider, Converter={StaticResource SolidColorBrushToColorConverter}}"
                               VerticalAlignment="Center"
                               Margin="5" />
@@ -578,7 +566,6 @@
                        Margin="10,5,5,5" />
             <xctk:ColorPicker Grid.Row="3"
                               Grid.Column="3"
-                              IsEnabled="{Binding SelectedIndex, ElementName=rangeStyleComboBox, Converter={StaticResource IntegerToBoolConverter}}"
                               SelectedColor="{Binding RangeBackground, ElementName=_rangeSlider, Converter={StaticResource SolidColorBrushToColorConverter}}"
                               VerticalAlignment="Center"
                               Margin="5" />
@@ -590,7 +577,6 @@
                        Margin="10,5,5,5" />
             <xctk:ColorPicker Grid.Row="4"
                               Grid.Column="3"
-                              IsEnabled="{Binding SelectedIndex, ElementName=higherRangeStyleComboBox, Converter={StaticResource IntegerToBoolConverter}}"
                               SelectedColor="{Binding HigherRangeBackground, ElementName=_rangeSlider, Converter={StaticResource SolidColorBrushToColorConverter}}"
                               VerticalAlignment="Center"
                               Margin="5" />
@@ -605,6 +591,7 @@
                       SelectedIndex="0"
                       SelectedValue="{Binding LowerRangeStyle, ElementName=_rangeSlider}"
                       SelectedValuePath="Tag"
+                      SelectionChanged="RangeStyleComboBox_SelectionChanged"
                       VerticalAlignment="Center"
                       Margin="5">
                <ComboBoxItem Content="Default"
@@ -628,6 +615,7 @@
                       SelectedIndex="0"
                       SelectedValue="{Binding RangeStyle, ElementName=_rangeSlider}"
                       SelectedValuePath="Tag"
+                      SelectionChanged="RangeStyleComboBox_SelectionChanged"
                       VerticalAlignment="Center"
                       Margin="5">
                <ComboBoxItem Content="Default"
@@ -651,6 +639,7 @@
                       SelectedIndex="0"
                       SelectedValue="{Binding HigherRangeStyle, ElementName=_rangeSlider}"
                       SelectedValuePath="Tag"
+                      SelectionChanged="RangeStyleComboBox_SelectionChanged"
                       VerticalAlignment="Center"
                       Margin="5">
                <ComboBoxItem Content="Default"
@@ -669,7 +658,6 @@
                   Margin="10">
          <TextBlock Text="Usage:"
                     Style="{StaticResource Header}" />
-
          <xctk:RangeSlider x:Name="_rangeSlider"
                            HorizontalAlignment="Center"
                            VerticalAlignment="Center"
@@ -678,17 +666,32 @@
                            LowerValue="30"
                            HigherValue="70"
                            Step="1"
-                           Width="600"
-                           Height="225"
                            Orientation="Horizontal"
                            LowerThumbBackground="#FFF0F0F0"
                            HigherThumbBackground="#FFF0F0F0"
-                           RangeBackground="Black"
-                           HigherRangeBackground="Blue"
-                           LowerRangeBackground="Blue"
+                           RangeBackground="Transparent"
+                           HigherRangeBackground="Transparent"
+                           LowerRangeBackground="Transparent"
                            HigherRangeStyle="{x:Null}"
                            RangeStyle="{x:Null}"
-                           LowerRangeStyle="{x:Null}" />
+                           LowerRangeStyle="{x:Null}">
+            <xctk:RangeSlider.Resources>
+               <Style TargetType="xctk:RangeSlider">
+                  <Style.Triggers>
+                     <Trigger Property="Orientation"
+                              Value="Horizontal">
+                        <Setter Property="Width"
+                                Value="600" />
+                     </Trigger>
+                     <Trigger Property="Orientation"
+                              Value="Vertical">
+                        <Setter Property="Height"
+                                Value="225" />
+                     </Trigger>
+                  </Style.Triggers>
+               </Style>
+            </xctk:RangeSlider.Resources>
+         </xctk:RangeSlider>
       </StackPanel>
    </Grid>
 </local:DemoView>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml.cs
index 20ad2985..8b375314 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Views/RangeSliderView.xaml.cs
@@ -17,6 +17,8 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
+using System.Windows.Controls;
+using System.Windows.Media;
 
 namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.RangeSlider.Views
 {
@@ -29,5 +31,32 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.RangeSlider.Views
     {
       InitializeComponent();
     }
+
+    private void RangeStyleComboBox_SelectionChanged( object sender, SelectionChangedEventArgs e )
+    {
+      if( e.AddedItems.Count > 0 && e.AddedItems[ 0 ] is ComboBoxItem)
+      {
+        ComboBoxItem item = e.AddedItems[ 0 ] as ComboBoxItem;
+        //A style different from null is chosen
+        if( item.Tag != null )
+        {
+          //LowerRangeBackground is Transparent, force a color
+          if( object.Equals( sender, lowerRangeStyleComboBox ) && ((SolidColorBrush)_rangeSlider.LowerRangeBackground).Color.Equals( Colors.Transparent) )
+          {
+            _rangeSlider.LowerRangeBackground = new SolidColorBrush( Colors.Green );
+          }
+          //RangeBackground is Transparent, force a color
+          else if( object.Equals( sender, rangeStyleComboBox ) && ( ( SolidColorBrush )_rangeSlider.RangeBackground ).Color.Equals( Colors.Transparent ) )
+          {
+            _rangeSlider.RangeBackground = new SolidColorBrush( Colors.Blue );
+          }
+          //HigherRangeBackground is Transparent, force a color
+          else if( object.Equals( sender, higherRangeStyleComboBox ) && ( ( SolidColorBrush )_rangeSlider.HigherRangeBackground ).Color.Equals( Colors.Transparent ) )
+          {
+            _rangeSlider.HigherRangeBackground = new SolidColorBrush( Colors.Green );
+          }
+        }
+      }
+    }
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/OpenSourceImages/TokenizedTextBox.png b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/OpenSourceImages/TokenizedTextBox.png
new file mode 100644
index 0000000000000000000000000000000000000000..dede90f04d612a0bc7d43fda1accaebbbba97cd9
GIT binary patch
literal 11336
zcmd6NWmH@5mu_05Em{gK1Z_(xR-h1^0>y&675Ct-Es~;z;tm0d7K*!DaSaZ^g1Z)X
zxS_w9S+nkZ_}@Eg*1GpY&dE7BZ_a*g@BKW_4pNX4$HgMW0ssKGk`kgy0Kh{6)c5Ph
z4^c;Ot-*WL>4Bq?xG<n-fP52mfo>`!D+B<PhGSnFV4$v_*hy$O0swez_n!w{w!e%4
z07j&wsE~@A?rsXyN=Gbi9T$l^Iz6ScYlhwkOM$wOior_DA~mJ7(4eC4XA;Fel8V+5
zvSUBVSH!pVP1p-1sS}}flD>YL0UTa1Ku|*xh6s>OhO~0YlW)ztB+m(qTEi0}68=zM
z+oky)dYxBO%(%;q=hms7>CT+-H=kL}dkEIGtLDh1<f(ram{)h+$L3H*S^AMJ4Tw5L
zJ%po<5kzK~0KnI*k08{=8w}V30N^G45Dw}>(i?(0N?@_0p_(ZD(?rP{p1^%1Y_Na0
zb4oMS$s}UP7}OL%jxja!p1~RQ^mE!=NQeuvHE2$kFK%6Pg1By4{83js^^^6gRab>G
zliJhJiz>bQcj?<JW<l6>Q!Jb0bS#R0FO_BtjdIcJmcKupw%BthVM@P~@#CQ8yPP1r
zn8?Sb&B6l!(sqb)fsbag1UNW&+zd;OzWgMwK88k_Rj2!|)X7PCGW&5X8{g?pyua^}
zO4ta8h`mjTh&4Cf4(w^4%-@$Pg2dqou**O81IQUJys+TK)+;USLiO^aQ<K`b`YZYE
z==`dOTFJp8p`odBnr6-Ph+pqQ)z|SVLnM=bVVd<Z-FW7$S#$<n`IKxKYLHIqnH9k~
z=Qz`DP{Y=r$Ya^*CjDcyBI^*Fc5hi_&cnUQ(J|f8_nEIH)_$n0Y$NMXEl;z&wbbcN
z$;ZO3xu?L%MqM7;e&z2uPSEqfkpx5b<^E#q6v2KD`bx7Lg`}(b8=U(YF)<y0y&`)Y
z+xuu5E2id5fZyVjJUYj#v+<N`GdjO}YRr^6$K6+?Q2qx5X!gY}fw993lknsb0H6R_
zD*&R&TBMfREL@L`)t{BiAG0O$X8?`2D7<chgu5=akG{VX43I{6ZUMFL$L$^WS{^X^
zQdjtBnObFdwW<p<eE*;*dcS=ibZG6b6SEP&s>wwZ#*X7;YYhB~S|PuMO>AJSbD5yZ
z?ynOe6NRJvZe$}Nk@3aLThijI+oYP9+2bL5w~+fk@2CA~+1Vcd?NTeg)Lzeb_BVI4
zY>KjuGPk|lcu?tqYc;MHb8G|zhhpVjD&KUbg;A!?78x`HXyi+gcd}|zNax_{$qDa1
zBRXnyLanwAg)GSAzW2V0g^>C-%eSMY<rU9cgb-Fr($TfNbmBXz;gAEa+qe|hf^JtU
z<{iCQq;u$2K8KOT(yqIY!j&zYvv>erF-Stj+a0cBLZ-gT$3;|kP{0HL#H7CFXw#Kt
zblBCx{300U5o>F9eE#ByC3p;ygm_V>N68hg=+ACsu{ApsS-JIj)}$5<w{5@PRC$(n
z*16iE5WZLIzCh@S$C(0=kzM6m)f1d8{cv~be!sEk_#`<{TMBSLc>mk>`fu#W|IsEv
z?91+h9s$_I%-S_dE|T9_0<vJQXi#S60$>k*XJln#inr@iq6{yg^M-u={NVm3I_$w3
z25NGHpP6AM5a$&D8&8~%)ri@44RJ?*3|p`0sL$tH(+GKIQ_+O+gmY7vChgY<>$<>I
z1-<B5)}(~m#^IdbVIwD6S6K|?&;m}2WIcy(cj<cr{HfA~A0`u01?mrb9nf>Q`)&{X
zRPr7+MrWaae4g6`dDGpqIudd!qw`i-B~Z#DKyoQLpD`tt&;qQZgS4KLS+aT#In7m5
z0riRj*)zL&gh0O=A|UXWJ-_yun86(E)QZBX)RF=EsWWU`HD1PbyNj26X}}INIDq)c
zQ6Uga+2D{2iIAm!ahkgxU1aXq5QQTc$WYyP@o8wdb1iV19BV&(&o3(=P2%U#BdE%m
z@5DT#Z*UUOmo0XsU5b;^yM^cF((-G6a*Gb$i}anRz2s1mY!A{@M>bAer<)0vTM@C!
z<!QjqN7!qE-3axY8n0+4SfTvF!nXx;=y_+GGnX}ATgnGR2l~XO+<N<rHJI$=#LU?%
z?!tLJ`A)|D*-^^|t0Hy(Q&aUi{uouDMa{Yl5ZU=8z_}|Fj3=C5&e}ZFH8`(*wy-U-
zWd3<S_4e@DuA}<Qn;UuvAW!0iL!^2ANvtIg*I*GaEWR|dr{_}9r(w_7jiaH+ZWw1N
z%TxUgxuuzt<*SsJGWcaQLpZ&#w|dh~@SyQ*XeXzGnsZW(%}6Qkb0YLjN=|ol0X1ry
zKU*&>Gko$fevJ6@$|AaIdN$+?EZ(F;YMdp<IgOG!NvLA8;EmWbHtr7j#!d{=A8dGQ
zQkF~X-|anJ>@KQ5aa<$M0lpz|mQR7HtP*o+e<8lX%4GwnnkepoxC`s;GG|yZUDMLY
zO=EWhJ9)Vmd)_WvBoEiJSZmct=z`$lKUIZB-qI>R>d6m_z3~ZQ*l1^dKDx7Fh&!{r
z_0T@3%`a{sJ<lyca$CYH2~?V95GUY5Kw@%+*0H#v<lo!!fZ<6Jxl9w+;b5W%30L}z
zla1ET9oXyg$BXAmiUH$N1cZq`i8}tmm4j>#H~rign`G}Ku>q>arDg&1!FGJ$C+ipb
zjs|FwQ{mQ@a&Ge?3cHObKnm|*kQ7)O;uMwZEt4L;LXg7^-v~ut-|=`J1a<=u^U<i9
zdC1uqB@poVIaU7{u(}SCw2l*)SbJu9{CHi7C6=sWn6u-ers@rBF`Q2te0My>@%BeK
zhay2{<gzcE?cqMt^f9N1(7pxz0|l`)El{_96zHb`eE>(Bc^S7PzmyvZ=({DC$!O;v
zZWmE90f-algbCX_Ag>a#KZ+n8$kTF3_Ml3_>!(b<V8D#e!bt{LHOwz+u{DLiT|9o{
z2>QMZ_(>RZST^ZA@s%pnMq-GTEmfa%lwjbeO0_unfpH^i^l%X0To)Y4na$B@>f)a2
zCj&~6O`MY>-b??^8tDsu#FyiC4(Y6hFA_a~1CClfECU9*v7}m}V6v?)4Ls#!DoLqh
zH)+F)HGH-8xI#REyYp!HqA&kE9`pSm^Dby0S@1k_U*NOUbN(d|^}0gK+fO=;0@19w
zY9_}1D@Hl$5ns`$XM7f8Qe<v#{p@pADwG~kjEA|$de-$;(eFgG@c+@cLTBle)0Nqx
zJg*e=RIUANM>)a&IHj6r6^k>nJSl0MTEJ$n>SBr%siuV&fVbzJMB)FE*+y?Ovgea$
zAox@_);41rwVN7j+~ce%2M)%nQ!@nHaZrw^45EVWDO&NK`$*=k9NSt-IXsE-lqNH|
z=1`f}zf&gJ_}x>PszC~`4KHyv1`z~WB1zAmd*}HI116Mun8MU@?XZ@(-@(tpv9F+1
zyb#Z9#%K_hyY?~tV4x-^`vqnL#?zi5t|>+-1RC`DQI_@NdpA2$G6*;l>Ze!UDp{8q
zAei*=eoI3G$b0-xuEvlLtg%~c^=CAR&pJ1h$O1y~zYD410su<lO7Mth3AhE%0WUi~
zf_iZ#umBN;X+RT9OALSn>re=rZ{<Tk7Ks@+u|@L%KnaIEvtPdu0HDW&DMCur0AGoe
zeIV^Oqa{IUVd>DUD$+@)b#+Zo+<lH1VJJ0<vz|)H@|s}K7g7V-DJ(|N-06w4fKWm2
z<M+g92vP3CqcmXYApn(kejQ1OhM@N#WZUEt1=k*}3+EZtCy-AmItzd4s8dvEDK(xB
zox-CGp!ksf9lZ>*=*Y_I9Y^G^aPuefiYN~a$V#Y14wh_2Mdis>R>@$nq~?W9FRemC
z;X|PM+Tl<&zek6P2ih8?uNpE!s6O@kWeD&ZUlXMRQC$G7m(!=bPie5|E0SGwa_U<#
zRk%H{`4E%FWG^xR2!Ac$T}`Oc0vVOEUdySlm?V+uV<G&f3rUbk2bqWXt4fBju+FtN
z+a+W-?+>gk`y)U`DGzO3>4I&l<m?5Cn8xt_TFABwvJ(0^`+Lnqi>qGhGtA3?%Yu;5
zbx15}OvEJoG^Fy82+y300`XzLF`Ek>s{pGq`+bs153xA|k;^Xh=cPGq|1`$cG6Y#y
z=p`pnM3;RY8iqJ1+u*Y`>hpou^R~l$L%TS+6xzSxR3VxEF_K;g^nw}Xb!goO@&8&a
z84Vet^{PKg;6kPFUx}jgJUfK}|6;n|=0ZI769?^RYX7!T_Jdp(**-+{6W`CXO&V~u
z;r_l88k}xD77NZj)$A(ia)ru`l~5@sHhX3=BAI=;-E(R;rogE9Dxf_V>%L#34^fYE
z(89S-B#JJ0Ye{2OcG$<)#9#b^;52~Fdjn<%m{gM~0r~>okeDM_G=v+6!Wd4M9AV*1
z4+dS5I*iX@J^-vmKVx5B;h)c|U#HP3%GE$z);CS4a!h>MIvG)hGT*tqvqxm6tDU_b
zwB@hlFxCeAWAa)SFuW-L;^><k=~Xg|_>(FDm7J_@*AjJe*uk|9sN-E14UF}+Wg+sU
zHd|9b&q6bjufp9)g(XX}EA<$cLL(n9EpAnl3fQ|n@s%6S%{A+3YqQQ4Hs$8L_p$BI
z1uOFXv@<r)QHS4%Uu!I_a;i}avza7`bRW1=!%;61DtrqeBJ}7#XX)9~*4ntxSDF@q
zv2uESu}r^t%fp<Rj$auP>gXG`texF=%mPhw)^O?i-deAr^9b;cR|*lLG4ka}d_FoT
zzqNHD<kmBWIezujmf6W>pt^8jY^q9@#w{hRxNo=q?MzwvP_59j(h5vb_T|~37E1{n
z2Wv8Vh`}AhUgdU+L2SJk=(KQv0}0DX;MLf_{cHeb3Lmj|4>K{6Jk_7^`~K5+{mis1
zbiT*cYG7Yypm3&`KAAfQWo>$1J!0K_b|CZug7<^Z!w(&@GP%~eua@7$sJg8zvM%}l
z3&iaLwcuXx{j}&5aUFNlsCSMPkX4$xR*WKi%Uzg35d;|*8O?DQe<Bg#LxHpUr3L*M
zoU3ut5Twsf6PCzuQ4oxt`}-#cb-m~3Ch>K>rA%+N-aNz!RKg@BEZ&$;lX;`lQR^t#
z5rL~v<^0&Z)9*_bgKI^X6-H+Oo_)q(b4QQ5CAi9bIc-jICFxM}%_&C+gJR-`6Hw7!
zjb7@@o?HF1%(lY=s8xmZ&)Y`a-lroWgJ8Kci&6uD&oKN<7$y0{c=uEctlx=+3Q)2^
zFAL&6!Ayj)h=VLve)rml*66o??J&ZGD@dmN!DySE(f{^`&U<(YOwyyMT<IQcu?yn9
z12fYA$_DM8naM-3HCnmwg<-5?xm9?Pj0oo_O)(H2)$o8?VnxRLWhSY_H|2c-%af*g
z*(7ET<iao^v}3&HThVkQ&!W%%yqj3UV(iO}x1Q6lJTBI)0AD+#a<4+x>6PoLCL28i
zBz)+j<<K84^ZGH*i1r}Q6;53{B!w@8Dk5Wh{8xo!$K}et!0dIJ+y@uz_es~}=OUfR
zjSO00>E+kbiwPpBm{&N3R9M3}w6fLDx$WIyi?sHLmQ<yt!jj;;K8HdwEOAoII<7CT
z2_|rmu66PFfKSK$i<C9>XbF;_>-H2;5P2fK6vzh|q<!=g*oU1X>`KS(I2y7Sp0%e8
zgRHnG1GmOlzNyc}fOVU~e4CwA!a9Us6BGkS8$AHOGfeSdixj*l<fYFQT|nPF=)}2t
zT1hLXmRJyp4aPC#Uxl&2AMeq;&$PvBIQY&G`wO_-HDTYcbA}=RDfA4NVkVQ&(Hyqe
zuQ0E#7sX#9jjaBYot5G!?p|ZK@8QQ`w4C<2wC&qC#mV_UmP>+EG%SD1z+Ty4x#NGR
z@cwgiVd$(#|AR){&S^=@wJ<8dn}Pesm!u_2O!+7~CX=QL$gj3!8V#@S=Ad~@vlY|0
zG2yshz%_#`noCJquZ6taiP<t{MUX?i`c_W*N^LGhKAgOPKD7CuI?ov+ydJ9R60by@
z4_vm!@cfo(B4TjYh&CoRP`0Ee@FVG=ekm%5_V2P$ol@x#PZMS>j=)$y->%-G4G@z~
zQvpBZJ6h$!ghEd7C^Z=ehxb1HuxxZ)a7q<mVL0#t%g+xH9PNfqFhK%D&7{_SilfNQ
zNW27{NI0Aq$EerxN$xBc9IN{O9HK(qI~NohYgkm^`#PaI5cirRega3M(qAg%<pUH2
zl$QbY$Po&h&6XR-xQ|vzd8x8LFMUv$bOaaW!T)ia--mFtC5!xvQFM_4n<R&bls@O*
zECA*BL7x~=Q61%~f&Zt;gv=Azu-5+VVCdGCd&iHjr!unHI=#=oLgGAl+2f^TFi}K@
z1nW<8a71G4*Ee#Fu|qhfyd7p>_iW~9dSS!AY!xc%TVN`RX6tgpgrXGZwL&`oGFB3-
zCPO$~A8B~X94cB!x3{)KA%9vTCcjY77$DMqNwc!nits0W&VOk=D^cWpvb!XhNlMqF
zP>ROIfeR|te_>D1xOw$A@@9v?gam!ar8HFIc^WaFe2Nz#u!_ZY)?{e!)LAmp%qI+K
z{OKLcW)+hbJgR~1y=Nr;Jy;_2ZP|>@J(yRLNo4np{^j99+%7$h9&M9y++Wl5tmE!g
zU@C6rdvNnctcc9=8kl31MEx?oiX=e)EfxwlzwC$+0?{?+eX;U78>!dJ{C))dfwc>?
zQ8ADykTS!p+_18JD#(>b-zAzXQ1bBaAUTfX$XzQfYg>_Z7xh)W?BSI-^}`kO$4Q@-
zpbgY8j4J{zVp0l=IcCBfv_&nB^!y+FdwzEDb--;ZdNlXxWa01}8vg5=CsQuzcyemt
zL6UDxKLvqbM2~mm^&XEN;O;z_P1TwGl}%2pc=q0{<;g#mrU8SoJr`8@|4AiW;D2lb
zRUZ8PDa$KW(fU6YM}=B5vXtzeMtE^cW1dg)Zz<*{qK}{#=%|(RJ0r~pW=~6pslfpN
zeEO}T0FuJSMUjFn|IisR43+^`Ivd^b=}h+XIm}OPIo%ZX29k~fNA0UF!WdUf5ZWip
z@rQ;*MC{r~tIS{YI?a{xd94Rs7MYzFG_L1VTYIxdwPU@$p%<IwjK%N7?Y@`qP{~VR
zd_7k3giAz3_x%L!irwj*FysQ?200cLIjPD00y;Z8SAPZtm8&L9<!CCx>4;5+LZlkx
z0KKv>4iV3!`Wlk)p%Bq0o?&l*KAtvxvkRAzn^oVo_rF4j@Y&I{-}F~QNIw7RwTB6D
zhJKn9ztcO*?mIZd|5_uY@;Ttnn^JsiO~DQ7MEiyVU5p_G1!?N2DsFXw+Oz#6F}ZJO
z)yfVY;|x3?pdzMUQDB_t!8iG)uy)?|es%ObIl9z5ZM(Yah>9VP0)eUjXoM)p>|4WD
z*GW>=sFml#M}p|`S8ZIBMfK)0z`YfMXz89~S!5_72g0hgYOV>t#r)>>3!Coe^&h&+
zCXS5^6@v96yXghJ3T^zRy&Ifz?+f^B*d3l~ri5M~1-x$8>K^G)J(KTqzdMePH%qOb
ze%pch(HTX#Y@B^acVJpyo8o9YVB=)t(GZl1K&0Rl2Oyp^!-SG6_P_fX;fC5UWf89F
z=_9JpVL}?CE7D0tJf+jegOlKaJR3rUEN@l1kIzeF8zlU9mqk0SF49m|#jf(Va-BlX
z<|PRi5J@i+`eqELnmKnGVl_&#oEcS7>uNA#EpHPWA}5yACHtt_k(@KEgW@&$lykM$
zK=LxXFM8%)uCgYB?yMcX3R*vYuwiP8IntjD8OB<JhOx?>Zzaw?(egx|6R5r%GT>=G
z(<*idGZ$be#ERnNN#vE#buQQ;HdYa$b;(VD&=Olt>Z%h5N|V2>aKcmVXp_+tKb%Pp
z!oV#*E)D)oS5HNUM;p(ef`_LdIk}>L*cb^NSZS+yg3NZDVK6}uC5k=nivP}5p!PkX
zo2Y+>fhf;2jzEI8UF*O)lM0{`+mQkEVrktap-Eo%h5O^aF%hgP<XQB@7pgp)Fm*y_
z9-sr-Ck{(yW3u@RM2ROav1f8UOD;cBeM7qVKzk=fCH;V>Hq-#T@^l3Gg}3~G_HCuc
z<)<X+f??`p=|&ZsA@B^*`to#?S%Bc)JK)WzDI&pbU_w+Z1RRFX+4p!->nlc!hb1OZ
z#vz;iT}KIoTlNKQuJ{vtBe4B$w$(HVWmlM4TUW>c_!f%JpckgXRc_pF0+uVe1%G9V
z(xV^U3SX>x>DKs5F_t>rxW>*D|6rKr@|r5d3NtQ3$Z7Pg7erz_mF(GZP(N)#r<0!}
z{rGOAB0$5o-`Hs>?9AS=I@CP$AQ3r7`)X9iR5`nP)ZhJ=q0CC!aLWKaWmBRz93#OM
zMPfLC)fBMe#;l%IEyEL$Y17wPdyhiHT9G|S>&Lx9R(F(cFCTh~r%|pL7)m;=UAItq
zp7ki_Z4jgadA?zBwrp*kB!);<GEg(Vq2g=wK_@4fdV!O(V|;i<8^TAE6U)2t%Vjoy
zXH>OH*5Dh?p7-E1tsAS$p`p^*@8X-y{9d^4QOTarMgyE)y(B0ZIa@$^fHECEII&SR
z?eN~o4u5us4&C1VN-A8Yb4!H1>@3fNaQuGjIM0+@9odEDq*3bs`1Rl51_1gG6jb36
z;S#xP?)LJsl4J>yoqWqbV0Cor``*ppKaafl>i?1S6sRu{$YUZ!ahlx2^AK%e={|a*
zgqzrL9PNAPA6q7^<iYx8<X*@5`u`!(i~<V(NnoO8^~9~+l`eB91ONQN0Is*`vC)g#
z=A}m|N`aXYaFTtp&qt9Sed95D=N1jTh%fv4sqD-To#w)uZ8lRc{8dCj(^zxl4f%G$
z$$5bLQ0MoW-RSVzyY+`=k6G3WIAa-KZ^U$`90$>K@nExBtkuaymB*1Yk0(biVx&Si
z4=zY@uHCSd8whbC+VOB<24OSCwbI+?Jw&A+F2{wmhlT3u$|ERf>(>rrEom;1&K2v6
zYmq;SHl!fsZ~6(f$+g~i`K|Dlb~Zy$L;ccftKGAq0VPyv>U`G-jlOZuZ^V5Fc=t5Q
zqO+TkktcK4l7xa-y7nvNF=`lo`_QIC$m!V?VV|a;;4Q_BTs<ur2#`#$v2w`5#&1Wv
zFFnJRSf;b#&jGf-8qd|za;8YVxUWj#{)1Vr7{O`i0^iQid5Q;O7<+7cjPL@v<(IQL
zAw2j90wR*vjw2`IyXaf6fe$1d>ac`sg&uPl9YzO`%i5v<W{_jAolVWv+=9pEUl40j
zjdl{!d=<#OqpijL)19Z?ywm?|H-o9Kaux}#lh=*0Z~Eiq+pvOkJ!_U{9mH)c6F^AZ
z{sVR+cs||ruxMhr$2%sz{rt<MzoBl(LM9oBY=#z+&+mR3V4*E0bs}G9)9LK|LfNyg
z7}?Y8+_y0G%486aLQ^Pu(3Mt^8l@%CCPFrxrmoKe$BYs*KyT;WBdB*iMea{(Z_G-V
zhwZMPow?c!?5j<g&f{aJBw=^Wy<A6WZOWQu?+{I;DD2Coenj0CwNL?>jhd-WCO_Pj
z;;cff;op78Sz6ap!Asfw;UWs^1lOxMic5XI;v(jCTGNU0Jm89Q)q!_c=SJ6A7U<(p
zGz6?gSY|%4MQKJI6t4WgXy2jjYNc3e$L1jNbE=JyA0;?m!(MF<dGMVqIWJsjE4#_d
ziu3L3q*z|cHTfcxJNk+63RP~Wr>35p-w}f@C@fUZ=JQUt#q%<!Me<vquCmp6_He(M
zs)OIAUOF4s24R99-}O{FTHe*CVn`#(y!E`gcBN!bu>Bx_2!`*&A;54G$OMk0q`12Z
zwjh+FNU$2rhqu$~$XmXdknDbWR%*3UFR0}Fc_J_)7awUv&64j}p4KOhR@l2(d8Weg
zqXd$C@l&aC{3bPFaP2h?3bDm>F#Gi9#8u&4D&P6_c0&Z(Cx>3$wx>WDrJwUF+{5Sw
z<3!zC5)-X&C_%2`V9sWL^z^;m;n?7$0dy2ywF0!6@nhG`wK;B1r{c!2ZLGHNv&$!B
zvF%RqU2p5v<#O{BEzktFuyf;T0MoKT%wLnsP8UIKs{F--SF_^!sSy&|HmtiB#|wDL
zM3f0+l8-L{657s-tXeJS39Daiq)GOEx9f7<Hyy09<}@LQ<|m`boWMzHl@WHT63P^}
zJv8hj=#4Te&Xw=|7QT@O?jp!E>s-D`srdO=Ae~So#e$Zo*2xaoEtz&OiftaC`)%WA
ztQH?%{+m9Mkde`O;TPpo-_J+!^z8&)4@8l2<_)$hZfLePu;OSY=@MIP%Yb(}$A^Pc
zC_3(CA_Rv$R~`l>6p*t=Ez0wn=53p3&$v}QD+<<2!aWkH6jIwvqdn7KFTk$$RYHq6
zB;x1M&Q`>(Y+vx|)qaJqbDg9<iIH#iyOwsx40lHi<+KR2g?_mDR5gA2iEeG7$JNI(
zpj;~Q1d)hD;6PQ8%`a`GAk?wQa)J4a_TL9xWAnEauveaZKXBzwd^c^O4*)M{pX_^^
zKEnSaZhqG094IkxDA0+ud@($?z9LQeXomYtHV0UGh2!~7SrQ(IH0}Q8nyDpnX;jIN
zQ3iV@ZfcMb9h9m|SGaAlt!AqX2{QZm8ops>{{wpnuhQSOc1g~BsSt;+`P}ECK8{QR
zWC=c1$RQ*LM94j}=p0+2m3Qo%)lIrWVz(?lGyi(w6+phcV>=SmNgkgRUTQiwhSie%
zd1Q(`!PwN+S;k#3lM~wCn5qbYC)|1k)b5h+I3H8&FZ3)Q7;V>V{pucbn;$CW=T&fG
zL(Npr?+fd#(Z+H-WuxVN8#1STd7^yaKz=mY4&NS-d?AmIMyKkb5vAl~OK?-yyD@kC
z0H0AOa2*u%&IIuBi$oqUx#Y_pg6%hAV7ql54Z#ynbujxIpMs-sfF~7<a=p66KiZ}e
zY}K^l;_IEIqHsFGKUnuSH>5Hlt4nE)XH~XAYc_T!>>@w@q$k!4%8sw`!Y6w9sX*1M
zCd(#y*JCV#B-v|LYlJB>*T=1F`jp@(=gH)CQ)5qDIyI0>asMW;*HO8W=jg=URw{=|
z5gOY!#yk7NvZ)ghQkw32*-_N%YD4!2O%W`5GLpN#)UWpx#R$AqeS^S(EcJ<?QLL4E
zMtxgLIuzF>iNr@3q3FacNzc2FrmRz@4W70|8vG4|jT0~GF1CqU-3Gtj!Z2uZsVRDi
zZrQ}sXFiAID8YnqLMgfQ*c5Uu{FfVBPP^-K3|(KXZRQTowTPey2F-nn_wzsLR6&n#
zVU5i;5DKZ$5MQQi3W6)wl?Gm@lu>5ao|?_2G$qsR6j9@;+(lGZ*y;shyv=;s)1z4m
zdgXUZskJjA1OiAr?=Z*wRM7tT82~_p%f7sXl86CxkA^~m(NKUejr=2s8Sfq@I^5I!
z|CePZ|I?y&HJ{6Jt3NhzQH)O1Qt+!>h{O|AO$)=XJje&YQp7lG;PaU08rr^}TCBRi
zJkbAD1tEVVFsvtCpfuI;Iv(tVL}~T?APG}dK(IFHurnF}rYN*xBJX=D#G6E2W-*%P
zS<<a&{3=`MN)&<nb<48zhpe>aJ4@2zB#>|$DH1#<&9ysR6_xgJH2hgtvN%p!e1q%q
z-Ec8-HJGI-O|Vklir0NpZ~vT7BOS)5b~i7#tI29s^RqlOBU|Mv8maVr8rt;1qJa6!
zFfX)HmRNgki#yBHkT`LN>5N6|GMeAkGKbAzUhsH;v5&0hnjr?L>Blb^6zP{ZpA6^^
zhP*jfWr&Bc7iiQ$WEEfa{sMl}o8&wg3=hB2AK$E|sr0mKyK`&W)N|6fYR?AI{s$hG
zj%RM1NRmu0Y!%IsVw||!*3)r2Y>B+9eGN4bE?#`Zg*^8n<}y#66npC~#*wLw;xU%i
zjtBC;y}ezHH-fr44sIjA$O_zU-!<({(K>7V9i13UOv%n{{*Dg1<^2zhD?LHE;kP^C
zf;CHrXo7d<XNcywzO`eer_;2YDYc2LlK&>rTOtaaZn~Xzb&~cHpzxQ>A$Xn_rh0-m
zU3xb=*ZcEzJBK|zlGX@;(qNg>U=5HNfmy8F?Ix9{+v+NO+s6H7Tkq<y@92yD<6S}>
zF2IYgkeX(~DwNc0JR0cl$$21&sA$fVV!M8sH~VtkNJyM4iQ2-Eu0gPlFpAV?N$Es6
zB3}0DX3n+V!a{f7O>qlrmoRDIU%~dH4VL5(S+w!nEblu7#oZcC0AED5gec$2^L#EO
zQwn68ko)|V+4N39gsO6d$Esz;Kqj@35{nS1+bM{0>FRFZT6H-!ThjeX!0$?}bRUNk
zbKm6X)P8=;uynu1&5Hc{I~|#r^KK!t=bY2BudrD;PF8EnE6l{bjvB_EPt%s!)KZ^$
zDu2_wbPJ#SE!Np!7T|>-*y6W_(mvMW^xv@6*I(8PP4t?w(#y&E_7}igrM>(`Ccs-)
z86o#HyNi?)c$|NG0&U!a7mwlK<3o=_`@}mRRYnd8ly3IFwU6bHZK~LW5$4O@g;=i?
zY;oEnvy8|X=pK*oTb(}kC;%56|JQ1Ome={594FH>@#Hs`Cd<pqrgwcNG<%@gOTpsC
znCC)X=%K6v*X5lg*7Zkt>D6^idDT+ae9V+&U9W9hChsc*$}t`_;>~Ooc^yT;($mvH
z>be5#0tKOdrw52o^h}$Zz4E;4spcCFmF3qar8}UF93>zcR~?0s-6O1Cd$p-BvjX3{
zKHC3OHE`>(K?6PRwCrm7vYCI`?Pkb!Mtm2B{dbC0G@rk*c3^XkXxRER#S*3HY#1-a
zzK?CCSI7P|o?FIjlRWSHx5SFDm1-VBY*NUk5wW+Ti{R5t;@xf<4qIK9%|G3bV_9Tm
zJdShj6lW^scV0*H7XXv5C{&V$F%By)7Zxtwqcron!c(2)24`foF-{oEbKKsQfJlc~
zEe;oSO+QB}uaC9^)WuD$jBKol#Wy0%bQLJrlSTMU#om7y-_E`?ke&Ll$Q4z4aCg|<
z^`0vt=4P^L&F_pKeZ0wZloVBb@TzA)udn*HjVk$~Q~kJ))~x#Aip3;9-P3SXgB?`Y
zGxjliNc=ERIT^AObYGQ#@$Xd$ZpXw9WNjhcud?b-oFL2cG8QNTgfsqEWW1H(bqW+Z
z1(F}jKQWTqn-dV=6vfyjtnW4sAI3>SGEI}@127Ss<&cdsL7Sa=#@`+p>1RpyAY0ip
zu8+N?ElVL4k8ST3P4uqUi?=Xdfx+MbuesvB=`KC49VS3IfZZ2oEk%CcogOxixlO^Y
zF*~2|c+sGrt_T?;OV+kLNnm}RFg#V`1SgHdp)fc9#CDD-yW5-5b30eOIppw!9;P}8
zp?q0+f>Y0viTTGRVuy?-nm4SoFVKsLIr1Fd#NZI`?Yt7G6HUGIjfDSx#ujKZ-9Ctu
zd+8|RBM^CkKKg#>J1%}W&g=!!aeZJDW9-^xy?8_ZZx8V;F~?aBaIng}pm5mT+f(jT
zLk<xPR!+7l-$Ii9nW4|o)2>DvOcqw&igxqIn3{gA^Tl`7{dW`C8Jky~RGU8cE7caF
z?G5h`8+<r~bHk~QB0A3MFL3P|F5)}&z4&%mzPUDtii$7pt?Y54ufD8;;(s_tVt??_
zlRSK1`lb%QamC2?Y_k01ua^`9QMd7^lsr*WM>)xVSrXy@UrQnu-4~GG!nTA_z7aKn
z>tltPgq)+&{1Ph$iGk-ec@Ywz+4SaS^XOdzKgn0jRkp{7_B-77s|nS43A3(rOsz>>
z!Jdx1UCIjK!LeJGV6h=_(cs9<k*S8mk>)wicoyJldu-}f$xGrXL#M3O+sY*Jo=<@L
zK<Q+L=^5f6D9rTsg&}WdmTn7+&X8Iwxw2}oe@!>$oNS=+M$!&;;6~j81#37!(byTs
z5W__51>&XJd$KZJ07+ineHrTuj{g^=2T)o0j>=|n%np%39g4C7ASos%S|qIR^S=Ng
C#z+hR

literal 0
HcmV?d00001

diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml
new file mode 100644
index 00000000..a62e8de1
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml
@@ -0,0 +1,74 @@
+<!--*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2014 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************-->
+<local:DemoView x:Class="Xceed.Wpf.Toolkit.LiveExplorer.Samples.TokenizedTextBox.Views.TokenizedTextBoxView"
+                xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                xmlns:sys="clr-namespace:System;assembly=mscorlib"
+                xmlns:local="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer"
+                xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
+                xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters;assembly=Xceed.Wpf.Toolkit"
+                Title="TokenizedTextBox">
+
+   <local:DemoView.Description>
+      <Paragraph FontSize="14"
+                 FontFamily="Segoe">
+         <Run>The TokenizedTextBox lets you display a series of values as tokens. If an ItemsSource is specified, an AutoComplete popup will appear with a filtered list of valid values during edition.</Run>
+            <LineBreak />
+            <LineBreak />
+            <Run>This feature is only available in the "Plus" version.</Run>
+            <LineBreak />
+            <Hyperlink NavigateUri="http://www.xceed.com/Extended_WPF_Toolkit_Intro.html" RequestNavigate="Hyperlink_RequestNavigate">
+               Click here for more details about Xceed Extended WPF Toolkit Plus.
+            </Hyperlink>
+      </Paragraph>
+   </local:DemoView.Description>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    <Image Source="..\OpenSourceImages\TokenizedTextBox.png" Width="600" Height="400"/>
+</local:DemoView>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml.cs
new file mode 100644
index 00000000..814297ab
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Text/Views/TokenizedTextBoxView.xaml.cs
@@ -0,0 +1,63 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2014 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using System.ComponentModel;
+using System.Data;
+using System.Collections.ObjectModel;
+
+
+namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.TokenizedTextBox.Views
+{
+  /// <summary>
+  /// Interaction logic for TokenizedTextBoxView.xaml
+  /// </summary>
+  public partial class TokenizedTextBoxView : DemoView
+  {
+
+
+
+    public TokenizedTextBoxView()
+    {
+
+      InitializeComponent();
+    }
+
+
+
+
+  }
+
+
+
+
+
+
+
+
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Resources/FancyStyles.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Resources/FancyStyles.xaml
index fd1c2c4c..a84cf966 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Resources/FancyStyles.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Resources/FancyStyles.xaml
@@ -16,7 +16,7 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 
-   <!--This file contains some "fancy" styles used by the StylableWindow sample. They are placed 
+   <!--This file contains some "fancy" styles used by the StyleableWindow sample. They are placed 
    here to avoid cluttering the XAML view of the sample. -->
 
    <LinearGradientBrush x:Key="FancyButtonRegionBackground" StartPoint="0,0" EndPoint="0,1">
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StylableWindowView.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StyleableWindowView.xaml
similarity index 92%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StylableWindowView.xaml
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StyleableWindowView.xaml
index 1d8b041e..2417692f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StylableWindowView.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StyleableWindowView.xaml
@@ -13,7 +13,7 @@
    Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
 
   **************************************************************************************-->
-<local:DemoView x:Class="Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views.StylableWindowView"
+<local:DemoView x:Class="Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views.StyleableWindowView"
                  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                  xmlns:local="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer"
@@ -21,13 +21,13 @@
                  xmlns:res="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Resources"
                  xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Converters"
                  xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
-                 Title="StylableWindows" >
+                 Title="StyleableWindows" >
    <local:DemoView.Description>
       <Paragraph FontSize="14" FontFamily="Segoe">
          <Run>It is possible to style ChildWindow controls as well as MessageBox controls. All the chrome of their window can be styled (color, thickness, opacity); their action buttons can also be styled.</Run>
          <LineBreak />
          <LineBreak />
-         <Run>The "Plus" version provides a new control called StylableWindow, which consists of a window that has all the functions of a normal window, but which can be styled in the same way as ChildWindow or MessageBox.</Run>
+         <Run>The "Plus" version provides a new control called StyleableWindow, which consists of a window that has all the functions of a normal window, but which can be styled in the same way as ChildWindow or MessageBox.</Run>
             <LineBreak />
             <Hyperlink NavigateUri="http://www.xceed.com/Extended_WPF_Toolkit_Intro.html" RequestNavigate="Hyperlink_RequestNavigate">
                Click here for more details about Xceed Extended WPF Toolkit Plus.
@@ -72,7 +72,7 @@
 
    <local:DemoView.DataContext>
       <!--A model containing the brushes and other properties was created to share theses values
-      between ChildWindow, MessageBox, and StylableWindow.-->
+      between ChildWindow, MessageBox, and StyleableWindow.-->
       <view:WindowModel
          WindowBackground="#FFEFAC27"
          WindowBorderBrush="Black"
@@ -129,9 +129,9 @@
                   <Button Content="Show Toolkit MessageBox" Click="StyledMessageBoxButton_Click" Margin="10" Width="150" Height="30"/>
                </StackPanel>
             </GroupBox>
-            <GroupBox Header="Stylable Window" DockPanel.Dock="Top" Margin="5" HorizontalAlignment="Stretch" >
+            <GroupBox Header="Styleable Window" DockPanel.Dock="Top" Margin="5" HorizontalAlignment="Stretch" >
                <Button Width="160" Height="30" Margin="10" HorizontalAlignment="Center"
-                       Content="Show" Click="OnStylableWindow_Click" >
+                       Content="Show" Click="OnStyleableWindow_Click" >
                   <Button.ContentTemplate>
                      <DataTemplate>
                         <StackPanel Orientation="Horizontal">
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StylableWindowView.xaml.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StyleableWindowView.xaml.cs
similarity index 90%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StylableWindowView.xaml.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StyleableWindowView.xaml.cs
index b8fb209e..9896e163 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StylableWindowView.xaml.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/Window/Views/StyleableWindowView.xaml.cs
@@ -34,33 +34,33 @@ using Xceed.Wpf.Toolkit.Primitives;
 namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views
 {
   /// <summary>
-  /// Interaction logic for StylableWindowView.xaml
+  /// Interaction logic for StyleableWindowView.xaml
   /// </summary>
-  public partial class StylableWindowView : DemoView
+  public partial class StyleableWindowView : DemoView
   {
     private const string StandardMsgBoxTitle = "Standard MessageBox";
     private const string StyledMsgBoxTitle = "Extended WPF Toolkit styled MessageBox";
-    private const string StylableWindowTitle = "Extended WPF Toolkit StylableWindow";
+    private const string StyleableWindowTitle = "Extended WPF Toolkit StyleableWindow";
     private const string StandardMsgBoxMessage = "The standard system MessageBox will always have this look. No styling is possible.";
     private const string StyledMsgBoxMessage = "The Toolkit MessageBox allows you to style it in order to integrate it into your application colors and styles.";
-    private const string StylableWindowContent = "This is a StylableWindow that has the same functionality as a normal window.";
+    private const string StyleableWindowContent = "This is a StyleableWindow that has the same functionality as a normal window.";
     private const string MessageBoxStyleKey = "messageBoxStyle";
     private const string WindowControlStyleKey = "windowControlStyle";
     private const string WindowButtonStyle = "FancyButtonStyle";
-    private const string StylableWindowMessage = "StylableWindow is a standalone window that can be styled just like ChildWindow or MessageBox. This is a feature of the \"Plus\" version.";
+    private const string StyleableWindowMessage = "StyleableWindow is a standalone window that can be styled just like ChildWindow or MessageBox. This is a feature of the \"Plus\" version.";
 
-    public StylableWindowView()
+    public StyleableWindowView()
     {
       InitializeComponent();
       this.UpdateWindowsStyles(null,null);
     }
 
 
-    private void OnStylableWindow_Click( object sender, RoutedEventArgs e )
+    private void OnStyleableWindow_Click( object sender, RoutedEventArgs e )
     {
       var msgBox = new Xceed.Wpf.Toolkit.MessageBox();
       msgBox.DataContext = this.DataContext;
-      msgBox.Text = StylableWindowMessage;
+      msgBox.Text = StyleableWindowMessage;
       msgBox.Caption = StyledMsgBoxTitle;
       msgBox.Style = ( _enableStyleCheckBox.IsChecked.GetValueOrDefault() ) ? ( Style )this.Resources[ MessageBoxStyleKey ] : null;
       msgBox.ShowDialog();
@@ -104,7 +104,7 @@ namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.Window.Views
 
   /// <summary>
   /// This model will allow to share the style values between our MessageBox, 
-  /// ChildWindow and StylableWindow controls
+  /// ChildWindow and StyleableWindow controls
   /// </summary>
   public class WindowModel : DependencyObject
   {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Xceed.Wpf.Toolkit.LiveExplorer.csproj b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Xceed.Wpf.Toolkit.LiveExplorer.csproj
index 69a3d3db..0708f3db 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Xceed.Wpf.Toolkit.LiveExplorer.csproj
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Xceed.Wpf.Toolkit.LiveExplorer.csproj
@@ -276,7 +276,6 @@
     <Compile Include="Samples\PropertyGrid\Views\PropertyGridView.xaml.cs">
       <DependentUpon>PropertyGridView.xaml</DependentUpon>
     </Compile>
-    <Compile Include="Samples\RangeSlider\Converters\IntegerToBoolConverter.cs" />
     <Compile Include="Samples\RangeSlider\Views\RangeSliderView.xaml.cs">
       <DependentUpon>RangeSliderView.xaml</DependentUpon>
     </Compile>
@@ -323,6 +322,9 @@
     <Compile Include="Samples\ToggleSwitch\Views\ToggleSwitchView.xaml.cs">
       <DependentUpon>ToggleSwitchView.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Samples\Text\Views\TokenizedTextBoxView.xaml.cs">
+      <DependentUpon>TokenizedTextBoxView.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Samples\Window\Converters\IntToBoolConverter.cs" />
     <Compile Include="Samples\Window\Converters\WindowStateToBoolConverter.cs" />
     <Compile Include="Samples\Window\Resources\WindowModelEditor.xaml.cs">
@@ -331,8 +333,8 @@
     <Compile Include="Samples\Window\Views\ChildWindowView.xaml.cs">
       <DependentUpon>ChildWindowView.xaml</DependentUpon>
     </Compile>
-    <Compile Include="Samples\Window\Views\StylableWindowView.xaml.cs">
-      <DependentUpon>StylableWindowView.xaml</DependentUpon>
+    <Compile Include="Samples\Window\Views\StyleableWindowView.xaml.cs">
+      <DependentUpon>StyleableWindowView.xaml</DependentUpon>
     </Compile>
     <Compile Include="Samples\Window\Views\WindowContainerView.xaml.cs">
       <DependentUpon>WindowContainerView.xaml</DependentUpon>
@@ -630,6 +632,10 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Samples\Text\Views\TokenizedTextBoxView.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
     <Page Include="Samples\Window\Resources\FancyStyles.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
@@ -642,7 +648,7 @@
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
     </Page>
-    <Page Include="Samples\Window\Views\StylableWindowView.xaml">
+    <Page Include="Samples\Window\Views\StyleableWindowView.xaml">
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
     </Page>
@@ -964,8 +970,6 @@
     <Resource Include="CodeFiles\PropertyGridView.xaml.txt" />
     <Resource Include="CodeFiles\RichTextboxView.xaml.cs.txt" />
     <Resource Include="CodeFiles\RichTextboxView.xaml.txt" />
-    <Resource Include="CodeFiles\StylableWindowView.xaml.cs.txt" />
-    <Resource Include="CodeFiles\StylableWindowView.xaml.txt" />
     <Resource Include="CodeFiles\SwitchPanelView.xaml.cs.txt" />
     <Resource Include="CodeFiles\SwitchPanelView.xaml.txt" />
     <Resource Include="CodeFiles\ThemingCoreWPFView.xaml.cs.txt" />
@@ -1047,10 +1051,20 @@
   <ItemGroup>
     <Resource Include="Samples\Rating\OpenSourceImages\Rating.png" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Resource Include="CodeFiles\TokenizedTextBoxView.xaml.cs.txt" />
+    <Resource Include="CodeFiles\TokenizedTextBoxView.xaml.txt" />
+  </ItemGroup>
   <ItemGroup>
     <Resource Include="Samples\ToggleSwitch\OpenSourceImages\ToggleSwitch.png" />
   </ItemGroup>
+  <ItemGroup>
+    <Resource Include="Samples\Text\OpenSourceImages\TokenizedTextBox.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="CodeFiles\StyleableWindowView.xaml.cs.txt" />
+    <Resource Include="CodeFiles\StyleableWindowView.xaml.txt" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PostBuildEvent>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/app.config b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/app.config
index 0893bea7..a5dd4154 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/app.config
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/app.config
@@ -1,15 +1,23 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0"?>
 <configuration>
     <configSections>
-        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
-            <section name="Xceed.Wpf.Toolkit.LiveExplorer.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
+        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+            <section name="Xceed.Wpf.Toolkit.LiveExplorer.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false"/>
         </sectionGroup>
     </configSections>
     <userSettings>
         <Xceed.Wpf.Toolkit.LiveExplorer.Properties.Settings>
             <setting name="lastSample" serializeAs="String">
-                <value />
+                <value/>
             </setting>
         </Xceed.Wpf.Toolkit.LiveExplorer.Properties.Settings>
     </userSettings>
-</configuration>
\ No newline at end of file
+	<runtime>
+		<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+			<dependentAssembly>
+				<assemblyIdentity name="Xceed.Wpf.Toolkit" publicKeyToken="BA83FF368B7563C6" culture="neutral"/>
+				<bindingRedirect oldVersion="0.0.0.0-2.2.14066.5" newVersion="2.2.14066.5"/>
+			</dependentAssembly>
+		</assemblyBinding>
+	</runtime>
+</configuration>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs
index ce1db48a..693b6601 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs
@@ -21,7 +21,7 @@
 internal static class _XceedVersionInfo
 {
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
-  public const string BaseVersion = "2.3";
+  public const string BaseVersion = "2.4";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
   public const string Version = BaseVersion + 
   ".0.0";
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs
index 0ea459b7..330b8d8f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs
@@ -21,6 +21,12 @@ using System.Windows.Markup;
 
 namespace Xceed.Wpf.Toolkit
 {
+  public enum Location
+  {
+    Left,
+    Right
+  }
+
   /// <summary>
   /// Represents a spinner control that includes two Buttons.
   /// </summary>
@@ -57,6 +63,23 @@ namespace Xceed.Wpf.Toolkit
 
     #endregion //AllowSpin
 
+    #region ButtonSpinnerLocation
+
+    public static readonly DependencyProperty ButtonSpinnerLocationProperty = DependencyProperty.Register( "ButtonSpinnerLocation", typeof( Location ), typeof( ButtonSpinner ), new UIPropertyMetadata( Location.Right ) );
+    public Location ButtonSpinnerLocation
+    {
+      get
+      {
+        return ( Location )GetValue( ButtonSpinnerLocationProperty );
+      }
+      set
+      {
+        SetValue( ButtonSpinnerLocationProperty, value );
+      }
+    }
+
+    #endregion //ButtonSpinnerLocation
+
     #region Content
 
     /// <summary>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml
index a16663a6..2497238d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml
@@ -46,12 +46,12 @@
                     <Border x:Name="Border" SnapsToDevicePixels="True" Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" >
                         <Grid>
                             <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="*" />
-                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition x:Name="firstContentColumn" Width="*" />
+                                <ColumnDefinition x:Name="secondContentColumn" Width="Auto" />
                             </Grid.ColumnDefinitions>
-                            <ContentPresenter Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
+                            <ContentPresenter x:Name="contentPresenter" Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                            <Grid Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
+                            <Grid x:Name="gridContent" Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
                                 <Grid.RowDefinitions>
                                     <RowDefinition Height="*" />
                                     <RowDefinition Height="*" />
@@ -85,7 +85,22 @@
                         <Trigger SourceName="PART_DecreaseButton" Property="IsEnabled" Value="False">
                             <Setter TargetName="PART_DecreaseButton" Property="ContentTemplate" Value="{StaticResource DecreaseGlyphDisabledKey}" />
                         </Trigger>
-                    </ControlTemplate.Triggers>
+                        <Trigger Property="ButtonSpinnerLocation"
+                                 Value="Left">
+                           <Setter TargetName="firstContentColumn"
+                                   Property="Width"
+                                   Value="Auto" />
+                           <Setter TargetName="secondContentColumn"
+                                   Property="Width"
+                                   Value="*" />
+                           <Setter TargetName="contentPresenter"
+                                   Property="Grid.Column"
+                                   Value="1" />
+                           <Setter TargetName="gridContent"
+                                   Property="Grid.Column"
+                                   Value="0" />
+                        </Trigger>
+                     </ControlTemplate.Triggers>
                 </ControlTemplate>
             </Setter.Value>
         </Setter>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml
index 91d1fb13..72c4f0c5 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml
@@ -44,12 +44,12 @@
                <Border x:Name="Border" SnapsToDevicePixels="True" Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" >
                   <Grid>
                      <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="*" />
-                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition x:Name="firstContentColumn" Width="*" />
+                        <ColumnDefinition x:Name="secondContentColumn" Width="Auto" />
                      </Grid.ColumnDefinitions>
-                     <ContentPresenter Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
+                     <ContentPresenter x:Name="contentPresenter" Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                     <Grid Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
+                     <Grid x:Name="gridContent" Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
                         <Grid.RowDefinitions>
                            <RowDefinition Height="*" />
                            <RowDefinition Height="*" />
@@ -77,6 +77,21 @@
                   <Trigger SourceName="PART_DecreaseButton" Property="IsEnabled" Value="False">
                      <Setter TargetName="PART_DecreaseButton" Property="ContentTemplate" Value="{StaticResource DecreaseGlyphDisabledKey}" />
                   </Trigger>
+                  <Trigger Property="ButtonSpinnerLocation"
+                           Value="Left">
+                     <Setter TargetName="firstContentColumn"
+                             Property="Width"
+                             Value="Auto" />
+                     <Setter TargetName="secondContentColumn"
+                             Property="Width"
+                             Value="*" />
+                     <Setter TargetName="contentPresenter"
+                             Property="Grid.Column"
+                             Value="1" />
+                     <Setter TargetName="gridContent"
+                             Property="Grid.Column"
+                             Value="0" />
+                  </Trigger>
                </ControlTemplate.Triggers>
             </ControlTemplate>
          </Setter.Value>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs
index 20907e41..eb0a4876 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs
@@ -23,17 +23,21 @@ using System.Reflection;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
+using Xceed.Wpf.Toolkit.PropertyGrid;
 
 namespace Xceed.Wpf.Toolkit
 {
   [TemplatePart( Name = PART_NewItemTypesComboBox, Type = typeof( ComboBox ) )]
+  [TemplatePart( Name = PART_PropertyGrid, Type = typeof( PropertyGrid.PropertyGrid ) )]
   public class CollectionControl : Control
   {
     private const string PART_NewItemTypesComboBox = "PART_NewItemTypesComboBox";
+    private const string PART_PropertyGrid = "PART_PropertyGrid";
 
     #region Private Members
 
     private ComboBox _newItemTypesComboBox;
+    private PropertyGrid.PropertyGrid _propertyGrid;
 
     #endregion
 
@@ -177,6 +181,20 @@ namespace Xceed.Wpf.Toolkit
 
       if( _newItemTypesComboBox != null )
         _newItemTypesComboBox.Loaded += new RoutedEventHandler( this.NewItemTypesComboBox_Loaded );
+
+      _propertyGrid = GetTemplateChild( PART_PropertyGrid ) as PropertyGrid.PropertyGrid;
+    }
+
+    public PropertyGrid.PropertyGrid PropertyGrid
+    {
+      get
+      {
+        if( _propertyGrid == null )
+        {
+          this.ApplyTemplate();
+        }
+        return _propertyGrid;
+      }
     }
 
     #endregion
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml
index 76e3a691..6dfcf1ca 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml
@@ -29,7 +29,7 @@
          <RowDefinition Height="Auto" />
       </Grid.RowDefinitions>
 
-      <local:CollectionControl x:Name="_propertyGrid"
+      <local:CollectionControl x:Name="_collectionControl"
                               ItemsSourceType="{Binding ItemsSourceType, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"
                               ItemsSource="{Binding ItemsSource, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}, Mode=TwoWay}"
                               NewItemTypes="{Binding NewItemTypes, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs
index ef3f803a..ddea5371 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs
@@ -80,6 +80,14 @@ namespace Xceed.Wpf.Toolkit
       }
     }
 
+    public CollectionControl CollectionControl
+    {
+      get
+      {
+        return _collectionControl;
+      }
+    }
+
     #endregion //Properties
 
     #region Constructors
@@ -107,7 +115,7 @@ namespace Xceed.Wpf.Toolkit
 
     private void OkButton_Click( object sender, RoutedEventArgs e )
     {
-      _propertyGrid.PersistChanges();
+      _collectionControl.PersistChanges();
       this.DialogResult = true;
       Close();
     }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml
index 85272fb1..5bf7d60b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml
@@ -124,13 +124,14 @@
                                     <RowDefinition />
                                 </Grid.RowDefinitions>
                                 <TextBlock Grid.Column="1" Text="Properties:" />
-                                <pg:PropertyGrid Grid.Row="1"
-                                         Grid.Column="1"
-                                         Margin="0,5,0,0"
-                                         HorizontalAlignment="Stretch"
-                                         VerticalAlignment="Stretch"
-                                         SelectedObject="{Binding SelectedItem, RelativeSource={RelativeSource TemplatedParent}}"
-                                         IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}" />
+                                <pg:PropertyGrid x:Name="PART_PropertyGrid"
+                                                 Grid.Row="1"
+                                                 Grid.Column="1"
+                                                 Margin="0,5,0,0"
+                                                 HorizontalAlignment="Stretch"
+                                                 VerticalAlignment="Stretch"
+                                                 SelectedObject="{Binding SelectedItem, RelativeSource={RelativeSource TemplatedParent}}"
+                                                 IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}" />
                             </Grid>
                         </Grid>
                     </Border>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml
index e64b51c4..46756d4e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml
@@ -123,7 +123,8 @@
                            <RowDefinition />
                         </Grid.RowDefinitions>
                         <TextBlock Grid.Column="1" Text="Properties:" />
-                        <pg:PropertyGrid Grid.Row="1"
+                        <pg:PropertyGrid x:Name="PART_PropertyGrid"
+                                         Grid.Row="1"
                                          Grid.Column="1"
                                          Margin="0,5,0,0"
                                          HorizontalAlignment="Stretch"
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs
index 0417d9b7..a2bc0f33 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs
@@ -385,6 +385,8 @@ namespace Xceed.Wpf.Toolkit
       Point p = e.GetPosition( _colorShadingCanvas );
       UpdateColorShadeSelectorPositionAndCalculateColor( p, true );
       _colorShadingCanvas.CaptureMouse();
+      //Prevent from closing ColorCanvas after mouseDown in ListView
+      e.Handled = true; 
     }
 
     void ColorShadingCanvas_MouseLeftButtonUp( object sender, MouseButtonEventArgs e )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml
index e51ac830..35a5aafc 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml
@@ -117,6 +117,7 @@
     </Style>
 
      <Style x:Key="ColorDisplayStyle" TargetType="ContentControl">
+      <Setter Property="Focusable" Value="False" />
       <Setter Property="ContentTemplate">
          <Setter.Value>
             <DataTemplate>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml
index e4ef913c..93a2d404 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml
@@ -142,6 +142,8 @@
    </Style>
 
    <Style x:Key="ColorDisplayStyle" TargetType="ContentControl">
+      <Setter Property="Focusable"
+              Value="False" />
       <Setter Property="ContentTemplate">
          <Setter.Value>
             <DataTemplate>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs
index d8d3e00d..44be449d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs
@@ -26,6 +26,34 @@ namespace Xceed.Wpf.Toolkit.Primitives
   {
     #region Properties
 
+    #region AllowTextInput
+
+    public static readonly DependencyProperty AllowTextInputProperty = DependencyProperty.Register( "AllowTextInput", typeof( bool ), typeof( InputBase ), new UIPropertyMetadata( true, OnAllowTextInputChanged ) );
+    public bool AllowTextInput
+    {
+      get
+      {
+        return ( bool )GetValue( AllowTextInputProperty );
+      }
+      set
+      {
+        SetValue( AllowTextInputProperty, value );
+      }
+    }
+
+    private static void OnAllowTextInputChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    {
+      InputBase inputBase = o as InputBase;
+      if( inputBase != null )
+        inputBase.OnAllowTextInputChanged( ( bool )e.OldValue, ( bool )e.NewValue );
+    }
+
+    protected virtual void OnAllowTextInputChanged( bool oldValue, bool newValue )
+    {
+    }
+
+    #endregion //AllowTextInput
+
     #region CultureInfo
 
     public static readonly DependencyProperty CultureInfoProperty = DependencyProperty.Register( "CultureInfo", typeof( CultureInfo ), typeof( InputBase ), new UIPropertyMetadata( CultureInfo.CurrentCulture, OnCultureInfoChanged ) );
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs
index d4ef3b0a..11f25f99 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs
@@ -420,16 +420,27 @@ namespace Xceed.Wpf.Toolkit.Primitives
 
     #region Methods
 
-    protected object GetItemValue( object item )
+    protected object GetPathValue( object item, string propertyPath )
     {
-      if( !String.IsNullOrEmpty( ValueMemberPath ) && ( item != null ) )
-      {
-        var property = item.GetType().GetProperty( ValueMemberPath );
-        if( property != null )
-          return property.GetValue( item, null );
-      }
+      if( item == null )
+        throw new ArgumentNullException( "item" );
 
-      return item;
+      if( String.IsNullOrEmpty( propertyPath )
+        || propertyPath == "." )
+        return item;
+
+
+      PropertyInfo prop = item.GetType().GetProperty( propertyPath );
+      return ( prop != null )
+        ? prop.GetValue( item, null )
+        : null;
+    }
+
+    protected object GetItemValue( object item )
+    {
+      return ( item != null )
+        ? this.GetPathValue( item, this.ValueMemberPath )
+        : null;
     }
 
     protected object ResolveItemByValue( string value )
@@ -490,7 +501,7 @@ namespace Xceed.Wpf.Toolkit.Primitives
     /// </summary>
     /// <param name="sender"></param>
     /// <param name="e"></param>
-    private void OnSelectedItemsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+    protected virtual void OnSelectedItemsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       if( _ignoreSelectedItemsCollectionChanged > 0 )
         return;
@@ -646,6 +657,26 @@ namespace Xceed.Wpf.Toolkit.Primitives
       this.UpdateFromSelectedItems();
     }
 
+    internal void UpdateSelectedItems( IList selectedItems )
+    {
+      if( selectedItems == null )
+        throw new ArgumentNullException( "selectedItems" );
+
+      // Just check if the collection is the same..
+      if( selectedItems.Count == this.SelectedItems.Count
+        && selectedItems.Cast<object>().SequenceEqual( this.SelectedItems.Cast<object>() ) )
+        return;
+
+      _ignoreSelectedItemsCollectionChanged++;
+      this.SelectedItems.Clear();
+      foreach( object newItem in selectedItems )
+      {
+        this.SelectedItems.Add( newItem );
+      }
+      _ignoreSelectedItemsCollectionChanged--;
+      this.UpdateFromSelectedItems();
+    }
+
     /// <summary>
     /// Updates the following based on the content of SelectedItems:
     /// - All SelectorItems "IsSelected" properties
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs
index a3a57c09..6a40ca41 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs
@@ -49,6 +49,8 @@ namespace Xceed.Wpf.Toolkit.Primitives
     private bool _isSyncingTextAndValueProperties;    
     private bool _isSpinnerCaptured;
 
+    private bool _internalValueSet;
+
     #endregion //Members
 
     #region Properties
@@ -81,6 +83,23 @@ namespace Xceed.Wpf.Toolkit.Primitives
 
     #endregion //AllowSpin
 
+    #region ButtonSpinnerLocation
+
+    public static readonly DependencyProperty ButtonSpinnerLocationProperty = DependencyProperty.Register( "ButtonSpinnerLocation", typeof( Location ), typeof( UpDownBase<T> ), new UIPropertyMetadata( Location.Right ) );
+    public Location ButtonSpinnerLocation
+    {
+      get
+      {
+        return ( Location )GetValue( ButtonSpinnerLocationProperty );
+      }
+      set
+      {
+        SetValue( ButtonSpinnerLocationProperty, value );
+      }
+    }
+
+    #endregion //ButtonSpinnerLocation
+
     #region ClipValueToMinMax
 
     public static readonly DependencyProperty ClipValueToMinMaxProperty = DependencyProperty.Register( "ClipValueToMinMax", typeof( bool ), typeof( UpDownBase<T> ), new UIPropertyMetadata( false ) );
@@ -122,7 +141,7 @@ namespace Xceed.Wpf.Toolkit.Primitives
     {
       if( this.IsInitialized && string.IsNullOrEmpty( Text ))
       {
-        this.SyncTextAndValueProperties( true, Text );
+        this.SyncTextAndValueProperties( false, Text );
       }
     }
 
@@ -339,6 +358,19 @@ namespace Xceed.Wpf.Toolkit.Primitives
       }
     }
 
+    private void SetValueInternal( T value )
+    {
+      _internalValueSet = true;
+      try
+      {
+        this.Value = value;
+      }
+      finally
+      {
+        _internalValueSet = false;
+      }
+    }
+
     private static object OnCoerceValue( DependencyObject o, object basevalue )
     {
       return ( ( UpDownBase<T> )o ).OnCoerceValue( basevalue );
@@ -358,9 +390,9 @@ namespace Xceed.Wpf.Toolkit.Primitives
 
     protected virtual void OnValueChanged( T oldValue, T newValue )
     {
-      if( this.IsInitialized )
+      if( !_internalValueSet && this.IsInitialized )
       {
-        SyncTextAndValueProperties( false, null );
+        SyncTextAndValueProperties( false, null, true );
       }
 
       SetValidSpinDirection();
@@ -630,13 +662,17 @@ namespace Xceed.Wpf.Toolkit.Primitives
           if( string.IsNullOrEmpty( text ) )
           {
             // An empty input sets the value to the default value.
-            Value = this.DefaultValue;
+            this.SetValueInternal( this.DefaultValue );
           }
           else
           {
             try
             {
-              Value = this.ConvertTextToValue( text );
+              T newValue = this.ConvertTextToValue( text );
+              if( !object.Equals( newValue, this.Value ) )
+              {
+                this.SetValueInternal( newValue );
+              }
             }
             catch( Exception e )
             {
@@ -660,7 +696,11 @@ namespace Xceed.Wpf.Toolkit.Primitives
           bool shouldKeepEmpty = !forceTextUpdate && string.IsNullOrEmpty( Text ) && object.Equals( Value, DefaultValue ) && !this.DisplayDefaultValueOnEmptyText;
           if(  !shouldKeepEmpty )
           {
-            Text = ConvertValueToText();
+            string newText = ConvertValueToText();
+            if( !object.Equals( this.Text, newText ) )
+            {
+              Text = newText;
+            }
           }
 
           // Sync Text and textBox
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs
new file mode 100644
index 00000000..bf896adb
--- /dev/null
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs
@@ -0,0 +1,36 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Xceed.Wpf.Toolkit.Core.Utilities
+{
+  internal static class DateTimeUtilities
+  {
+    public static DateTime GetContextNow( DateTimeKind kind )
+    {
+      if( kind == DateTimeKind.Unspecified )
+        return DateTime.SpecifyKind( DateTime.Now, DateTimeKind.Unspecified );
+
+      return ( kind == DateTimeKind.Utc )
+        ? DateTime.UtcNow
+        : DateTime.Now;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs
index cc2a2a7a..e0f5fa4a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs
@@ -258,7 +258,7 @@ namespace Xceed.Wpf.Toolkit
       {
         _calendar.SelectedDatesChanged += Calendar_SelectedDatesChanged;
         _calendar.SelectedDate = Value ?? null;
-        _calendar.DisplayDate = Value ?? DateTime.Now;
+        _calendar.DisplayDate = Value ?? this.ContextNow;
         this.SetBlackOutDates();
       }
 
@@ -281,9 +281,15 @@ namespace Xceed.Wpf.Toolkit
 
     protected override void OnValueChanged( DateTime? oldValue, DateTime? newValue )
     {
-      if( (_calendar != null) && (_calendar.SelectedDate != newValue) )
+      //The calendar only select the Date part, not the time part.
+      DateTime? newValueDate = (newValue != null) 
+        ? newValue.Value.Date 
+        : (DateTime?)null;
+
+      if( _calendar != null && _calendar.SelectedDate != newValueDate)
       {
-        _calendar.SelectedDate = newValue;
+        _calendar.SelectedDate = newValueDate;
+        _calendar.DisplayDate = newValue.GetValueOrDefault( this.ContextNow );
       }
 
       base.OnValueChanged( oldValue, newValue );
@@ -357,8 +363,16 @@ namespace Xceed.Wpf.Toolkit
       {
         var newDate = ( DateTime? )e.AddedItems[ 0 ];
 
-        if( ( Value != null ) && ( newDate != null ) && newDate.HasValue )
+        //The Calendar will always return a date with an "Unspecified" Kind.
+        //Force the expected kind to the value.
+        if( newDate != null )
         {
+          newDate = DateTime.SpecifyKind( newDate.Value, this.Kind );
+        }
+
+        if( ( Value != null ) && ( newDate != null ) )
+        {
+
           // Only change the year, month, and day part of the value. Keep everything to the last "tick."
           // "Milliseconds" aren't precise enough. Use a mathematical scheme instead.
           newDate = newDate.Value.Date + Value.Value.TimeOfDay;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Aero2.NormalColor.xaml
index 313f66b5..d79ba46e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Aero2.NormalColor.xaml
@@ -109,7 +109,6 @@
                                                    FontWeight="{TemplateBinding FontWeight}" 
                                                    Foreground="{TemplateBinding Foreground}" 
                                                    HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                                   IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                                    MinWidth="20"
                                                    AcceptsReturn="False"
                                                    Padding="0"
@@ -138,6 +137,7 @@
                                                           Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" 
                                                           Format="{TemplateBinding TimeFormat}"
                                                           FormatString="{TemplateBinding TimeFormatString}"
+                                                          Kind="{Binding Kind, RelativeSource={RelativeSource TemplatedParent}}"
                                                           Value="{Binding Value, RelativeSource={RelativeSource TemplatedParent}}"
                                                           Minimum="{Binding Minimum, RelativeSource={RelativeSource TemplatedParent}}"
                                                           Maximum="{Binding Maximum, RelativeSource={RelativeSource TemplatedParent}}"
@@ -156,7 +156,24 @@
                         <Trigger Property="IsMouseOver" Value="True">
                             <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
                         </Trigger>
-                        <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                     <MultiDataTrigger>
+                        <MultiDataTrigger.Conditions>
+                           <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                           <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                        </MultiDataTrigger.Conditions>
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </MultiDataTrigger>
+                     <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                  Value="True">
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </DataTrigger>
+                     <Trigger Property="IsKeyboardFocusWithin" Value="True">
                             <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
                         </Trigger>
                         <Trigger Property="IsEnabled" Value="False">
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Generic.xaml
index 28c7aa69..c41d8407 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimePicker/Themes/Generic.xaml
@@ -117,7 +117,6 @@
                                                    FontWeight="{TemplateBinding FontWeight}" 
                                                    Foreground="{TemplateBinding Foreground}" 
                                                    HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                                   IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                                    MinWidth="20"
                                                    AcceptsReturn="False"
                                                    Padding="0"
@@ -146,6 +145,7 @@
                                                 Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" 
                                                 Format="{TemplateBinding TimeFormat}"
                                                 FormatString="{TemplateBinding TimeFormatString}"
+                                                Kind="{Binding Kind, RelativeSource={RelativeSource TemplatedParent}}"
                                                 Value="{Binding Value, RelativeSource={RelativeSource TemplatedParent}}"
                                                 Minimum="{Binding Minimum, RelativeSource={RelativeSource TemplatedParent}}"
                                                 Maximum="{Binding Maximum, RelativeSource={RelativeSource TemplatedParent}}"
@@ -160,6 +160,25 @@
                      </Popup>
                   </Grid>
                </Border>
+               <ControlTemplate.Triggers>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                        <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </MultiDataTrigger>
+                  <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                               Value="True">
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </DataTrigger>
+               </ControlTemplate.Triggers>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs
index 7efed265..b8fac171 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs
@@ -55,6 +55,15 @@ namespace Xceed.Wpf.Toolkit
       var dateTimeParts = dateTime.Split( dateTimeSeparators, StringSplitOptions.RemoveEmptyEntries ).ToList();
       var formats = format.Split( dateTimeSeparators, StringSplitOptions.RemoveEmptyEntries ).ToList();
 
+      //Auto-complete missing date parts
+      if( dateTimeParts.Count < formats.Count )
+      {
+        while( dateTimeParts.Count != formats.Count  )
+        {
+          dateTimeParts.Add( "0" );
+        }
+      }
+
       //something went wrong
       if( dateTimeParts.Count != formats.Count )
         return string.Empty;
@@ -65,12 +74,12 @@ namespace Xceed.Wpf.Toolkit
         if( !f.Contains( "ddd" ) && !f.Contains( "GMT" ) )
         {
           if( f.Contains( "M" ) )
-            dateParts[ "Month" ] = dateTimeParts[ i ];
+            dateParts[ "Month" ] = dateTimeParts[ i ] != "0" ? dateTimeParts[ i ] : "1";
           else if( f.Contains( "d" ) )
-            dateParts[ "Day" ] = dateTimeParts[ i ];
+            dateParts[ "Day" ] = dateTimeParts[ i ] != "0" ? dateTimeParts[ i ] : "1";
           else if( f.Contains( "y" ) )
           {
-            dateParts[ "Year" ] = dateTimeParts[ i ];
+            dateParts[ "Year" ] = dateTimeParts[ i ] != "0" ? dateTimeParts[ i ] : "0001";
 
             if( dateParts[ "Year" ].Length == 2 )
               dateParts[ "Year" ] = string.Format( "{0}{1}", currentDate.Year / 100, dateParts[ "Year" ] );
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs
index 8662fb0e..a28cba5a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs
@@ -24,6 +24,7 @@ using Xceed.Wpf.Toolkit.Primitives;
 using System.Windows.Controls;
 using System.Linq;
 using Xceed.Wpf.Toolkit.Core.Primitives;
+using Xceed.Wpf.Toolkit.Core.Utilities;
 
 namespace Xceed.Wpf.Toolkit
 {
@@ -31,7 +32,8 @@ namespace Xceed.Wpf.Toolkit
   {
     #region Members
 
-    private DateTime? _lastValidDate;
+    private DateTime? _lastValidDate; //null
+    private bool _setKindInternal = false;
 
     #endregion
 
@@ -110,6 +112,75 @@ namespace Xceed.Wpf.Toolkit
 
     #endregion //FormatString
 
+    #region Kind
+
+    public static readonly DependencyProperty KindProperty = DependencyProperty.Register( "Kind", typeof( DateTimeKind ), typeof( DateTimeUpDown ), 
+      new FrameworkPropertyMetadata( DateTimeKind.Unspecified, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnKindChanged ) );
+    public DateTimeKind Kind
+    {
+      get
+      {
+        return ( DateTimeKind )GetValue( KindProperty );
+      }
+      set
+      {
+        SetValue( KindProperty, value );
+      }
+    }
+
+    private static void OnKindChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    {
+      DateTimeUpDown dateTimeUpDown = o as DateTimeUpDown;
+      if( dateTimeUpDown != null )
+        dateTimeUpDown.OnKindChanged( ( DateTimeKind )e.OldValue, ( DateTimeKind )e.NewValue );
+    }
+
+    protected virtual void OnKindChanged( DateTimeKind oldValue, DateTimeKind newValue )
+    {
+      //Upate the value based on kind. (Postpone to EndInit if not yet initialized)
+      if( !_setKindInternal
+        && this.Value != null 
+        && this.IsInitialized )
+      {
+        this.Value = this.ConvertToKind( this.Value.Value, newValue );
+      }
+    }
+
+    private void SetKindInternal( DateTimeKind kind )
+    {
+      _setKindInternal = true;
+      try
+      {
+#if VS2008
+        // Warning : Binding could be lost
+        this.Kind = kind;
+#else
+        //We use SetCurrentValue to not erase the possible underlying 
+        //OneWay Binding. (This will also update correctly any
+        //possible TwoWay bindings).
+        this.SetCurrentValue( DateTimeUpDown.KindProperty, kind );
+#endif
+      }
+      finally
+      {
+        _setKindInternal = false;
+      }
+    }
+
+    #endregion //Kind
+
+    #region ContextNow (Private)
+
+    internal DateTime ContextNow
+    {
+      get
+      {
+        return DateTimeUtilities.GetContextNow( this.Kind );
+      }
+    }
+
+    #endregion
+
     #endregion //Properties
 
     #region Constructors
@@ -148,7 +219,7 @@ namespace Xceed.Wpf.Toolkit
         if( Value.HasValue )
           UpdateDateTime( 1 );
         else
-          Value = DefaultValue ?? DateTime.Now;
+          Value = DefaultValue ?? this.ContextNow;
       }
     }
 
@@ -159,7 +230,7 @@ namespace Xceed.Wpf.Toolkit
         if( Value.HasValue )
           UpdateDateTime( -1 );
         else
-          Value = DefaultValue ?? DateTime.Now;
+          Value = DefaultValue ?? this.ContextNow;
       }
     }
 
@@ -179,6 +250,21 @@ namespace Xceed.Wpf.Toolkit
       DateTime result;
       this.TryParseDateTime( text, out result );
 
+      //Do not force "unspecified" to a time-zone specific
+      //parsed text value. This would result in a lost of precision and
+      //corrupt data. Let the value impose the Kind to the
+      //DateTimePicker. 
+      if( this.Kind != DateTimeKind.Unspecified )
+      {
+
+        //Keep the current kind (Local or Utc) 
+        //by imposing it to the parsed text value.
+        //
+        //Note: A parsed UTC text value may be
+        //      adjusted with a Local kind and time.
+        result = this.ConvertToKind( result, this.Kind );
+      }
+
       if( this.ClipValueToMinMax )
       {
         return this.GetClippedMinMaxValue( result );
@@ -214,10 +300,28 @@ namespace Xceed.Wpf.Toolkit
         this.Spinner.ValidSpinDirection = validDirections;
     }
 
+    protected override object OnCoerceValue( object newValue )
+    {
+      //Since only changing the "kind" of a date
+      //Ex. "2001-01-01 12:00 AM, Kind=Utc" to "2001-01-01 12:00 AM Kind=Local"
+      //by setting the "Value" property won't trigger a property changed,
+      //but will call this callback (coerce), we update the Kind here.
+      DateTime? value = ( DateTime? )base.OnCoerceValue( newValue );
+
+      //Let the initialized determine the final "kind" value.
+      if(value != null && this.IsInitialized)
+      {
+        //Update kind based on value kind
+        this.SetKindInternal( value.Value.Kind );
+      }
+
+      return value;
+    }
+
     protected override void OnValueChanged( DateTime? oldValue, DateTime? newValue )
     {
-      //whenever the value changes we need to parse out the value into out DateTimeInfo segments so we can keep track of the individual pieces
-      //but only if it is not null
+        //whenever the value changes we need to parse out the value into out DateTimeInfo segments so we can keep track of the individual pieces
+        //but only if it is not null
       if( newValue != null )
         ParseValueIntoDateTimeInfo();
 
@@ -248,6 +352,29 @@ namespace Xceed.Wpf.Toolkit
       return this.TryParseDateTime( this.TextBox.Text, out result );
     }
 
+    protected override void OnInitialized( EventArgs e )
+    {
+      base.OnInitialized( e );
+      if( this.Value != null )
+      {
+        DateTimeKind valueKind = this.Value.Value.Kind;
+
+        if( valueKind != this.Kind )
+        {
+          //Conflit between "Kind" property and the "Value.Kind" value.
+          //Priority to the one that is not "Unspecified".
+          if( this.Kind == DateTimeKind.Unspecified )
+          {
+            this.SetKindInternal( valueKind );
+          }
+          else
+          {
+            this.Value = this.ConvertToKind( this.Value.Value, this.Kind );
+          }
+        }
+      }
+    }
+
     #endregion //Base Class Overrides
 
     #region Methods
@@ -709,9 +836,8 @@ namespace Xceed.Wpf.Toolkit
     private bool TryParseDateTime( string text, out DateTime result )
     {
       bool isValid = false;
-      result = DateTime.Now;
 
-      DateTime current = this.Value.HasValue ? this.Value.Value : DateTime.Parse( DateTime.Now.ToString(), this.CultureInfo.DateTimeFormat );
+      DateTime current = this.Value.HasValue ? this.Value.Value : DateTime.Parse( this.ContextNow.ToString(), this.CultureInfo.DateTimeFormat );
       isValid = DateTimeParser.TryParse( text, this.GetFormatString( Format ), current, this.CultureInfo, out result );
 
       if( !isValid )
@@ -720,11 +846,31 @@ namespace Xceed.Wpf.Toolkit
       }
 
       if( !isValid )
+      {
         result = ( _lastValidDate != null ) ? _lastValidDate.Value : current;
+      }
 
       return isValid;
     }
 
+    private DateTime ConvertToKind( DateTime dateTime, DateTimeKind kind )
+    {
+      //Same kind, just return same value.
+      if( kind == dateTime.Kind )
+        return dateTime;
+
+      //"ToLocalTime()" from an unspecified will assume
+      // That the time was originaly Utc and affect the datetime value. 
+      // Just "Force" the "Kind" instead.
+      if( dateTime.Kind == DateTimeKind.Unspecified 
+        || kind == DateTimeKind.Unspecified )
+        return DateTime.SpecifyKind( dateTime, kind );
+
+      return ( kind == DateTimeKind.Local )
+         ? dateTime.ToLocalTime()
+         : dateTime.ToUniversalTime();
+    }
+
     #endregion //Methods
   }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml
index c3610996..33327a15 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml
@@ -58,7 +58,6 @@
                                           FontWeight="{TemplateBinding FontWeight}" 
                                           Foreground="{TemplateBinding Foreground}" 
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
                                           Padding="{TemplateBinding Padding}"
@@ -73,7 +72,24 @@
                         <Trigger Property="IsMouseOver" Value="True">
                             <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
                         </Trigger>
-                        <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                     <MultiDataTrigger>
+                        <MultiDataTrigger.Conditions>
+                           <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                           <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                        </MultiDataTrigger.Conditions>
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </MultiDataTrigger>
+                     <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                  Value="True">
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </DataTrigger>
+                     <Trigger Property="IsKeyboardFocusWithin" Value="True">
                             <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
                         </Trigger>
                         <Trigger Property="IsEnabled" Value="False">
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml
index cc84bf73..906c1e7d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml
@@ -57,7 +57,6 @@
                                           FontWeight="{TemplateBinding FontWeight}" 
                                           Foreground="{TemplateBinding Foreground}" 
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
                                           Padding="{TemplateBinding Padding}"
@@ -72,6 +71,23 @@
                    <Trigger Property="IsFocused" Value="True">
                        <Setter TargetName="PART_TextBox" Property="FocusManager.FocusedElement" Value="{Binding ElementName=PART_TextBox}" />
                    </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                        <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </MultiDataTrigger>
+                  <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                               Value="True">
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </DataTrigger>
                </ControlTemplate.Triggers>
             </ControlTemplate>
          </Setter.Value>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs
index 75ef5d45..c7205d91 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs
@@ -767,27 +767,6 @@ namespace Xceed.Wpf.Toolkit
       return msgBox.MessageBoxResult;
     }
 
-    /// <summary>
-    /// Resolves the owner Window of the MessageBox.
-    /// </summary>
-    /// <returns>the owner Window</returns>
-    private static Window ComputeOwnerWindow()
-    {
-      Window owner = null;
-      if( Application.Current != null )
-      {
-        foreach( Window w in Application.Current.Windows )
-        {
-          if( w.IsActive )
-          {
-            owner = w;
-            break;
-          }
-        }
-      }
-      return owner;
-    }
-
     /// <summary>
     /// Sets the message image source.
     /// </summary>
@@ -839,7 +818,6 @@ namespace Xceed.Wpf.Toolkit
       newWindow.AllowsTransparency = true;
       newWindow.Background = Brushes.Transparent;
       newWindow.Content = this;
-      newWindow.Owner = _owner ?? ComputeOwnerWindow();
 
       if( newWindow.Owner != null )
         newWindow.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterOwner;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs
index 2b0ec3da..f1149772 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs
@@ -19,18 +19,22 @@ using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using System.Windows.Input;
+using System.Windows.Threading;
 using Xceed.Wpf.Toolkit.Core.Utilities;
 
 namespace Xceed.Wpf.Toolkit
 {
   [TemplatePart( Name = PART_ResizeThumb, Type = typeof( Thumb ) )]
+  [TemplatePart( Name = PART_TextBox, Type = typeof( TextBox ) )]
   public class MultiLineTextEditor : ContentControl
   {
     private const string PART_ResizeThumb = "PART_ResizeThumb";
+    private const string PART_TextBox = "PART_TextBox";
 
     #region Members
 
-    Thumb _resizeThumb;
+    private Thumb _resizeThumb;
+    private TextBox _textBox;
 
     #endregion //Members
 
@@ -90,7 +94,8 @@ namespace Xceed.Wpf.Toolkit
 
     protected virtual void OnIsOpenChanged( bool oldValue, bool newValue )
     {
-
+      // Focus the content of the popup, after its loaded
+      Dispatcher.BeginInvoke(new Action(()=>_textBox.Focus()), DispatcherPriority.Background);
     }
 
     #endregion //IsOpen
@@ -214,6 +219,8 @@ namespace Xceed.Wpf.Toolkit
 
       if( _resizeThumb != null )
         _resizeThumb.DragDelta += ResizeThumb_DragDelta;
+
+      _textBox = GetTemplateChild( PART_TextBox ) as TextBox;
     }
 
     #endregion //Bass Class Overrides
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml
index ff34c8e7..e605aed4 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml
@@ -21,85 +21,113 @@
                     xmlns:themes="clr-namespace:Xceed.Wpf.Toolkit.Themes"
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-    <ResourceDictionary.MergedDictionaries>
-        <ResourceDictionary Source="../../Themes/Aero2/Common.xaml" />
-    </ResourceDictionary.MergedDictionaries>
-
-    <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
-
-    <Image x:Key="DefaultContent" x:Shared="False" Height="16" Width="18" Source="./../Images/Notes16.png" />
-
-    <Style x:Key="ToggleButtonStyle" TargetType="ToggleButton">
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="ToggleButton">
-                    <Grid SnapsToDevicePixels="True">
-
-                        <Grid>
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="*" />
-                                <ColumnDefinition Width="Auto" />
-                            </Grid.ColumnDefinitions>
-
-                            <Border Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Padding="{TemplateBinding Padding}" SnapsToDevicePixels="True">
-                                <ContentPresenter Content="{TemplateBinding Content}"
+   <ResourceDictionary.MergedDictionaries>
+      <ResourceDictionary Source="../../Themes/Aero2/Common.xaml" />
+   </ResourceDictionary.MergedDictionaries>
+
+   <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
+
+   <Image x:Key="DefaultContent"
+          x:Shared="False"
+          Height="16"
+          Width="18"
+          Source="./../Images/Notes16.png" />
+
+   <Style x:Key="ToggleButtonStyle"
+          TargetType="ToggleButton">
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="ToggleButton">
+               <Grid SnapsToDevicePixels="True">
+
+                  <Grid>
+                     <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                     </Grid.ColumnDefinitions>
+
+                     <Border Background="{TemplateBinding Background}"
+                             BorderBrush="{TemplateBinding BorderBrush}"
+                             BorderThickness="{TemplateBinding BorderThickness}"
+                             Padding="{TemplateBinding Padding}"
+                             SnapsToDevicePixels="True">
+                        <ContentPresenter Content="{TemplateBinding Content}"
                                           ContentTemplate="{TemplateBinding ContentTemplate}"
                                           ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
                                           VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                                           HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" />
-                            </Border>
+                     </Border>
 
-                            <chrome:ButtonChrome x:Name="ToggleButtonChrome"
+                     <chrome:ButtonChrome x:Name="ToggleButtonChrome"
                                           Grid.Column="1"
                                           CornerRadius="0"
                                           RenderChecked="{Binding IsOpen, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=local:MultiLineTextEditor}}"
                                           RenderEnabled="{Binding IsEnabled, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=local:MultiLineTextEditor}}"
-											         RenderMouseOver="{TemplateBinding IsMouseOver}"
-											         RenderPressed="{TemplateBinding IsPressed}">
-                                <Grid x:Name="arrowGlyph" IsHitTestVisible="False" Grid.Column="1" Margin="5">
-                                    <Path x:Name="Arrow"  Width="7" Height="4" Data="M 0,1 C0,1 0,0 0,0 0,0 3,0 3,0 3,0 3,1 3,1 3,1 4,1 4,1 4,1 4,0 4,0 4,0 7,0 7,0 7,0 7,1 7,1 7,1 6,1 6,1 6,1 6,2 6,2 6,2 5,2 5,2 5,2 5,3 5,3 5,3 4,3 4,3 4,3 4,4 4,4 4,4 3,4 3,4 3,4 3,3 3,3 3,3 2,3 2,3 2,3 2,2 2,2 2,2 1,2 1,2 1,2 1,1 1,1 1,1 0,1 0,1 z" Fill="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
-                                </Grid>
-                            </chrome:ButtonChrome>
+                                          RenderMouseOver="{TemplateBinding IsMouseOver}"
+                                          RenderPressed="{TemplateBinding IsPressed}">
+                        <Grid x:Name="arrowGlyph"
+                              IsHitTestVisible="False"
+                              Grid.Column="1"
+                              Margin="5">
+                           <Path x:Name="Arrow"
+                                 Width="7"
+                                 Height="4"
+                                 Data="M 0,1 C0,1 0,0 0,0 0,0 3,0 3,0 3,0 3,1 3,1 3,1 4,1 4,1 4,1 4,0 4,0 4,0 7,0 7,0 7,0 7,1 7,1 7,1 6,1 6,1 6,1 6,2 6,2 6,2 5,2 5,2 5,2 5,3 5,3 5,3 4,3 4,3 4,3 4,4 4,4 4,4 3,4 3,4 3,4 3,3 3,3 3,3 2,3 2,3 2,3 2,2 2,2 2,2 1,2 1,2 1,2 1,1 1,1 1,1 0,1 0,1 z"
+                                 Fill="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
                         </Grid>
-
-                    </Grid>
-                    <ControlTemplate.Triggers>
-                        <Trigger Property="IsEnabled" Value="False">
-                            <Setter Property="Fill" TargetName="Arrow" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
-                            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
-                        </Trigger>
-                    </ControlTemplate.Triggers>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-    </Style>
-
-
-    <!-- =============================================================================== -->
-    <!-- MultiLineTextEditor                                                             -->
-    <!-- =============================================================================== -->
-
-    <Style TargetType="{x:Type local:MultiLineTextEditor}">
-        <Setter Property="Background" Value="White"/>
-        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
-        <Setter Property="BorderThickness" Value="1,1,0,1" />
-        <Setter Property="Content" Value="{StaticResource DefaultContent}" />
-        <Setter Property="Focusable" Value="False" />
-        <Setter Property="Padding" Value="2,0,0,0" />
-        <Setter Property="HorizontalContentAlignment" Value="Center" />
-        <Setter Property="VerticalContentAlignment" Value="Center" />
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="{x:Type local:MultiLineTextEditor}">
-                    <Grid x:Name="Root">
-                        <ToggleButton x:Name="PART_DropDownButton"
+                     </chrome:ButtonChrome>
+                  </Grid>
+
+               </Grid>
+               <ControlTemplate.Triggers>
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+                     <Setter Property="Fill"
+                             TargetName="Arrow"
+                             Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
+                     <Setter Property="Foreground"
+                             Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
+                  </Trigger>
+               </ControlTemplate.Triggers>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+
+   <!-- =============================================================================== -->
+   <!-- MultiLineTextEditor                                                             -->
+   <!-- =============================================================================== -->
+
+   <Style TargetType="{x:Type local:MultiLineTextEditor}">
+      <Setter Property="Background"
+              Value="White" />
+      <Setter Property="BorderBrush"
+              Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
+      <Setter Property="BorderThickness"
+              Value="1,1,0,1" />
+      <Setter Property="Content"
+              Value="{StaticResource DefaultContent}" />
+      <Setter Property="Focusable"
+              Value="False" />
+      <Setter Property="Padding"
+              Value="2,0,0,0" />
+      <Setter Property="HorizontalContentAlignment"
+              Value="Center" />
+      <Setter Property="VerticalContentAlignment"
+              Value="Center" />
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type local:MultiLineTextEditor}">
+               <Grid x:Name="Root">
+                  <ToggleButton x:Name="PART_DropDownButton"
                                 Grid.Column="1"
                                 IsTabStop="True"
                                 MinHeight="22"
                                 SnapsToDevicePixels="True"
-                                Background="{TemplateBinding Background}" 
-                                BorderBrush="{TemplateBinding BorderBrush}" 
-                                BorderThickness="{TemplateBinding BorderThickness}" 
+                                Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
                                 Padding="{TemplateBinding Padding}"
                                 Content="{TemplateBinding Content}"
                                 ContentTemplate="{TemplateBinding ContentTemplate}"
@@ -109,7 +137,7 @@
                                 IsHitTestVisible="{Binding IsOpen, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource InverseBoolConverter}}"
                                 VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
                                 HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}" />
-                        <Popup IsOpen="{Binding IsChecked, ElementName=PART_DropDownButton}"
+                  <Popup IsOpen="{Binding IsChecked, ElementName=PART_DropDownButton}"
                          StaysOpen="False"
                          Placement="Bottom"
                          SnapsToDevicePixels="True"
@@ -118,9 +146,11 @@
                          PopupAnimation="Slide"
                          Width="{TemplateBinding DropDownWidth}"
                          Height="{TemplateBinding DropDownHeight}">
-                            <Border BorderThickness="1" Background="White" BorderBrush="{StaticResource PopupDarkBorderBrush}">
-                                <Grid>
-                                    <TextBox x:Name="PART_TextBox"
+                     <Border BorderThickness="1"
+                             Background="White"
+                             BorderBrush="{StaticResource PopupDarkBorderBrush}">
+                        <Grid>
+                           <TextBox x:Name="PART_TextBox"
                                     AcceptsReturn="true"
                                     TextWrapping="{TemplateBinding TextWrapping}"
                                     Padding="{TemplateBinding Padding}"
@@ -131,31 +161,40 @@
                                     Text="{Binding Text, RelativeSource={RelativeSource TemplatedParent}}"
                                     TextAlignment="{TemplateBinding TextAlignment}"
                                     Margin="3" />
-                                    <Thumb x:Name="PART_ResizeThumb" HorizontalAlignment="Right" VerticalAlignment="Bottom" Cursor="SizeNWSE">
-                                        <Thumb.Template>
-                                            <ControlTemplate TargetType="{x:Type Thumb}">
-                                                <Grid Background="Transparent">
-                                                    <Path Data="M0.5,6.5 L6.5,0.5 M6.5,3.5 L3.5,6.5" Stroke="Black" StrokeThickness="1" />
-                                                </Grid>
-                                            </ControlTemplate>
-                                        </Thumb.Template>
-                                    </Thumb>
-                                </Grid>
-                            </Border>
-                        </Popup>
-                    </Grid>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-
-        <Style.Triggers>
-            <Trigger Property="IsMouseOver" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
-            </Trigger>
-            <Trigger Property="IsKeyboardFocusWithin" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
-            </Trigger>
-        </Style.Triggers>
-    </Style>
+                           <Thumb x:Name="PART_ResizeThumb"
+                                  HorizontalAlignment="Right"
+                                  VerticalAlignment="Bottom"
+                                  Cursor="SizeNWSE">
+                              <Thumb.Template>
+                                 <ControlTemplate TargetType="{x:Type Thumb}">
+                                    <Grid Background="Transparent">
+                                       <Path Data="M0.5,6.5 L6.5,0.5 M6.5,3.5 L3.5,6.5"
+                                             Stroke="Black"
+                                             StrokeThickness="1" />
+                                    </Grid>
+                                 </ControlTemplate>
+                              </Thumb.Template>
+                           </Thumb>
+                        </Grid>
+                     </Border>
+                  </Popup>
+               </Grid>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+
+      <Style.Triggers>
+         <Trigger Property="IsMouseOver"
+                  Value="True">
+            <Setter Property="BorderBrush"
+                    Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
+         </Trigger>
+         <Trigger Property="IsKeyboardFocusWithin"
+                  Value="True">
+            <Setter Property="BorderBrush"
+                    Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
+         </Trigger>
+      </Style.Triggers>
+   </Style>
 
 </ResourceDictionary>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml
index 00f907b3..fdb564bb 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml
@@ -21,44 +21,58 @@
                     xmlns:prim="clr-namespace:Xceed.Wpf.Toolkit.Primitives"
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-    <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
-
-    <DataTemplate x:Key="DefaultWatermarkTemplate">
-        <ContentControl Content="{Binding}" Foreground="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" Focusable="False" Margin="0,0,3,0" />
-    </DataTemplate>
-
-    <Style x:Key="NumericUpDown" TargetType="{x:Type prim:InputBase}">
-        <Setter Property="Background" Value="{DynamicResource {x:Static SystemColors.WindowBrushKey}}" />
-        <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
-        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
-        <Setter Property="BorderThickness" Value="1" />
-        <Setter Property="HorizontalContentAlignment" Value="Right" />
-        <Setter Property="Focusable"  Value="False" />
-        <Setter Property="VerticalContentAlignment" Value="Center" />
-        <Setter Property="TextAlignment" Value="Right" />
-        <Setter Property="WatermarkTemplate" Value="{StaticResource DefaultWatermarkTemplate}" />
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="Control">
-                    <local:ButtonSpinner x:Name="PART_Spinner"
+   <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
+
+   <DataTemplate x:Key="DefaultWatermarkTemplate">
+      <ContentControl Content="{Binding}"
+                      Foreground="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"
+                      Focusable="False"
+                      Margin="0,0,3,0" />
+   </DataTemplate>
+
+   <Style x:Key="NumericUpDown"
+          TargetType="{x:Type prim:InputBase}">
+      <Setter Property="Background"
+              Value="{DynamicResource {x:Static SystemColors.WindowBrushKey}}" />
+      <Setter Property="Foreground"
+              Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+      <Setter Property="BorderBrush"
+              Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
+      <Setter Property="BorderThickness"
+              Value="1" />
+      <Setter Property="HorizontalContentAlignment"
+              Value="Right" />
+      <Setter Property="Focusable"
+              Value="False" />
+      <Setter Property="VerticalContentAlignment"
+              Value="Center" />
+      <Setter Property="TextAlignment"
+              Value="Right" />
+      <Setter Property="WatermarkTemplate"
+              Value="{StaticResource DefaultWatermarkTemplate}" />
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="Control">
+               <local:ButtonSpinner x:Name="PART_Spinner"
                                     IsTabStop="False"
                                     Background="{TemplateBinding Background}"
                                     BorderThickness="{TemplateBinding BorderThickness}"
                                     BorderBrush="{TemplateBinding BorderBrush}"
                                     AllowSpin="{Binding AllowSpin, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}">
-                        <local:WatermarkTextBox x:Name="PART_TextBox"
+                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ButtonSpinnerLocation="{Binding ButtonSpinnerLocation, RelativeSource={RelativeSource TemplatedParent}}">
+                  <local:WatermarkTextBox x:Name="PART_TextBox"
                                           BorderThickness="0"
                                           Background="{TemplateBinding Background}"
                                           ContextMenu="{TemplateBinding ContextMenu}"
-                                          FontFamily="{TemplateBinding FontFamily}" 
-                                          FontSize="{TemplateBinding FontSize}" 
+                                          FontFamily="{TemplateBinding FontFamily}"
+                                          FontSize="{TemplateBinding FontSize}"
                                           FontStretch="{TemplateBinding FontStretch}"
-                                          FontStyle="{TemplateBinding FontStyle}" 
-                                          FontWeight="{TemplateBinding FontWeight}" 
-                                          Foreground="{TemplateBinding Foreground}" 
+                                          FontStyle="{TemplateBinding FontStyle}"
+                                          FontWeight="{TemplateBinding FontWeight}"
+                                          Foreground="{TemplateBinding Foreground}"
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
+
                                           IsTabStop="{TemplateBinding IsTabStop}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
@@ -67,43 +81,69 @@
                                           AutoSelectBehavior="{Binding AutoSelectBehavior, RelativeSource={RelativeSource TemplatedParent}}"
                                           AutoMoveFocus="{Binding AutoMoveFocus, RelativeSource={RelativeSource TemplatedParent}}"
                                           TextAlignment="{Binding TextAlignment, RelativeSource={RelativeSource TemplatedParent}}"
-                                          TextWrapping="NoWrap" 
+                                          TextWrapping="NoWrap"
                                           TabIndex="{TemplateBinding TabIndex}"
                                           VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
                                           Watermark="{Binding Watermark, RelativeSource={RelativeSource TemplatedParent}}"
                                           WatermarkTemplate="{Binding WatermarkTemplate, RelativeSource={RelativeSource TemplatedParent}}" />
-                    </local:ButtonSpinner>
-
-                    <ControlTemplate.Triggers>
-                        <Trigger Property="IsMouseOver" Value="True">
-                            <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
-                        </Trigger>
-                        <Trigger Property="IsKeyboardFocusWithin" Value="True">
-                            <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
-                        </Trigger>
-                        <Trigger Property="IsEnabled" Value="False">
-                            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
-                        </Trigger>
-                        <Trigger Property="IsFocused" Value="True">
-                            <Setter TargetName="PART_TextBox" Property="FocusManager.FocusedElement" Value="{Binding ElementName=PART_TextBox}" />
-                        </Trigger>
-                    </ControlTemplate.Triggers>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-    </Style>
+               </local:ButtonSpinner>
+
+               <ControlTemplate.Triggers>
+                  <Trigger Property="IsMouseOver"
+                           Value="True">
+                     <Setter Property="BorderBrush"
+                             Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
+                  </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                        <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions> 
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox"/>
+                  </MultiDataTrigger>
+                  <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                               Value="True">
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </DataTrigger>
+                  <Trigger Property="IsKeyboardFocusWithin"
+                           Value="True">
+                     <Setter Property="BorderBrush"
+                             Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
+                  </Trigger>
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+                     <Setter Property="Foreground"
+                             Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
+                  </Trigger>
+                  <Trigger Property="IsFocused"
+                           Value="True">
+                     <Setter TargetName="PART_TextBox"
+                             Property="FocusManager.FocusedElement"
+                             Value="{Binding ElementName=PART_TextBox}" />
+                  </Trigger>
+               </ControlTemplate.Triggers>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
 
-    <!-- =============================================================================== -->
-    <!-- DecimalUpDown                                                                   -->
-    <!-- =============================================================================== -->
-    <Style TargetType="{x:Type local:DecimalUpDown}" BasedOn="{StaticResource NumericUpDown}" />
+   <!-- =============================================================================== -->
+   <!-- DecimalUpDown                                                                   -->
+   <!-- =============================================================================== -->
+   <Style TargetType="{x:Type local:DecimalUpDown}" BasedOn="{StaticResource NumericUpDown}" />
 
-    <!-- =============================================================================== -->
-    <!-- DoubleUpDown                                                                    -->
-    <!-- =============================================================================== -->
-    <Style TargetType="{x:Type local:DoubleUpDown}" BasedOn="{StaticResource NumericUpDown}" />
+   <!-- =============================================================================== -->
+   <!-- DoubleUpDown                                                                    -->
+   <!-- =============================================================================== -->
+   <Style TargetType="{x:Type local:DoubleUpDown}" BasedOn="{StaticResource NumericUpDown}" />
 
-    <!-- =============================================================================== -->
+   <!-- =============================================================================== -->
     <!-- IntegerUpDown                                                                   -->
     <!-- =============================================================================== -->
     <Style TargetType="{x:Type local:IntegerUpDown}" BasedOn="{StaticResource NumericUpDown}" />
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml
index a40aa0ae..944e45e2 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml
@@ -46,7 +46,8 @@
                                     BorderThickness="{TemplateBinding BorderThickness}"
                                     BorderBrush="{TemplateBinding BorderBrush}"
                                     AllowSpin="{Binding AllowSpin, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}">
+                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ButtonSpinnerLocation="{Binding ButtonSpinnerLocation, RelativeSource={RelativeSource TemplatedParent}}">
                         <local:WatermarkTextBox x:Name="PART_TextBox"
                                           BorderThickness="0"
                                           Background="{TemplateBinding Background}"
@@ -58,7 +59,6 @@
                                           FontWeight="{TemplateBinding FontWeight}" 
                                           Foreground="{TemplateBinding Foreground}" 
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                           IsTabStop="{TemplateBinding IsTabStop}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
@@ -74,6 +74,23 @@
                                           WatermarkTemplate="{Binding WatermarkTemplate, RelativeSource={RelativeSource TemplatedParent}}" />
                </local:ButtonSpinner>
                <ControlTemplate.Triggers>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                        <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </MultiDataTrigger>
+                  <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                               Value="True">
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </DataTrigger>
                   <Trigger Property="IsEnabled" Value="False">
                      <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
                   </Trigger>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Converters/IntegerToBoolConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs
similarity index 59%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Converters/IntegerToBoolConverter.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs
index 84140439..7ed0af19 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit.LiveExplorer/Samples/RangeSlider/Converters/IntegerToBoolConverter.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs
@@ -1,8 +1,8 @@
-/**************************************************************************************
+/*************************************************************************************
 
    Extended WPF Toolkit
 
-   Copyright (C) 2007-2014 Xceed Software Inc.
+   Copyright (C) 2007-2013 Xceed Software Inc.
 
    This program is provided to you under the terms of the Microsoft Public
    License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
@@ -12,28 +12,27 @@
 
    Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
 
-  ************************************************************************************/
+  ***********************************************************************************/
+
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Globalization;
 using System.Windows.Data;
 
-namespace Xceed.Wpf.Toolkit.LiveExplorer.Samples.RangeSlider.Converters
+namespace Xceed.Wpf.Toolkit.PropertyGrid.Converters
 {
-  public class IntegerToBoolConverter: IValueConverter
+  public class IsStringEmptyConverter : IValueConverter
   {
-    public object Convert( object value, Type targetType, object parameter, System.Globalization.CultureInfo culture )
+    public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
     {
-      if( value is int )
+      if( value is string )
       {
-        return (( int )value != 0);
+        return string.IsNullOrEmpty( ( string )value );
       }
 
-      return value;
+      return false;
     }
 
-    public object ConvertBack( object value, Type targetType, object parameter, System.Globalization.CultureInfo culture )
+    public object ConvertBack( object value, Type targetType, object parameter, CultureInfo culture )
     {
       throw new NotImplementedException();
     }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs
index 37a285aa..53533f90 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs
@@ -34,6 +34,11 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
   {
     internal CustomPropertyItem() { }
 
+    internal CustomPropertyItem( bool isPropertyGridCategorized )
+    {
+      _isPropertyGridCategorized = isPropertyGridCategorized;
+    }
+
     #region Category
 
     public static readonly DependencyProperty CategoryProperty =
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs
index 6d28674a..b1490e1e 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs
@@ -42,16 +42,28 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     {
       object currentValue = this.GetValue( definitionProperty );
       object localValue = this.ReadLocalValue( definitionProperty );
+      object elementValue = element.GetValue( elementProp );
+      bool areEquals = false;
+
       // Avoid setting values if it does not affect anything 
       // because setting a local value may prevent a style setter from being active.
-      if( ( localValue != DependencyProperty.UnsetValue )
-        || currentValue != element.GetValue( elementProp ) )
-      {
-        element.SetValue( elementProp, currentValue );
-      }
-      else
+      if( localValue != DependencyProperty.UnsetValue )
       {
-        element.ClearValue( elementProp );
+        if( ( elementValue != null ) && ( currentValue != null ) )
+        {
+          areEquals = ( elementValue.GetType().IsValueType && currentValue.GetType().IsValueType )
+                      ? elementValue.Equals( currentValue )  // Value Types
+                      : currentValue == element.GetValue( elementProp ); // Reference Types
+        }
+
+        if( !areEquals )
+        {
+          element.SetValue( elementProp, currentValue );
+        }
+        else
+        {
+          element.ClearValue( elementProp );
+        }
       }
     }
   }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs
index 98d2f66b..fc3a4a9f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs
@@ -79,6 +79,9 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     {
       return null;
     }
+
+
+
     protected virtual int ComputeDisplayOrder( bool isPropertyGridCategorized )
     {
       return int.MaxValue;
@@ -242,6 +245,10 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
               : null;
     }
 
+
+
+
+
     internal object ComputeDisplayOrderForItem( object item )
     {
       PropertyDescriptor pd = item as PropertyDescriptor;
@@ -407,6 +414,9 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       get { return _displayName; }
       internal set { _displayName = value; }
     }
+
+
+
     public string Description
     {
       get { return _description; }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs
index e044a6a6..358f35f8 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs
@@ -31,6 +31,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
 
 
+
     ContainerHelperBase ContainerHelper { get; }
 
     Style PropertyContainerStyle { get; }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs
index 0991ad88..b5c66e45 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs
@@ -47,7 +47,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     {
       _propertyItemCollection = new PropertyItemCollection( new ObservableCollection<PropertyItem>() );
       UpdateFilter();
-      UpdateCategorization();
+      UpdateCategorization( false );
 
     }
 
@@ -137,7 +137,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
     protected override void OnCategorizationChanged()
     {
-      UpdateCategorization();
+      UpdateCategorization( true );
     }
 
     protected override void OnAutoGeneratePropertiesChanged()
@@ -165,9 +165,20 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
         ?? PropertyItemCollection.CreateFilter( filterInfo.InputString );
     }
 
-    private void UpdateCategorization()
+    private void UpdateCategorization( bool updateSubPropertiesCategorization )
     {
       _propertyItemCollection.UpdateCategorization( this.ComputeCategoryGroupDescription(), this.PropertyContainer.IsCategorized );
+      if( updateSubPropertiesCategorization && (_propertyItemCollection.Count > 0) )
+      {
+        foreach( PropertyItem propertyItem in _propertyItemCollection )
+        {
+          PropertyItemCollection subPropertyItemsCollection = propertyItem.Properties as PropertyItemCollection;
+          if( subPropertyItemsCollection != null )
+          {
+            subPropertyItemsCollection.UpdateCategorization( this.ComputeCategoryGroupDescription(), this.PropertyContainer.IsCategorized );
+          }
+        }
+      }
     }
 
     private GroupDescription ComputeCategoryGroupDescription()
@@ -218,7 +229,6 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
         propertyItem.PropertyChanged -= OnChildrenPropertyChanged;
       }
 
-
       PropertyItems.UpdateItems( subProperties );
 
       //Add the event callback to the new childrens
@@ -309,6 +319,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       propertyItem.IsReadOnly = pd.IsReadOnly;
       propertyItem.DisplayName = pd.DisplayName;
       propertyItem.Description = pd.Description;
+
       propertyItem.Category = pd.Category;
       propertyItem.PropertyOrder = pd.DisplayOrder;
 
@@ -344,7 +355,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       propertyItem.SetBinding( itemProperty, binding );
     }
 
-    private FrameworkElement GenerateChildrenEditorElement( PropertyItem propertyItem )
+    internal FrameworkElement GenerateChildrenEditorElement( PropertyItem propertyItem )
     {
       FrameworkElement editorElement = null;
       DescriptorPropertyDefinitionBase pd = propertyItem.DescriptorDefinition;
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs
index 8d12011c..8a1059f0 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs
@@ -15,17 +15,26 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
+using System.Windows.Documents;
 
 namespace Xceed.Wpf.Toolkit.PropertyGrid
 {
-  public class PropertyDefinitionCollection : PropertyDefinitionBaseCollection<PropertyDefinition> { }
-  public class EditorDefinitionCollection : PropertyDefinitionBaseCollection<EditorDefinitionBase> { }
+  public class PropertyDefinitionCollection : PropertyDefinitionBaseCollection<PropertyDefinition>
+  {
+  }
+  public class EditorDefinitionCollection : PropertyDefinitionBaseCollection<EditorDefinitionBase>
+  {
+  }
 
 
   public abstract class PropertyDefinitionBaseCollection<T> : DefinitionCollectionBase<T> where T : PropertyDefinitionBase
   {
-    internal PropertyDefinitionBaseCollection() { }
+    internal PropertyDefinitionBaseCollection()
+    {
+    }
 
     public T this[ object propertyId ]
     {
@@ -35,6 +44,24 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
         {
           if( item.TargetProperties.Contains( propertyId ) )
             return item;
+
+          // Using the special character "*" in a string of TargetProperties will
+          // return all the items containing the string (before or after) the "*".
+          // ex : Prop* will return properties named Prop1, Prop2, Prop3...
+          List<string> stringTargetProperties = item.TargetProperties.OfType<string>().ToList();
+          if( (stringTargetProperties != null) && (stringTargetProperties.Count > 0) && ( propertyId is string ) )
+          {
+            string stringPropertyID = ( string )propertyId;
+            foreach( var targetPropertyString in stringTargetProperties )
+            {
+              if( targetPropertyString.Contains( "*" ) )
+              {
+                string searchString = targetPropertyString.Replace( "*", "" );
+                if( stringPropertyID.StartsWith( searchString ) || stringPropertyID.EndsWith( searchString ) )
+                  return item;
+              }
+            }
+          }
         }
 
         return null;
@@ -56,7 +83,9 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
   public abstract class DefinitionCollectionBase<T> : ObservableCollection<T> where T : DefinitionBase
   {
-    internal DefinitionCollectionBase() { }
+    internal DefinitionCollectionBase()
+    {
+    }
 
     protected override void InsertItem( int index, T item )
     {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs
index 5a9f1ff8..61086d0c 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs
@@ -94,6 +94,23 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
     #endregion //AutoGenerateProperties
 
+    #region ShowDescriptionByTooltip
+
+    public static readonly DependencyProperty ShowDescriptionByTooltipProperty = DependencyProperty.Register( "ShowDescriptionByTooltip", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( false ) );
+    public bool ShowDescriptionByTooltip
+    {
+      get
+      {
+        return ( bool )GetValue( ShowDescriptionByTooltipProperty );
+      }
+      set
+      {
+        SetValue( ShowDescriptionByTooltipProperty, value );
+      }
+    }
+
+    #endregion //ShowDescriptionByTooltip
+
     #region ShowSummary
 
     public static readonly DependencyProperty ShowSummaryProperty = DependencyProperty.Register( "ShowSummary", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( true ) );
@@ -721,7 +738,6 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       CommandBindings.Add( new CommandBinding( PropertyGridCommands.ClearFilter, ClearFilter, CanClearFilter ) );
     }
 
-
     #endregion //Constructors
 
     #region Base Class Overrides
@@ -818,6 +834,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       NameColumnWidth = Math.Max( 0, NameColumnWidth + e.HorizontalChange );
     }
 
+
     #endregion //Event Handlers
 
     #region Commands
@@ -917,6 +934,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
 
 
+
     #endregion //Methods
 
     #region Events
@@ -1129,6 +1147,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       }
     }
 
+
     #endregion
 
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs
index fb7f09e4..a89a75be 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs
@@ -196,7 +196,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     #region Constructors
 
     internal PropertyItem( DescriptorPropertyDefinitionBase definition )
-      : base()
+      : base( definition.IsPropertyGridCategorized )
     {
       if( definition == null )
         throw new ArgumentNullException( "definition" );
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs
index 3b52f4b8..049b5c9f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs
@@ -40,6 +40,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     private ContentControl _valueContainer;
     private ContainerHelperBase _containerHelper;
     private IPropertyContainer _parentNode;
+    internal bool _isPropertyGridCategorized;
 
     #region Properties
 
@@ -416,6 +417,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
 
 
+
     Style IPropertyContainer.PropertyContainerStyle
     {
       get { return this.PropertyContainerStyle; }
@@ -441,7 +443,10 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
     bool IPropertyContainer.IsCategorized 
     {
-      get { return false; }
+      get
+      {
+        return _isPropertyGridCategorized;
+      }
     }
 
     bool IPropertyContainer.AutoGenerateProperties
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml
index 2e214c53..4d564b64 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml
@@ -44,6 +44,7 @@
     <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
     <pgconv:ExpandableObjectMarginConverter x:Key="ExpandableObjectMarginConverter" />
     <pgconv:ObjectToUIElementConverter x:Key="ObjectToUIElementConverter" />
+    <pgconv:IsStringEmptyConverter x:Key="IsStringEmptyConverter" />
 
    <x:Static x:Key="EmptyString" Member="sys:String.Empty" />
 
@@ -500,7 +501,28 @@
         </Setter>
     </Style>
 
-    <ContextMenu x:Key="{ComponentResourceKey 
+   <Style x:Key="PropertyItemGroupContainerStyle"
+          TargetType="{x:Type GroupItem}">
+      <Style.Resources>
+      </Style.Resources>
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Border>
+                  <Expander Header="{Binding Name}"
+                            Style="{StaticResource ExpanderStyle}">
+                        <Expander.IsExpanded>
+                           <sys:Boolean>True</sys:Boolean>
+                        </Expander.IsExpanded>
+                     <ItemsPresenter />
+                  </Expander>
+               </Border>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+   <ContextMenu x:Key="{ComponentResourceKey 
                   TypeInTargetAssembly={x:Type pg:PropertyGrid}, 
                   ResourceId=SelectedObjectAdvancedOptionsMenu}">
         <MenuItem Header="Reset Value" Command="commands:PropertyItemCommands.ResetValue" />
@@ -615,6 +637,11 @@
                                  <VirtualizingStackPanel />
                               </ItemsPanelTemplate>
                            </ItemsControl.ItemsPanel>
+
+                           <ItemsControl.GroupStyle>
+                              <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}"/>
+                           </ItemsControl.GroupStyle>
+
                         </pg:PropertyItemsControl>
                      </Expander>
                   </Grid>
@@ -641,6 +668,17 @@
                              TargetName="_text"
                              Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
                   </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding ShowDescriptionByTooltip, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=pg:PropertyGrid}}"
+                                   Value="True" />
+                        <Condition Binding="{Binding Description, RelativeSource={RelativeSource Self}, Converter={StaticResource IsStringEmptyConverter}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="ToolTipService.ToolTip"
+                             Value="{Binding Description, RelativeSource={RelativeSource TemplatedParent}}"
+                             TargetName="PART_Name" />
+                  </MultiDataTrigger>
                   <Trigger Property="Validation.HasError"
                            Value="true">
                      <Setter Property="ToolTip"
@@ -815,28 +853,8 @@
                                         </ItemsControl.ItemsPanel>
 
                                         <ItemsControl.GroupStyle>
-                                            <GroupStyle>
-                                                <GroupStyle.ContainerStyle>
-                                                    <Style TargetType="{x:Type GroupItem}">
-                                                        <Setter Property="Template">
-                                                            <Setter.Value>
-                                                                <ControlTemplate>
-                                                                    <Border>
-                                                                        <Expander Header="{Binding Name}"
-                                                                                  Style="{StaticResource ExpanderStyle}">
-                                                                            <Expander.IsExpanded>
-                                                                                <sys:Boolean>True</sys:Boolean>
-                                                                            </Expander.IsExpanded>
-                                                                            <ItemsPresenter />
-                                                                        </Expander>
-                                                                    </Border>
-                                                                </ControlTemplate>
-                                                            </Setter.Value>
-                                                        </Setter>
-                                                    </Style>
-                                                </GroupStyle.ContainerStyle>
-                                            </GroupStyle>
-                                        </ItemsControl.GroupStyle>
+                                          <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}" />
+                                       </ItemsControl.GroupStyle>
 
                                     </pg:PropertyItemsControl>
                                 </ScrollViewer>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml
index 8c13cee2..792d08b1 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml
@@ -41,6 +41,7 @@
    <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
    <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
    <pgconv:ExpandableObjectMarginConverter x:Key="ExpandableObjectMarginConverter" />
+   <pgconv:IsStringEmptyConverter x:Key="IsStringEmptyConverter" />
 
    <x:Static x:Key="EmptyString" Member="sys:String.Empty" />
 
@@ -197,6 +198,12 @@
             </MultiTrigger.Conditions>
             <Setter Property="BorderBrush" Value="Transparent" />
          </MultiTrigger>
+         <MultiTrigger>
+            <MultiTrigger.Conditions>
+               <Condition Property="IsEnabled" Value="False"/>
+            </MultiTrigger.Conditions>
+            <Setter Property="BorderThickness" Value="0" />
+         </MultiTrigger>          
       </Style.Triggers>
    </Style>
 
@@ -557,6 +564,27 @@
       </Setter>
    </Style>
 
+   <Style x:Key="PropertyItemGroupContainerStyle"
+          TargetType="{x:Type GroupItem}">
+      <Style.Resources>
+      </Style.Resources>
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Border>
+                  <Expander Header="{Binding Name}"
+                            Style="{StaticResource ExpanderStyle}">
+                        <Expander.IsExpanded>
+                              <sys:Boolean>True</sys:Boolean>
+                        </Expander.IsExpanded>
+                     <ItemsPresenter />
+                  </Expander>
+               </Border>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
    <ContextMenu x:Key="{ComponentResourceKey 
                   TypeInTargetAssembly={x:Type pg:PropertyGrid}, 
                   ResourceId=SelectedObjectAdvancedOptionsMenu}">
@@ -656,6 +684,11 @@
                                  <VirtualizingStackPanel />
                               </ItemsPanelTemplate>
                            </ItemsControl.ItemsPanel>
+
+                           <ItemsControl.GroupStyle>
+                              <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}" />
+                           </ItemsControl.GroupStyle>
+
                         </pg:PropertyItemsControl>
                      </Expander>
                   </Grid>
@@ -676,6 +709,17 @@
                              TargetName="_text"
                              Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
                   </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding ShowDescriptionByTooltip, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=pg:PropertyGrid}}"
+                                   Value="True" />
+                        <Condition Binding="{Binding Description, RelativeSource={RelativeSource Self}, Converter={StaticResource IsStringEmptyConverter}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="ToolTipService.ToolTip"
+                             Value="{Binding Description, RelativeSource={RelativeSource TemplatedParent}}"
+                             TargetName="PART_Name" />
+                  </MultiDataTrigger>
                   <Trigger Property="Validation.HasError" Value="true">
                         <Setter Property="ToolTip"
                                 Value="{Binding RelativeSource={x:Static RelativeSource.Self}, Path=(Validation.Errors).CurrentItem.ErrorContent}"/>
@@ -806,27 +850,7 @@
                               </ItemsControl.ItemsPanel>
 
                               <ItemsControl.GroupStyle>
-                                 <GroupStyle>
-                                    <GroupStyle.ContainerStyle>
-                                       <Style TargetType="{x:Type GroupItem}">
-                                          <Setter Property="Template">
-                                             <Setter.Value>
-                                                <ControlTemplate>
-                                                   <Border >
-                                                        <Expander Header="{Binding Name}"
-                                                                    Style="{StaticResource ExpanderStyle}">
-                                                            <Expander.IsExpanded>
-                                                                <sys:Boolean>True</sys:Boolean>
-                                                            </Expander.IsExpanded>
-                                                            <ItemsPresenter />
-                                                        </Expander>
-                                                    </Border>
-                                                </ControlTemplate>
-                                             </Setter.Value>
-                                          </Setter>
-                                       </Style>
-                                    </GroupStyle.ContainerStyle>
-                                 </GroupStyle>
+                                 <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}" />
                               </ItemsControl.GroupStyle>
 
                            </pg:PropertyItemsControl>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs
index c96ee1ee..a36deced 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs
@@ -25,6 +25,7 @@ using System.Windows.Data;
 
 namespace Xceed.Wpf.Toolkit.Converters
 {
+  [Obsolete("This class is no longer used internaly and may be removed in a future release")]
   public class SliderThumbWidthConverter : IValueConverter
   {
     public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs
index fff651b4..14f39322 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs
@@ -49,16 +49,6 @@ namespace Xceed.Wpf.Toolkit
 
       #endregion Members
 
-      #region Enums
-
-      public enum OrientationEnum
-      {
-          Horizontal,
-          Vertical
-      };
-
-      #endregion Enums
-
       #region Constructors
 
       static RangeSlider()
@@ -177,7 +167,7 @@ namespace Xceed.Wpf.Toolkit
       /// HigherValue property represents the higher value within the selected range.
       /// </summary>
       public static readonly DependencyProperty HigherValueProperty = DependencyProperty.Register( "HigherValue", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnHigherValueChanged, RangeSlider.CoerceHigherValue ) );
+        , new FrameworkPropertyMetadata( 0d, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, RangeSlider.OnHigherValueChanged ) );
 
       public double HigherValue
       {
@@ -191,14 +181,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceHigherValue( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        return Math.Max( rangeSlider.LowerValue, Math.Max( rangeSlider.Minimum, Math.Min( rangeSlider.Maximum, newValue ) ) );
-      }
-
       private static void OnHigherValueChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -210,7 +192,7 @@ namespace Xceed.Wpf.Toolkit
 
       protected virtual void OnHigherValueChanged( double oldValue, double newValue )
       {
-        this.AdjustWidths( this.Minimum, this.Maximum, this.LowerValue, newValue );
+        this.AdjustView();
 
         RoutedEventArgs args = new RoutedEventArgs();
         args.RoutedEvent = RangeSlider.HigherValueChangedEvent;
@@ -273,7 +255,7 @@ namespace Xceed.Wpf.Toolkit
       /// 
 
       private static DependencyPropertyKey LowerRangeWidthPropertyKey = DependencyProperty.RegisterAttachedReadOnly( "LowerRangeWidth", typeof( double )
-        , typeof( RangeSlider ), new PropertyMetadata( 0d ) );
+        , typeof( RangeSlider ), new PropertyMetadata( 0d  ) );
 
       public static readonly DependencyProperty LowerRangeWidthProperty = LowerRangeWidthPropertyKey.DependencyProperty;
 
@@ -319,7 +301,7 @@ namespace Xceed.Wpf.Toolkit
       /// LowerValue property represents the lower value within the selected range.
       /// </summary>
       public static readonly DependencyProperty LowerValueProperty = DependencyProperty.Register( "LowerValue", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnLowerValueChanged, RangeSlider.CoerceLowerValue ) );
+        , new FrameworkPropertyMetadata( 0d, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, RangeSlider.OnLowerValueChanged ) );
 
       public double LowerValue
       {
@@ -333,19 +315,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceLowerValue( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        if( ( rangeSlider.HigherValue == 0 ) && ( rangeSlider.LowerValue == 0 ) )
-          newValue = Math.Max( rangeSlider.Minimum, Math.Min( rangeSlider.Maximum, newValue ) );
-        else
-          newValue = Math.Min( Math.Max( rangeSlider.Minimum, Math.Min( rangeSlider.Maximum, newValue ) ), rangeSlider.HigherValue );
-
-        return newValue;
-      }
-
       private static void OnLowerValueChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -357,9 +326,7 @@ namespace Xceed.Wpf.Toolkit
 
       protected virtual void OnLowerValueChanged( double oldValue, double newValue )
       {
-        this.HigherValue = Math.Max( this.HigherValue, newValue );
-
-          this.AdjustWidths( this.Minimum, this.Maximum, newValue, this.HigherValue );
+          this.AdjustView();
 
           RoutedEventArgs args = new RoutedEventArgs();
           args.RoutedEvent = RangeSlider.LowerValueChangedEvent;
@@ -374,7 +341,7 @@ namespace Xceed.Wpf.Toolkit
       /// Maximum property represents the maximum value, which can be selected, in a range.
       /// </summary>
       public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register( "Maximum", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnMaximumChanged, RangeSlider.CoerceMaximum ) );
+        , new FrameworkPropertyMetadata( RangeSlider.OnMaximumChanged ) );
 
       public double Maximum
       {
@@ -388,14 +355,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceMaximum( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        return Math.Max( newValue, rangeSlider.HigherValue );
-      }
-
       private static void OnMaximumChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -407,7 +366,7 @@ namespace Xceed.Wpf.Toolkit
 
       protected virtual void OnMaximumChanged( double oldValue, double newValue )
       {
-        this.AdjustWidths( this.Minimum, newValue, this.LowerValue, this.HigherValue );
+        this.AdjustView();
       }
 
       #endregion Maximum
@@ -418,7 +377,7 @@ namespace Xceed.Wpf.Toolkit
       /// Minimum property represents the minimum value, which can be selected, in a range.
       /// </summary>
       public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register( "Minimum", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnMinimumChanged, RangeSlider.CoerceMinimum ) );
+        , new FrameworkPropertyMetadata( RangeSlider.OnMinimumChanged ) );
 
       public double Minimum
       {
@@ -432,23 +391,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceMinimum( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        if( ( rangeSlider.Minimum == 0.0 ) && ( rangeSlider.LowerValue == 0 ) && ( rangeSlider.HigherValue == 0 ) && ( rangeSlider.Maximum == 0 ) )
-        {
-          newValue = Math.Max( newValue, rangeSlider.LowerValue );
-        }
-        else
-        {
-          newValue = Math.Min( newValue, rangeSlider.LowerValue );
-        }
-
-        return newValue;
-      }
-
       private static void OnMinimumChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -461,7 +403,7 @@ namespace Xceed.Wpf.Toolkit
       protected virtual void OnMinimumChanged( double oldValue, double newValue )
       {
         // adjust the range width
-        this.AdjustWidths( newValue, this.Maximum, this.LowerValue, this.HigherValue );
+        this.AdjustView();
       }
 
       #endregion Minimum
@@ -472,14 +414,14 @@ namespace Xceed.Wpf.Toolkit
       /// # TODODOC
       /// Get/Set the RangeSlider orientation.
       /// </summary>
-      public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register( "Orientation", typeof( OrientationEnum ), typeof( RangeSlider ),
-          new FrameworkPropertyMetadata( OrientationEnum.Horizontal, RangeSlider.OnOrientationChanged ) );
+      public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register( "Orientation", typeof( Orientation ), typeof( RangeSlider ),
+          new FrameworkPropertyMetadata( Orientation.Horizontal, RangeSlider.OnOrientationChanged ) );
 
-      public OrientationEnum Orientation
+      public Orientation Orientation
       {
         get
         {
-          return ( OrientationEnum )GetValue( RangeSlider.OrientationProperty );
+          return ( Orientation )GetValue( RangeSlider.OrientationProperty );
         }
         set
         {
@@ -492,11 +434,11 @@ namespace Xceed.Wpf.Toolkit
         RangeSlider rangeSlider = sender as RangeSlider;
         if( rangeSlider != null )
         {
-          rangeSlider.OnOrientationChanged( ( OrientationEnum )e.OldValue, ( OrientationEnum )e.NewValue );
+          rangeSlider.OnOrientationChanged( ( Orientation )e.OldValue, ( Orientation )e.NewValue );
         }
       }
 
-      protected virtual void OnOrientationChanged( OrientationEnum oldValue, OrientationEnum newValue )
+      protected virtual void OnOrientationChanged( Orientation oldValue, Orientation newValue )
       {
       }
 
@@ -635,21 +577,25 @@ namespace Xceed.Wpf.Toolkit
         if( _lowerSlider != null )
         {
           _lowerSlider.Loaded -= this.Slider_Loaded;
+          _lowerSlider.ValueChanged -= LowerSlider_ValueChanged;
         }
         _lowerSlider = this.Template.FindName( PART_LowerSlider, this ) as Slider;
         if( _lowerSlider != null )
         {
           _lowerSlider.Loaded += this.Slider_Loaded;
+          _lowerSlider.ValueChanged += LowerSlider_ValueChanged;
         }
 
         if( _higherSlider != null )
         {
-            _higherSlider.Loaded -= this.Slider_Loaded;    
+            _higherSlider.Loaded -= this.Slider_Loaded;
+            _higherSlider.ValueChanged -= HigherSlider_ValueChanged;
         }
         _higherSlider = this.Template.FindName( PART_HigherSlider, this ) as Slider;
         if( _higherSlider != null )
         {
-          _higherSlider.Loaded += this.Slider_Loaded; 
+          _higherSlider.Loaded += this.Slider_Loaded;
+          _higherSlider.ValueChanged += HigherSlider_ValueChanged;
         }
       }
 
@@ -690,19 +636,22 @@ namespace Xceed.Wpf.Toolkit
         return 0d;
       }
 
-      private void AdjustWidths( double minimum, double maximum, double lowerValue, double higherValue )
+      private void AdjustView()
       {
+        //Coerce values to make them consistent.
+        CoercedValues cv = this.GetCoercedValues();
+
         double actualWidth = 0;
         double lowerSliderThumbWidth = 0d;
         double higherSliderThumbWidth = 0d;
 
-        if( this.Orientation == OrientationEnum.Horizontal )
+        if( this.Orientation == Orientation.Horizontal )
         {
           actualWidth = this.ActualWidth;
           lowerSliderThumbWidth = RangeSlider.GetThumbWidth( _lowerSlider );
           higherSliderThumbWidth = RangeSlider.GetThumbWidth( _higherSlider );
         }
-        else if( this.Orientation == OrientationEnum.Vertical )
+        else if( this.Orientation == Orientation.Vertical )
         {
           actualWidth = this.ActualHeight;
           lowerSliderThumbWidth = RangeSlider.GetThumbHeight( _lowerSlider );
@@ -711,20 +660,34 @@ namespace Xceed.Wpf.Toolkit
 
         actualWidth -= ( lowerSliderThumbWidth + higherSliderThumbWidth );
 
-        double entireRange = maximum - minimum;
+        this.SetLowerSliderValues( cv.LowerValue, cv.Minimum, cv.Maximum );
+        this.SetHigherSliderValues( cv.HigherValue, cv.Minimum, cv.Maximum );
+
+        double entireRange = cv.Maximum - cv.Minimum;
+
+        if( entireRange > 0 )
+        {
+          this.HigherRangeWidth = ( actualWidth * ( cv.Maximum - cv.HigherValue ) ) / entireRange;
+
+          this.RangeWidth = ( actualWidth * ( cv.HigherValue - cv.LowerValue ) ) / entireRange;
 
-        this.HigherRangeWidth = ( actualWidth * ( maximum - higherValue ) ) / entireRange;
+          this.LowerRangeWidth = ( actualWidth * ( cv.LowerValue - cv.Minimum ) ) / entireRange;
+        }
+        else
+        {
+          this.HigherRangeWidth = 0d;
+          this.RangeWidth = 0d;
+          this.LowerRangeWidth = actualWidth;
+        }
 
-        this.RangeWidth = ( actualWidth * ( higherValue - lowerValue ) ) / entireRange;
 
-        this.LowerRangeWidth = ( actualWidth * ( lowerValue - minimum ) ) / entireRange;
       }
 
       private void SetSlidersMargins()
       {
         if( ( _lowerSlider != null ) && ( _higherSlider != null ) )
         {
-          if( this.Orientation == OrientationEnum.Horizontal )
+          if( this.Orientation == Orientation.Horizontal )
           {
             double lowerSliderThumbWidth = RangeSlider.GetThumbWidth( _lowerSlider );
             double higherSliderThumbWidth = RangeSlider.GetThumbWidth( _higherSlider );
@@ -743,6 +706,53 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
+      private CoercedValues GetCoercedValues()
+      {
+        CoercedValues cv = new CoercedValues();
+        cv.Minimum = Math.Min( this.Minimum, this.Maximum );
+        cv.Maximum = Math.Max( cv.Minimum, this.Maximum );
+        cv.LowerValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, this.LowerValue ) );
+        cv.HigherValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, this.HigherValue ) );
+        cv.HigherValue = Math.Max( cv.LowerValue, cv.HigherValue );
+
+        return cv;
+      }
+
+      private void SetLowerSliderValues( double value, double? minimum, double? maximum )
+      {
+        this.SetSliderValues( _lowerSlider, this.LowerSlider_ValueChanged, value, minimum, maximum );
+      }
+
+      private void SetHigherSliderValues( double value, double? minimum, double? maximum )
+      {
+        this.SetSliderValues( _higherSlider, this.HigherSlider_ValueChanged, value, minimum, maximum );
+      }
+
+      private void SetSliderValues(
+        Slider slider,
+        RoutedPropertyChangedEventHandler<double> handler,
+        double value,
+        double? minimum,
+        double? maximum )
+      {
+        if( slider != null )
+        {
+          slider.ValueChanged -= handler;
+
+          slider.Value = value;
+          if( minimum != null )
+          {
+            slider.Minimum = minimum.Value;
+          }
+          if( maximum != null )
+          {
+            slider.Maximum = maximum.Value;
+          }
+
+          slider.ValueChanged += handler;
+        }
+      }
+
       #endregion
 
       #region Events
@@ -779,25 +789,73 @@ namespace Xceed.Wpf.Toolkit
 
       private void LowerRange_Click(object sender, RoutedEventArgs e)
       {
-        this.LowerValue -= this.Step;
+        CoercedValues cv = this.GetCoercedValues();
+        //When Maximum is not greater than Minimum, the
+        //slider display is in an inconsistant state. Don't 
+        //consider any operation from the user
+        if( cv.Minimum < cv.Maximum )
+        {
+          double newValue = cv.LowerValue - this.Step;
+          this.LowerValue = Math.Min( cv.Maximum, Math.Max( cv.Minimum, newValue ) );
+        }
       }
 
       private void HigherRange_Click(object sender, RoutedEventArgs e)
       {
-        this.HigherValue += this.Step;
+        CoercedValues cv = this.GetCoercedValues();
+        //When Maximum is not greater than Minimum, the
+        //slider display is in an inconsistant state. Don't 
+        //consider any operation from the user
+        if( cv.Minimum < cv.Maximum )
+        {
+          double newValue = cv.HigherValue + this.Step;
+          this.HigherValue = Math.Min( cv.Maximum, Math.Max( cv.Minimum, newValue ) );
+        }
       }
 
       private void RangeSlider_SizeChanged( object sender, SizeChangedEventArgs e )
       {
-        this.AdjustWidths( this.Minimum, this.Maximum, this.LowerValue, this.HigherValue );
+        this.AdjustView();
       }
 
       private void Slider_Loaded( object sender, RoutedEventArgs e )
       {
         this.SetSlidersMargins();
-        this.AdjustWidths( this.Minimum, this.Maximum, this.LowerValue, this.HigherValue );
+        this.AdjustView();
+      }
+
+      private void LowerSlider_ValueChanged( object sender, RoutedPropertyChangedEventArgs<double> e )
+      {
+        if( _lowerSlider.IsLoaded )
+        {
+          CoercedValues cv = this.GetCoercedValues();
+          double newValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, e.NewValue ) );
+          newValue = Math.Min( newValue, cv.HigherValue );
+          this.SetLowerSliderValues( newValue, null, null );
+          this.LowerValue = newValue;
+        }
+      }
+
+      private void HigherSlider_ValueChanged( object sender, RoutedPropertyChangedEventArgs<double> e )
+      {
+        if( _higherSlider.IsLoaded )
+        {
+          CoercedValues cv = this.GetCoercedValues();
+          double newValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, e.NewValue ) );
+          newValue = Math.Max( newValue, cv.LowerValue );
+          this.SetHigherSliderValues( newValue, null, null );
+          this.HigherValue = newValue;
+        }
       }
 
       #endregion Events Handlers
+
+      private struct CoercedValues
+      {
+        public double Minimum;
+        public double Maximum;
+        public double LowerValue;
+        public double HigherValue;
+      }
     }
 }
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml
index 499c266c..2776dfc9 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml
@@ -22,30 +22,46 @@
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Converters"
                     xmlns:coreConv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-   <conv:SliderThumbWidthConverter x:Key="SliderThumbWidthConverter" />
    <coreConv:SolidColorBrushToColorConverter x:Key="SolidColorBrushToColorConverter" />
 
     <!-- //#TODODOC
          Repeat Button - This is used by RangeSlider for the LowerRange, Range, and HigherRange buttons -->
    <Style x:Key="DefaultRangeStyle"
           TargetType="{x:Type RepeatButton}">
+      <Setter Property="Focusable"
+              Value="False" />
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type RepeatButton}">
                <Grid>
                   <Rectangle x:Name="MainBorder"
-                             Fill="Transparent"
-                             Opacity="1" />
+                             Fill="{TemplateBinding Background}" />
                </Grid>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
    </Style>
 
+   <!--//##TODODOC-->
+   <!--Since a thumb is pretty small, we put a bigger visual clue
+   outside the thumb bounds to give the user a hint where the focus is-->
+   <Style x:Key="ThumbFocusVisualStyle">
+      <Setter Property="Control.Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Rectangle Margin="-2"
+                          StrokeThickness="1"
+                          Stroke="Black"
+                          StrokeDashArray="1 2" />
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+   <!-- ********************** -->
+    <!-- Thumb Template    -->
     <!-- ********************** -->
-    <!-- LowerThumb Template    -->
-    <!-- ********************** -->
-   <ControlTemplate x:Key="LowerThumbTemplate"
+   <ControlTemplate x:Key="ThumbTemplate"
                     TargetType="{x:Type Thumb}">
       <Grid>
          <Rectangle x:Name="BackgroundFadingRect"
@@ -53,17 +69,17 @@
                     Width="11"
                     Height="20" />
          <Rectangle x:Name="MainBorder"
-                    Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue=#FFF0F0F0}"
+                    Fill="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background, TargetNullValue=#FFF0F0F0}"
                     StrokeThickness="1"
                     Stroke="#FFACACAC"
                     Opacity="1"
                     Width="11"
                     Height="20"
-                    ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
+                    ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Value, StringFormat=\{0:00.00\}}"
                     SnapsToDevicePixels="True" />
       </Grid>
       <ControlTemplate.Triggers>
-         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background, Converter={StaticResource SolidColorBrushToColorConverter}}"
                       Value="Transparent">
             <Setter Property="Visibility"
                     TargetName="BackgroundFadingRect"
@@ -75,11 +91,9 @@
                     TargetName="MainBorder"
                     Value="0.75" />
          </Trigger>
-         <!-- //# TODODOC
-               Do something else when MouseOver and LowerThumbBackground is null -->
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background}"
                           Value="{x:Null}" />
                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
@@ -107,451 +121,192 @@
                     TargetName="MainBorder"
                     Value="#FFF0F0F0" />
          </Trigger>
-      </ControlTemplate.Triggers>
-   </ControlTemplate>
-
-    <!-- ********************** -->
-    <!-- HigherThumb Template    -->
-    <!-- ********************** -->
-   <ControlTemplate x:Key="HigherThumbTemplate"
-                    TargetType="{x:Type Thumb}">
-      <Grid>
-         <Rectangle x:Name="BackgroundFadingRect"
-                    Fill="Black"
-                    Width="11"
-                    Height="20" />
-         <Rectangle Name="MainBorder"
-                    Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue=#FFF0F0F0}"
-                    StrokeThickness="1"
-                    Stroke="#FFACACAC"
-                    Opacity="1"
-                    Width="11"
-                    Height="20"
-                    ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                    SnapsToDevicePixels="True" />
-      </Grid>
-      <ControlTemplate.Triggers>
-         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
-                      Value="Transparent">
-            <Setter Property="Visibility"
-                    TargetName="BackgroundFadingRect"
-                    Value="Collapsed" />
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Orientation}"
+                      Value="Vertical">
+            <Setter TargetName="MainBorder"
+                    Property="Width"
+                    Value="20" />
+            <Setter TargetName="MainBorder"
+                    Property="Height"
+                    Value="11" />
+            <Setter TargetName="BackgroundFadingRect"
+                    Property="Width"
+                    Value="20" />
+            <Setter TargetName="BackgroundFadingRect"
+                    Property="Height"
+                    Value="11" />
          </DataTrigger>
-         <Trigger Property="IsMouseOver"
-                  Value="True">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="0.75" />
-         </Trigger>
-         <!-- //# TODODOC
-               Do something else when MouseOver and HigherThumbBackground is null -->
-         <MultiDataTrigger>
-            <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                          Value="{x:Null}" />
-               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                          Value="True" />
-            </MultiDataTrigger.Conditions>
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="1" />
-            <Setter Property="Stroke"
-                    TargetName="MainBorder"
-                    Value="#FF7EB4EA" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="#FFDCECFC" />
-         </MultiDataTrigger>
-
-         <Trigger Property="IsEnabled"
-                  Value="False">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="1" />
-            <Setter Property="Stroke"
-                    TargetName="MainBorder"
-                    Value="#FFD9D9D9" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="#FFF0F0F0" />
-         </Trigger>
       </ControlTemplate.Triggers>
    </ControlTemplate>
 
     <!-- ********************** -->
-    <!-- LowerSlider Template     -->
+    <!-- Slider Template     -->
     <!-- ********************** -->
-   <ControlTemplate x:Key="LowerSliderTemplate"
+   <ControlTemplate x:Key="SliderTemplate"
                     TargetType="{x:Type Slider}">
       <Border SnapsToDevicePixels="true"
               BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
-            <Grid.RowDefinitions>
-               <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
-               <RowDefinition Height="Auto" />
-            </Grid.RowDefinitions>
-
             <Track x:Name="PART_Track"
+                   Orientation="{TemplateBinding Orientation}"
                    Grid.Row="1">
                <Track.Thumb>
                   <Thumb x:Name="Thumb"
-                         Template="{StaticResource LowerThumbTemplate}">
+                         Focusable="True"
+                         FocusVisualStyle="{StaticResource ThumbFocusVisualStyle}"
+                         Background="{TemplateBinding Background}"
+                         Template="{StaticResource ThumbTemplate}">
                   </Thumb>
                </Track.Thumb>
             </Track>
-         </Grid>
       </Border>
    </ControlTemplate>
 
     <!-- ********************** -->
-    <!-- HigherSlider Template   -->
+    <!-- Vertical RangeSlider Template -->
     <!-- ********************** -->
-   <ControlTemplate x:Key="HigherSliderTemplate"
-                    TargetType="{x:Type Slider}">
-      <Border SnapsToDevicePixels="true"
-              BorderBrush="{TemplateBinding BorderBrush}"
-              BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
+   <ControlTemplate x:Key="VerticalRangeSlider"
+                    TargetType="{x:Type local:RangeSlider}">
+      <Border BorderBrush="{TemplateBinding BorderBrush}"
+              BorderThickness="{TemplateBinding BorderThickness}"
+              Background="{TemplateBinding Background}">
+         <Grid HorizontalAlignment="Left"
+               VerticalAlignment="Top">
+            <!-- //#TODODOC 
+             Get Thumbs's height to set the good RangeSlider height.-->
             <Grid.RowDefinitions>
+               <RowDefinition Height="11" />
+               <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
                <RowDefinition Height="Auto" />
+               <RowDefinition Height="11" />
             </Grid.RowDefinitions>
 
-            <Track x:Name="PART_Track"
-                   Grid.Row="1">
-               <Track.Thumb>
-                  <Thumb x:Name="Thumb"
-                         Template="{StaticResource HigherThumbTemplate}" />
-               </Track.Thumb>
-            </Track>
+            <Border Grid.Row="1"
+                    Grid.RowSpan="3"
+                    BorderThickness="1"
+                    BorderBrush="#FFD6D6D6"
+                    Background="#FFE7EAEA"
+                    VerticalAlignment="Stretch"
+                    HorizontalAlignment="Center"
+                    Width="4" />
+
+            <RepeatButton x:Name="PART_LowerRange"
+                          Height="{TemplateBinding LowerRangeWidth}"
+                          Grid.Row="3"
+                          Background="{TemplateBinding LowerRangeBackground}"
+                          Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton Height="{TemplateBinding RangeWidth}"
+                          Grid.Row="2"
+                          Background="{TemplateBinding RangeBackground}"
+                          Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton x:Name="PART_HigherRange"
+                          Height="{TemplateBinding HigherRangeWidth}"
+                          Grid.Row="1"
+                          Background="{TemplateBinding HigherRangeBackground}"
+                          Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
+            <Slider x:Name="PART_LowerSlider"
+                    Orientation="Vertical"
+                    Grid.RowSpan="5"
+                    Focusable="False"
+                    Background="{TemplateBinding LowerThumbBackground}"
+                    Template="{StaticResource SliderTemplate}">
+            </Slider>
+
+            <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+            <Slider x:Name="PART_HigherSlider"
+                    Grid.RowSpan="5"
+                    Orientation="Vertical"
+                    Focusable="False"
+                    Background="{TemplateBinding HigherThumbBackground}"
+                    Template="{StaticResource SliderTemplate}">
+            </Slider>
          </Grid>
       </Border>
    </ControlTemplate>
 
-    <!-- ********************** -->
-    <!-- Vertical RangeSlider Template -->
-    <!-- ********************** -->
-   <ControlTemplate x:Key="VerticalRangeSlider"
-                    TargetType="{x:Type local:RangeSlider}">
-      <Grid Width="50">
-         <!-- //#TODODOC 
-             Get Thumbs's height to set the good RangeSlider height.-->
-         <Grid.RowDefinitions>
-            <RowDefinition Height="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-         </Grid.RowDefinitions>
-
-         <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="Auto" />
-            <ColumnDefinition Width="Auto"
-                              MinWidth="50" />
-         </Grid.ColumnDefinitions>
-
-         <Border Grid.Column="1"
-                 Grid.Row="1"
-                 Grid.RowSpan="3"
-                 BorderThickness="1"
-                 BorderBrush="#FFD6D6D6"
-                 Background="#FFE7EAEA"
-                 VerticalAlignment="Stretch"
-                 HorizontalAlignment="Center"
-                 Width="4" />
-
-         <RepeatButton x:Name="PART_LowerRange"
-                       Height="{TemplateBinding LowerRangeWidth}"
-                       Width="15"
-                       Grid.Column="1"
-                       Grid.Row="3"
-                       Background="{TemplateBinding LowerRangeBackground}"
-                       Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True"/>
-
-         <RepeatButton Height="{TemplateBinding RangeWidth}"
-                       Width="15"
-                       Grid.Row="2"
-                       Grid.Column="1"
-                       Background="{TemplateBinding RangeBackground}"
-                       Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True"/>
-
-         <RepeatButton x:Name="PART_HigherRange"
-                       Height="{TemplateBinding HigherRangeWidth}"
-                       Width="15"
-                       Grid.Row="1"
-                       Grid.Column="1"
-                       Background="{TemplateBinding HigherRangeBackground}"
-                       Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True"/>
-
-         <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
-         <Slider x:Name="PART_LowerSlider"
-                 Grid.Column="1"
-                 Orientation="Vertical"
-                 Grid.RowSpan="5"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Rectangle x:Name="BackgroundFadingRect"
-                                                     Fill="Black"
-                                                     Width="20"
-                                                     Height="11" />
-                                          <Rectangle x:Name="MainBorder"
-                                                     Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue=#FFF0F0F0}"
-                                                     StrokeThickness="1"
-                                                     Stroke="#FFACACAC"
-                                                     Width="20"
-                                                     Height="11"
-                                                     Opacity="1"
-                                                     ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
-                                                     SnapsToDevicePixels="True" />
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
-                                                       Value="Transparent">
-                                             <Setter Property="Visibility"
-                                                     TargetName="BackgroundFadingRect"
-                                                     Value="Collapsed" />
-                                          </DataTrigger>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.75" />
-                                          </Trigger>
-                                          <!-- //# TODODOC
-                                             Do something else when MouseOver and LowerThumbBackground is null -->
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FF7EB4EA" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFDCECFC" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD9D9D9" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF0F0F0" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-
-         <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-         <Slider x:Name="PART_HigherSlider"
-                 Grid.Column="1"
-                 Grid.RowSpan="5"
-                 Orientation="Vertical"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Rectangle x:Name="BackgroundFadingRect"
-                                                     Fill="Black"
-                                                     Width="20"
-                                                     Height="11" />
-                                          <Rectangle Name="MainBorder"
-                                                     Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue=#FFF0F0F0}"
-                                                     StrokeThickness="1"
-                                                     Stroke="#FFACACAC"
-                                                     Width="20"
-                                                     Height="11"
-                                                     ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                                                     SnapsToDevicePixels="True" />
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
-                                                       Value="Transparent">
-                                             <Setter Property="Visibility"
-                                                     TargetName="BackgroundFadingRect"
-                                                     Value="Collapsed" />
-                                          </DataTrigger>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter TargetName="MainBorder"
-                                                     Property="Opacity"
-                                                     Value="0.75" />
-                                          </Trigger>
-                                          <!-- //# TODODOC
-                                                Do something else when MouseOver and HigherThumbBackground is null -->
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FF7EB4EA" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFDCECFC" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD9D9D9" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF0F0F0" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-      </Grid>
-   </ControlTemplate>
-
     <!-- ********************** -->
     <!-- RangeSlider Style -->
     <!-- ********************** -->
    <Style TargetType="{x:Type local:RangeSlider}">
+      <Setter Property="IsTabStop"
+              Value="False" />
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type local:RangeSlider}">
-               <Grid>
-                  <Grid.RowDefinitions>
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto"
-                                    MinHeight="{TemplateBinding MinHeight}" />
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto" />
-                  </Grid.RowDefinitions>
-
-                  <!-- //#TODODOC 
+               <Border BorderBrush="{TemplateBinding BorderBrush}"
+                       BorderThickness="{TemplateBinding BorderThickness}"
+                       Background="{TemplateBinding Background}">
+                  <Grid HorizontalAlignment="Left"
+                        VerticalAlignment="Top">
+                     <!-- //#TODODOC 
                         Get Thumbs's width to set the good RangeSlider width.-->
-                  <Grid.ColumnDefinitions>
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
-                     <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
-                  </Grid.ColumnDefinitions>
-
-                  <Border Grid.Row="1"
-                          Grid.Column="1"
-                          Grid.ColumnSpan="3"
-                          BorderThickness="1"
-                          BorderBrush="#FFD6D6D6"
-                          Background="#FFE7EAEA"
-                          VerticalAlignment="Center"
-                          Height="4" />
-
-                  <RepeatButton x:Name="PART_LowerRange"
-                                Width="{TemplateBinding LowerRangeWidth}"
-                                Grid.Column="1"
-                                Grid.Row="1"
-                                Background="{TemplateBinding LowerRangeBackground}"
-                                Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}" 
-                                SnapsToDevicePixels="True"/>
-
-                  <RepeatButton Width="{TemplateBinding RangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="2"
-                                Background="{TemplateBinding RangeBackground}"
-                                Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <RepeatButton x:Name="PART_HigherRange"
-                                Width="{TemplateBinding HigherRangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="3"
-                                Background="{TemplateBinding HigherRangeBackground}"
-                                Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True"/>
-
-                  <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
-                  <Slider x:Name="PART_LowerSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource LowerSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-
-                  <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-                  <Slider x:Name="PART_HigherSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource HigherSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-               </Grid>
+                     <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="11" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="11" />
+                     </Grid.ColumnDefinitions>
+
+                     <Border Grid.Row="1"
+                             Grid.Column="1"
+                             Grid.ColumnSpan="3"
+                             BorderThickness="1"
+                             BorderBrush="#FFD6D6D6"
+                             Background="#FFE7EAEA"
+                             VerticalAlignment="Center"
+                             Height="4" />
+
+                     <RepeatButton x:Name="PART_LowerRange"
+                                   Width="{TemplateBinding LowerRangeWidth}"
+                                   Grid.Column="1"
+                                   Grid.Row="1"
+                                   Background="{TemplateBinding LowerRangeBackground}"
+                                   Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <RepeatButton Width="{TemplateBinding RangeWidth}"
+                                   Grid.Row="1"
+                                   Grid.Column="2"
+                                   Background="{TemplateBinding RangeBackground}"
+                                   Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <RepeatButton x:Name="PART_HigherRange"
+                                   Width="{TemplateBinding HigherRangeWidth}"
+                                   Grid.Row="1"
+                                   Grid.Column="3"
+                                   Background="{TemplateBinding HigherRangeBackground}"
+                                   Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
+                     <Slider x:Name="PART_LowerSlider"
+                             Grid.Row="1"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding LowerThumbBackground}"
+                             Template="{StaticResource SliderTemplate}">
+                     </Slider>
+
+                     <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+                     <Slider x:Name="PART_HigherSlider"
+                             Grid.Row="1"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding HigherThumbBackground}"
+                             Template="{StaticResource SliderTemplate}">
+                     </Slider>
+                  </Grid>
+               </Border>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml
index fa49a941..d4c7af8b 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml
@@ -22,7 +22,6 @@
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Converters"
                     xmlns:coreConv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-   <conv:SliderThumbWidthConverter x:Key="SliderThumbWidthConverter" />
    <coreConv:SolidColorBrushToColorConverter x:Key="SolidColorBrushToColorConverter" />
 
    <LinearGradientBrush x:Key="NormalThumbFillBackground"
@@ -80,123 +79,58 @@
          Repeat Button - This is used by RangeSlider for the LowerRange, Range, and HigherRange buttons -->
    <Style x:Key="DefaultRangeStyle"
           TargetType="{x:Type RepeatButton}">
+      <Setter Property="Focusable"
+              Value="False" />      
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type RepeatButton}">
                <Grid>
                   <Rectangle x:Name="MainBorder"
-                             Fill="Transparent"
-                             Opacity="1" />
+                             Fill="{TemplateBinding Background}"/>
                </Grid>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
    </Style>
 
-   <!-- ********************** -->
-   <!-- LowerThumb Template    -->
-   <!-- ********************** -->
-   <ControlTemplate x:Key="LowerThumbTemplate"
-                    TargetType="{x:Type Thumb}">
-      <Grid>
-         <Border x:Name="BackgroundFadingBorder"
-                 Background="Black" />
-         <Border x:Name="BackgroundBorder"
-                 BorderBrush="#FF929292"
-                 BorderThickness="1"
-                 CornerRadius="1">
-            <Rectangle x:Name="MainBorder"
-                       Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                       StrokeThickness="1"
-                       Stroke="White"
-                       Width="9"
-                       Height="20"
-                       Opacity="1"
-                       ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
-                       SnapsToDevicePixels="True" />
-         </Border>
-      </Grid>
-      <ControlTemplate.Triggers>
-         <Trigger Property="IsMouseOver"
-                  Value="True">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="0.9" />
-         </Trigger>
-         <Trigger Property="IsMouseCaptureWithin"
-                  Value="True">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="0.8" />
-         </Trigger>
-         <MultiDataTrigger>
-            <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                          Value="{x:Null}" />
-               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                          Value="True" />
-            </MultiDataTrigger.Conditions>
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="1" />
-            <Setter Property="BorderBrush"
-                    TargetName="BackgroundBorder"
-                    Value="#FF3C7FB1" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="{StaticResource MouseOverThumbFillBackground}" />
-         </MultiDataTrigger>
-         <MultiDataTrigger>
-            <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                          Value="{x:Null}" />
-               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
-                          Value="True" />
-            </MultiDataTrigger.Conditions>
-            <Setter Property="BorderBrush"
-                    TargetName="BackgroundBorder"
-                    Value="#FF2C628B" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="{StaticResource PressedThumbFillBackground}" />
-         </MultiDataTrigger>
-
-         <Trigger Property="IsEnabled"
-                  Value="False">
-            <Setter Property="BorderBrush"
-                    TargetName="BackgroundBorder"
-                    Value="#FFD7D7D7" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="#FFF4F4F4" />
-            <Setter Property="Stroke"
-                    TargetName="MainBorder"
-                    Value="#FFD7D7D7" />
-         </Trigger>
-      </ControlTemplate.Triggers>
-   </ControlTemplate>
+   <!--//##TODODOC-->
+   <!--Since a thumb is pretty small, we put a bigger visual clue
+   outside the thumb bounds to give the user a hint where the focus is-->
+   <Style x:Key="ThumbFocusVisualStyle">
+      <Setter Property="Control.Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Rectangle Margin="-2"
+                          StrokeThickness="1"
+                          Stroke="Black"
+                          StrokeDashArray="1 2" />
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>   
 
    <!-- ********************** -->
-   <!-- HigherThumb Template    -->
+   <!-- Thumb Template    -->
    <!-- ********************** -->
-   <ControlTemplate x:Key="HigherThumbTemplate"
+   <ControlTemplate x:Key="ThumbTemplate"
                     TargetType="{x:Type Thumb}">
       <Grid>
          <Border x:Name="BackgroundFadingBorder"
                  Background="Black" />
-         <Border x:Name="BackgroundBorder"
-                 BorderBrush="#FF929292"
-                 BorderThickness="1"
-                 CornerRadius="1">
-            <Rectangle x:Name="MainBorder"
-                       Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                       StrokeThickness="1"
-                       Stroke="White"
-                       Width="9"
-                       Height="20"
-                       ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                       SnapsToDevicePixels="True" />
-         </Border>
+            <Border x:Name="BackgroundBorder"
+                    BorderBrush="#FF929292"
+                    BorderThickness="1"
+                    CornerRadius="1">
+               <Rectangle x:Name="MainBorder"
+                          Fill="{Binding Background, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource NormalThumbFillBackground}}"
+                          StrokeThickness="1"
+                          Stroke="White"
+                          Width="9"
+                          Height="20"
+                          Opacity="1"
+                          ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Value, StringFormat=\{0:00.00\}}"
+                          SnapsToDevicePixels="True" />
+            </Border>
       </Grid>
       <ControlTemplate.Triggers>
          <Trigger Property="IsMouseOver"
@@ -211,9 +145,18 @@
                     TargetName="MainBorder"
                     Value="0.8" />
          </Trigger>
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Orientation}"
+                      Value="Vertical">
+            <Setter TargetName="MainBorder"
+                    Property="Width"
+                    Value="20" />
+            <Setter TargetName="MainBorder"
+                    Property="Height"
+                    Value="9" />
+         </DataTrigger>
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background}"
                           Value="{x:Null}" />
                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
@@ -230,7 +173,7 @@
          </MultiDataTrigger>
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background}"
                           Value="{x:Null}" />
                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
                           Value="True" />
@@ -259,412 +202,167 @@
    </ControlTemplate>
 
    <!-- ********************** -->
-   <!-- LowerSlider Template     -->
+   <!-- Slider Template     -->
    <!-- ********************** -->
-   <ControlTemplate x:Key="LowerSliderTemplate"
+   <ControlTemplate x:Key="SliderTemplate"
                     TargetType="{x:Type Slider}">
       <Border SnapsToDevicePixels="true"
               BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
-            <Grid.RowDefinitions>
-               <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
-               <RowDefinition Height="Auto" />
-            </Grid.RowDefinitions>
-
-            <Track x:Name="PART_Track"
-                   Grid.Row="1">
-               <Track.Thumb>
-                  <Thumb x:Name="Thumb"
-                         Template="{StaticResource LowerThumbTemplate}">
-                  </Thumb>
-               </Track.Thumb>
-            </Track>
-         </Grid>
+         <Track x:Name="PART_Track"
+                Orientation="{TemplateBinding Orientation}">
+            <Track.Thumb>
+               <Thumb x:Name="thumb" 
+                      Focusable="True"
+                      FocusVisualStyle="{StaticResource ThumbFocusVisualStyle}"
+                      Background="{TemplateBinding Background}"
+                      Template="{StaticResource ThumbTemplate}">
+               </Thumb>
+            </Track.Thumb>
+         </Track>
       </Border>
    </ControlTemplate>
 
    <!-- ********************** -->
-   <!-- HigherSlider Template   -->
+   <!-- Vertical RangeSlider Template -->
    <!-- ********************** -->
-   <ControlTemplate x:Key="HigherSliderTemplate"
-                    TargetType="{x:Type Slider}">
-      <Border SnapsToDevicePixels="true"
-              BorderBrush="{TemplateBinding BorderBrush}"
-              BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
+   <ControlTemplate x:Key="VerticalRangeSlider"
+                    TargetType="{x:Type local:RangeSlider}">
+      <Border BorderBrush="{TemplateBinding BorderBrush}"
+              BorderThickness="{TemplateBinding BorderThickness}"
+              Background="{TemplateBinding Background}">
+         <Grid HorizontalAlignment="Left"
+               VerticalAlignment="Top">
+            <!-- //#TODODOC 
+             Get Thumbs's height to set the good RangeSlider height.-->
             <Grid.RowDefinitions>
+               <!-- 11 is equal to the width of the horizontal slider thumb, (or the height of the vertical slider thumb)
+               See Thumb template -->
+               <RowDefinition Height="11" />
+               <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
                <RowDefinition Height="Auto" />
+               <RowDefinition Height="11" />
             </Grid.RowDefinitions>
 
-            <Track x:Name="PART_Track"
-                   Grid.Row="1">
-               <Track.Thumb>
-                  <Thumb x:Name="Thumb"
-                         Template="{StaticResource HigherThumbTemplate}" />
-               </Track.Thumb>
-            </Track>
+            <Border Grid.Row="1"
+                    Grid.RowSpan="3"
+                    BorderThickness="1"
+                    BorderBrush="{StaticResource SliderVerticalBorderBrush}"
+                    Background="#FFE7EAEA"
+                    VerticalAlignment="Stretch"
+                    HorizontalAlignment="Center"
+                    Width="4" />
+
+            <RepeatButton x:Name="PART_LowerRange"
+                          Height="{TemplateBinding LowerRangeWidth}"
+                          Grid.Row="3"
+                          Background="{TemplateBinding LowerRangeBackground}"
+                          Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton Height="{TemplateBinding RangeWidth}"
+                          Grid.Row="2"
+                          Background="{TemplateBinding RangeBackground}"
+                          Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton x:Name="PART_HigherRange"
+                          Height="{TemplateBinding HigherRangeWidth}"
+                          Grid.Row="1"
+                          Background="{TemplateBinding HigherRangeBackground}"
+                          Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
+            <Slider x:Name="PART_LowerSlider"
+                    Orientation="Vertical"
+                    Grid.RowSpan="5"
+                    Focusable="False"
+                    Background="{TemplateBinding LowerThumbBackground}"
+                    Template="{StaticResource SliderTemplate}" />
+
+            <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+            <Slider x:Name="PART_HigherSlider"
+                    Grid.RowSpan="5"
+                    Orientation="Vertical"
+                    Focusable="False"
+                    Background="{TemplateBinding HigherThumbBackground}"
+                    Template="{StaticResource SliderTemplate}" />
          </Grid>
       </Border>
    </ControlTemplate>
 
-   <!-- ********************** -->
-   <!-- Vertical RangeSlider Template -->
-   <!-- ********************** -->
-   <ControlTemplate x:Key="VerticalRangeSlider"
-                    TargetType="{x:Type local:RangeSlider}">
-      <Grid Width="50">
-         <!-- //#TODODOC 
-             Get Thumbs's height to set the good RangeSlider height.-->
-         <Grid.RowDefinitions>
-            <RowDefinition Height="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-         </Grid.RowDefinitions>
-
-         <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="Auto" />
-            <ColumnDefinition Width="Auto"
-                              MinWidth="50" />
-         </Grid.ColumnDefinitions>
-
-         <Border Grid.Column="1"
-                 Grid.Row="1"
-                 Grid.RowSpan="3"
-                 BorderThickness="1"
-                 BorderBrush="{StaticResource SliderVerticalBorderBrush}"
-                 Background="#FFE7EAEA"
-                 VerticalAlignment="Stretch"
-                 HorizontalAlignment="Center"
-                 Width="4" />
-
-         <RepeatButton x:Name="PART_LowerRange"
-                       Height="{TemplateBinding LowerRangeWidth}"
-                       Width="15"
-                       Grid.Column="1"
-                       Grid.Row="3"
-                       Background="{TemplateBinding LowerRangeBackground}"
-                       Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True" />
-
-         <RepeatButton Height="{TemplateBinding RangeWidth}"
-                       Width="15"
-                       Grid.Row="2"
-                       Grid.Column="1"
-                       Background="{TemplateBinding RangeBackground}"
-                       Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True" />
-
-         <RepeatButton x:Name="PART_HigherRange"
-                       Height="{TemplateBinding HigherRangeWidth}"
-                       Width="15"
-                       Grid.Row="1"
-                       Grid.Column="1"
-                       Background="{TemplateBinding HigherRangeBackground}"
-                       Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True" />
-
-         <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
-         <Slider x:Name="PART_LowerSlider"
-                 Grid.Column="1"
-                 Orientation="Vertical"
-                 Grid.RowSpan="5"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Border x:Name="BackgroundFadingBorder"
-                                                  Background="Black"
-                                                  Width="22" />
-                                          <Border x:Name="BackgroundBorder"
-                                                  BorderBrush="#FF929292"
-                                                  BorderThickness="1"
-                                                  Width="22"
-                                                  CornerRadius="1">
-                                             <Rectangle x:Name="MainBorder"
-                                                        Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                                                        StrokeThickness="1"
-                                                        Stroke="White"
-                                                        Width="20"
-                                                        Height="9"
-                                                        ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
-                                                        SnapsToDevicePixels="True" />
-                                          </Border>
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.9" />
-                                          </Trigger>
-                                          <Trigger Property="IsMouseCaptureWithin"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.8" />
-                                          </Trigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF3C7FB1" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource MouseOverThumbFillBackground}" />
-                                          </MultiDataTrigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF2C628B" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource PressedThumbFillBackground}" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FFD7D7D7" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF4F4F4" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD7D7D7" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-
-         <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-         <Slider x:Name="PART_HigherSlider"
-                 Grid.Column="1"
-                 Grid.RowSpan="5"
-                 Orientation="Vertical"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Border x:Name="BackgroundFadingBorder"
-                                                  Width="22"
-                                                  Background="Black" />
-                                          <Border x:Name="BackgroundBorder"
-                                                  BorderBrush="#FF929292"
-                                                  BorderThickness="1"
-                                                  Width="22"
-                                                  CornerRadius="1">
-                                             <Rectangle x:Name="MainBorder"
-                                                        Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                                                        StrokeThickness="1"
-                                                        Stroke="White"
-                                                        Width="20"
-                                                        Height="9"
-                                                        ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                                                        SnapsToDevicePixels="True" />
-                                          </Border>
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.9" />
-                                          </Trigger>
-                                          <Trigger Property="IsMouseCaptureWithin"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.8" />
-                                          </Trigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF3C7FB1" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource MouseOverThumbFillBackground}" />
-                                          </MultiDataTrigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF2C628B" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource PressedThumbFillBackground}" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FFD7D7D7" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF4F4F4" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD7D7D7" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-      </Grid>
-   </ControlTemplate>
-
    <!-- ********************** -->
    <!-- RangeSlider Style -->
    <!-- ********************** -->
    <Style TargetType="{x:Type local:RangeSlider}">
+      <Setter Property="IsTabStop"
+              Value="False" />
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type local:RangeSlider}">
-               <Grid>
-                  <Grid.RowDefinitions>
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto"
-                                    MinHeight="{TemplateBinding MinHeight}" />
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto" />
-                  </Grid.RowDefinitions>
-
-                  <!-- //#TODODOC 
+               <Border BorderBrush="{TemplateBinding BorderBrush}"
+                       BorderThickness="{TemplateBinding BorderThickness}"
+                       Background="{TemplateBinding Background}">
+                  <Grid HorizontalAlignment="Left"
+                        VerticalAlignment="Top">
+
+                     <!-- //#TODODOC 
                         Get Thumbs's width to set the good RangeSlider width.-->
                   <Grid.ColumnDefinitions>
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
+                     <!-- 11 is equal to the width of the horizontal slider thumb, (or the height of the vertical slider thumb)
+                     See Thumb template -->
+                     <ColumnDefinition Width="11" />
                      <ColumnDefinition Width="Auto" />
                      <ColumnDefinition Width="Auto" />
                      <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
+                     <ColumnDefinition Width="11" />
                   </Grid.ColumnDefinitions>
 
-                  <Border Grid.Row="1"
-                          Grid.Column="1"
-                          Grid.ColumnSpan="3"
-                          BorderThickness="1"
-                          BorderBrush="{StaticResource SliderBorderBrush}"
-                          Background="#FFE7EAEA"
-                          VerticalAlignment="Center"
-                          Height="4" />
-
-                  <RepeatButton x:Name="PART_LowerRange"
-                                Width="{TemplateBinding LowerRangeWidth}"
-                                Grid.Column="1"
-                                Grid.Row="1"
-                                Background="{TemplateBinding LowerRangeBackground}"
-                                Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <RepeatButton Width="{TemplateBinding RangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="2"
-                                Background="{TemplateBinding RangeBackground}"
-                                Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <RepeatButton x:Name="PART_HigherRange"
-                                Width="{TemplateBinding HigherRangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="3"
-                                Background="{TemplateBinding HigherRangeBackground}"
-                                Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
-                  <Slider x:Name="PART_LowerSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource LowerSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-
-                  <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-                  <Slider x:Name="PART_HigherSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource HigherSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-               </Grid>
+                     <Border Grid.Column="1"
+                             Grid.ColumnSpan="3"
+                             BorderThickness="1"
+                             BorderBrush="{StaticResource SliderBorderBrush}"
+                             Background="#FFE7EAEA"
+                             VerticalAlignment="Center"
+                             Height="4" />
+
+                     <RepeatButton x:Name="PART_LowerRange"
+                                      Width="{TemplateBinding LowerRangeWidth}"
+                                      Grid.Column="1"
+                                      Background="{TemplateBinding LowerRangeBackground}"
+                                      Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                      SnapsToDevicePixels="True" />
+
+                     <RepeatButton Width="{TemplateBinding RangeWidth}"
+                                   Grid.Column="2"
+                                   Background="{TemplateBinding RangeBackground}"
+                                   Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <RepeatButton x:Name="PART_HigherRange"
+                                      Width="{TemplateBinding HigherRangeWidth}"
+                                      Grid.Column="3"
+                                      Background="{TemplateBinding HigherRangeBackground}"
+                                      Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                      SnapsToDevicePixels="True" />
+
+                     <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
+                     <Slider x:Name="PART_LowerSlider"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding LowerThumbBackground}"
+                             Template="{StaticResource SliderTemplate}" />
+
+                     <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+                     <Slider x:Name="PART_HigherSlider"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding HigherThumbBackground}"
+                             Template="{StaticResource SliderTemplate}" />
+                  </Grid>
+               </Border>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs
index edc7de1f..5b8a9752 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs
@@ -79,18 +79,21 @@ namespace Xceed.Wpf.Toolkit
     {
       if( e.ChangedButton == MouseButton.Left && e.LeftButton == MouseButtonState.Released )
       {
-        TextRange selectedText = new TextRange( _richTextBox.Selection.Start, _richTextBox.Selection.End );
+        if( !_richTextBox.IsReadOnly )
+        {
+          TextRange selectedText = new TextRange( _richTextBox.Selection.Start, _richTextBox.Selection.End );
 #if !VS2008
-        if( selectedText.Text.Length > 0 && !String.IsNullOrWhiteSpace( selectedText.Text ) )
-          ShowAdorner();
+          if( selectedText.Text.Length > 0 && !String.IsNullOrWhiteSpace( selectedText.Text ) )
+            ShowAdorner();
 #else
-        if( selectedText.Text.Length > 0 && !String.IsNullOrEmpty( selectedText.Text ) )
-          ShowAdorner();
+          if( selectedText.Text.Length > 0 && !String.IsNullOrEmpty( selectedText.Text ) )
+            ShowAdorner();
 #endif
-        else
-          HideAdorner();
+          else
+            HideAdorner();
 
-        e.Handled = true;
+          e.Handled = true;
+        }
       }
       else
         HideAdorner();
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs
similarity index 92%
rename from ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs
rename to ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs
index 325edc66..5d2139ad 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs
@@ -24,7 +24,7 @@ using System.Windows;
 
 namespace Xceed.Wpf.Toolkit.Converters
 {
-  public class StylableWindowClippingBorderConverter : IValueConverter
+  public class StyleableWindowClippingBorderConverter : IValueConverter
   {
     public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
     {
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml
index ee4660dd..0d24459a 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml
@@ -40,7 +40,7 @@
 
     <!-- =============================================================================== -->
     <!-- Common Styles                                                                   -->
-    <!-- Need to find a way to share these for WindowControl and StylableWindow          -->
+   <!-- Need to find a way to share these for WindowControl and StyleableWindow          -->
     <!-- =============================================================================== -->
 
     <!-- ResizeGrip -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Generic/Common.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Generic/Common.xaml
index ea5c9283..fccab3ab 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Generic/Common.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Themes/Generic/Common.xaml
@@ -103,7 +103,7 @@
 
     <!-- =============================================================================== -->
     <!-- Common Styles                                                                   -->
-    <!-- Need to find a way to share these for WindowControl and StylableWindow          -->
+   <!-- Need to find a way to share these for WindowControl and StyleableWindow          -->
     <!-- =============================================================================== -->
 
     <!-- Button template -->
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs
index b84501bf..0a374652 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs
@@ -227,6 +227,53 @@ namespace Xceed.Wpf.Toolkit
 
     #endregion //IsOpen
 
+    #region Kind
+
+    public static readonly DependencyProperty KindProperty = DependencyProperty.Register( "Kind", typeof( DateTimeKind ), typeof( TimePicker ),
+      new FrameworkPropertyMetadata( DateTimeKind.Unspecified, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault ) );
+    public DateTimeKind Kind
+    {
+      get
+      {
+        return ( DateTimeKind )GetValue( KindProperty );
+      }
+      set
+      {
+        SetValue( KindProperty, value );
+      }
+    }
+
+    #endregion //Kind
+
+    #region MaxDropDownHeight
+
+    public static readonly DependencyProperty MaxDropDownHeightProperty = DependencyProperty.Register( "MaxDropDownHeight", typeof( double ), typeof( TimePicker ), new UIPropertyMetadata( 130d, OnMaxDropDownHeightChanged ) );
+    public double MaxDropDownHeight
+    {
+      get
+      {
+        return ( double )GetValue( MaxDropDownHeightProperty );
+      }
+      set
+      {
+        SetValue( MaxDropDownHeightProperty, value );
+      }
+    }
+
+    private static void OnMaxDropDownHeightChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    {
+      TimePicker timePicker = o as TimePicker;
+      if( timePicker != null )
+        timePicker.OnMaxDropDownHeightChanged( ( double )e.OldValue, ( double )e.NewValue );
+    }
+
+    protected virtual void OnMaxDropDownHeightChanged( double oldValue, double newValue )
+    {
+      // TODO: Add your property changed side-effects. Descendants can override as well.
+    }
+
+    #endregion
+
     #region Maximum
 
     public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register( "Maximum", typeof( DateTime? ), typeof( TimePicker ), new UIPropertyMetadata( DateTime.MaxValue ) );
@@ -554,9 +601,9 @@ namespace Xceed.Wpf.Toolkit
       {
         TimeItem selectedTimeListItem = ( TimeItem )e.AddedItems[ 0 ];
         var time = selectedTimeListItem.Time;
-        var date = Value ?? DateTime.MinValue;
+        var date = Value ?? DateTimeUtilities.GetContextNow( this.Kind );
 
-        Value = new DateTime( date.Year, date.Month, date.Day, time.Hours, time.Minutes, time.Seconds, time.Milliseconds );
+        Value = new DateTime( date.Year, date.Month, date.Day, time.Hours, time.Minutes, time.Seconds, time.Milliseconds, date.Kind );
       }
     }
 
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml
index 0e1c2a54..8fc0ffb3 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml
@@ -141,6 +141,7 @@
                                               Format="{TemplateBinding Format, Converter={StaticResource TimeFormatToDateTimeFormatConverter}}"
                                               FormatString="{TemplateBinding FormatString}"
                                               ShowButtonSpinner="{TemplateBinding ShowButtonSpinner}"
+                                              Kind="{Binding Kind, RelativeSource={RelativeSource TemplatedParent}}"
                                               Value="{Binding Value, RelativeSource={RelativeSource TemplatedParent}}"
                                               Minimum="{Binding Minimum, RelativeSource={RelativeSource TemplatedParent}}"
                                               Maximum="{Binding Maximum, RelativeSource={RelativeSource TemplatedParent}}"
@@ -163,7 +164,7 @@
                                         <ListBox x:Name="PART_TimeListItems"
                                        BorderThickness="0"
                                        Width="150"
-                                       Height="130"
+                                       Height="{TemplateBinding MaxDropDownHeight}"
                                        DisplayMemberPath="Display"
                                        ItemContainerStyle="{StaticResource TimeItemStyle}" />
                                     </Grid>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml
index e783d03c..354ebd05 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml
@@ -134,6 +134,7 @@
                                               Format="{TemplateBinding Format, Converter={StaticResource TimeFormatToDateTimeFormatConverter}}"
                                               FormatString="{TemplateBinding FormatString}"
                                               ShowButtonSpinner="{TemplateBinding ShowButtonSpinner}"
+                                              Kind="{Binding Kind, RelativeSource={RelativeSource TemplatedParent}}"
                                               Value="{Binding Value, RelativeSource={RelativeSource TemplatedParent}}"
                                               Minimum="{Binding Minimum, RelativeSource={RelativeSource TemplatedParent}}"
                                               Maximum="{Binding Maximum, RelativeSource={RelativeSource TemplatedParent}}"
@@ -156,7 +157,7 @@
                               <ListBox x:Name="PART_TimeListItems"
                                        BorderThickness="0"
                                        Width="150"
-                                       Height="130"
+                                       Height="{TemplateBinding MaxDropDownHeight}"
                                        DisplayMemberPath="Display"
                                        ItemContainerStyle="{StaticResource TimeItemStyle}" />
                            </Grid>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml
index b0a95844..0018f640 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml
@@ -70,7 +70,6 @@
                                                 FontWeight="{TemplateBinding FontWeight}"
                                                 Foreground="{TemplateBinding Foreground}"
                                                 HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                                IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                                 MinWidth="20"
                                                 AcceptsReturn="False"
                                                 Padding="{TemplateBinding Padding}"
@@ -87,7 +86,24 @@
                             <Setter Property="BorderBrush"
                                     Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
                         </Trigger>
-                        <Trigger Property="IsKeyboardFocusWithin"
+                     <MultiDataTrigger>
+                        <MultiDataTrigger.Conditions>
+                           <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                           <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                        </MultiDataTrigger.Conditions>
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </MultiDataTrigger>
+                     <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                  Value="True">
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </DataTrigger>
+                     <Trigger Property="IsKeyboardFocusWithin"
                                  Value="True">
                             <Setter Property="BorderBrush"
                                     Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml
index 4a8a3cb7..14644f9f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml
@@ -69,7 +69,6 @@
                                                 FontWeight="{TemplateBinding FontWeight}"
                                                 Foreground="{TemplateBinding Foreground}"
                                                 HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                                IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                                 MinWidth="20"
                                                 AcceptsReturn="False"
                                                 Padding="{TemplateBinding Padding}"
@@ -81,6 +80,23 @@
                                                 WatermarkTemplate="{TemplateBinding WatermarkTemplate}" />
                     </local:ButtonSpinner>
                     <ControlTemplate.Triggers>
+                        <MultiDataTrigger>
+                           <MultiDataTrigger.Conditions>
+                              <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                         Value="False" />
+                              <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                         Value="False" />
+                           </MultiDataTrigger.Conditions>
+                           <Setter Property="IsReadOnly"
+                                   Value="True"
+                                   TargetName="PART_TextBox" />
+                        </MultiDataTrigger>
+                        <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                     Value="True">
+                           <Setter Property="IsReadOnly"
+                                   Value="True"
+                                   TargetName="PART_TextBox" />
+                        </DataTrigger>
                         <Trigger Property="IsFocused"
                                  Value="True">
                             <Setter TargetName="PART_TextBox"
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs
index a852fbd2..31735a9d 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs
@@ -15,6 +15,7 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Specialized;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
@@ -331,6 +332,17 @@ namespace Xceed.Wpf.Toolkit
         CurrentPage = Items[ 0 ] as WizardPage;
     }
 
+    protected override void OnItemsChanged( NotifyCollectionChangedEventArgs e )
+    {
+      base.OnItemsChanged( e );
+
+      foreach( object o in this.Items )
+      {
+        if( !( o is WizardPage ) )
+          throw new NotSupportedException( "Wizard should only contains WizardPages." );
+      }
+    }
+
     protected override void OnPropertyChanged( DependencyPropertyChangedEventArgs e )
     {
       base.OnPropertyChanged( e );
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj
index b581838c..882a9a2f 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj
@@ -404,6 +404,8 @@
     <Compile Include="Core\Converters\CornerRadiusToDoubleConverter.cs" />
     <Compile Include="Core\Converters\IntToThicknessConverter.cs" />
     <Compile Include="Core\Converters\ThicknessToDoubleConverter.cs" />
+    <Compile Include="Core\Utilities\DateTimeUtilities.cs" />
+    <Compile Include="PropertyGrid\Implementation\Converters\IsStringEmptyConverter.cs" />
     <Compile Include="PropertyGrid\Implementation\Editors\CollectionEditor.cs" />
     <Compile Include="Core\Converters\WindowContentBorderMarginConverter.cs" />
     <Compile Include="Core\Converters\WindowControlBackgroundConverter.cs" />
@@ -606,7 +608,7 @@
     <Compile Include="Core\Primitives\UpDownBase.cs" />
     <Compile Include="SplitButton\Implementation\SplitButton.cs" />
     <Compile Include="Core\Themes\ResourceKeys.cs" />
-    <Compile Include="StylableWindow\Implementation\Converters\StylableWindowClippingBorderConverter.cs" />
+    <Compile Include="StyleableWindow\Implementation\Converters\StyleableWindowClippingBorderConverter.cs" />
     <Compile Include="TimelinePanel\Implementation\DateElement.cs" />
     <Compile Include="TimelinePanel\Implementation\OverlapBehavior.cs" />
     <Compile Include="TimelinePanel\Implementation\TimelinePanel.cs" />
@@ -746,7 +748,6 @@
   <ItemGroup>
     <Compile Include="PropertyGrid\Implementation\Definitions\DefinitionBase.cs" />
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml
index a3a78c96..ecf3da20 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml
@@ -333,7 +333,7 @@
 
     <Style x:Key="{x:Type local:Zoombox}" TargetType="{x:Type local:Zoombox}">
         <Setter Property="Background" Value="Transparent" />
-        <Setter Property="Foreground" Value="White" />
+        <Setter Property="Foreground" Value="Black" />
         <Setter Property="PanDistance" Value="5.0" />
         <Setter Property="ZoomOrigin" Value="0.5,0.5" />
         <Setter Property="ZoomPercentage" Value="5.0" />
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml
index 0ebb9057..adfd6c01 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml
@@ -333,7 +333,7 @@
 
    <Style x:Key="{x:Type local:Zoombox}" TargetType="{x:Type local:Zoombox}">
       <Setter Property="Background" Value="Transparent" />
-      <Setter Property="Foreground" Value="White" />
+      <Setter Property="Foreground" Value="Black" />
       <Setter Property="PanDistance" Value="5.0" />
       <Setter Property="ZoomOrigin" Value="0.5,0.5" />
       <Setter Property="ZoomPercentage" Value="5.0" />
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs
index 2ae3cbdb..7fb02dc8 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs
+++ b/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs
@@ -1907,10 +1907,11 @@ namespace Xceed.Wpf.Toolkit.Zoombox
       if( _content != null )
       {
         // measure visuals according to supplied constraint
-        base.MeasureOverride( constraint );
+        Size size = base.MeasureOverride( constraint );
 
         // now re-measure content to let the child be whatever size it desires
         _content.Measure( new Size( double.PositiveInfinity, double.PositiveInfinity ) );
+        return size;
       }
 
 
@@ -3342,7 +3343,7 @@ namespace Xceed.Wpf.Toolkit.Zoombox
         // adjust translateFrom based on relativeTo
         translateFrom = this.TranslatePoint( relativeTo, _contentPresenter );
       }
-      else
+      else if( _contentPresenter != null )
       {
         // prior to the first render, just use the ContentPresenter's transform and do not adjust translateFrom
         if( _contentPresenter.RenderTransform == Transform.Identity )
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs
index ce1db48a..693b6601 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/AssemblyVersionInfo.cs
@@ -21,7 +21,7 @@
 internal static class _XceedVersionInfo
 {
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
-  public const string BaseVersion = "2.3";
+  public const string BaseVersion = "2.4";
   [System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields" )]
   public const string Version = BaseVersion + 
   ".0.0";
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs
index 0ea459b7..330b8d8f 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Implementation/ButtonSpinner.cs
@@ -21,6 +21,12 @@ using System.Windows.Markup;
 
 namespace Xceed.Wpf.Toolkit
 {
+  public enum Location
+  {
+    Left,
+    Right
+  }
+
   /// <summary>
   /// Represents a spinner control that includes two Buttons.
   /// </summary>
@@ -57,6 +63,23 @@ namespace Xceed.Wpf.Toolkit
 
     #endregion //AllowSpin
 
+    #region ButtonSpinnerLocation
+
+    public static readonly DependencyProperty ButtonSpinnerLocationProperty = DependencyProperty.Register( "ButtonSpinnerLocation", typeof( Location ), typeof( ButtonSpinner ), new UIPropertyMetadata( Location.Right ) );
+    public Location ButtonSpinnerLocation
+    {
+      get
+      {
+        return ( Location )GetValue( ButtonSpinnerLocationProperty );
+      }
+      set
+      {
+        SetValue( ButtonSpinnerLocationProperty, value );
+      }
+    }
+
+    #endregion //ButtonSpinnerLocation
+
     #region Content
 
     /// <summary>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml
index a16663a6..2497238d 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Aero2.NormalColor.xaml
@@ -46,12 +46,12 @@
                     <Border x:Name="Border" SnapsToDevicePixels="True" Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" >
                         <Grid>
                             <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="*" />
-                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition x:Name="firstContentColumn" Width="*" />
+                                <ColumnDefinition x:Name="secondContentColumn" Width="Auto" />
                             </Grid.ColumnDefinitions>
-                            <ContentPresenter Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
+                            <ContentPresenter x:Name="contentPresenter" Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                            <Grid Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
+                            <Grid x:Name="gridContent" Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
                                 <Grid.RowDefinitions>
                                     <RowDefinition Height="*" />
                                     <RowDefinition Height="*" />
@@ -85,7 +85,22 @@
                         <Trigger SourceName="PART_DecreaseButton" Property="IsEnabled" Value="False">
                             <Setter TargetName="PART_DecreaseButton" Property="ContentTemplate" Value="{StaticResource DecreaseGlyphDisabledKey}" />
                         </Trigger>
-                    </ControlTemplate.Triggers>
+                        <Trigger Property="ButtonSpinnerLocation"
+                                 Value="Left">
+                           <Setter TargetName="firstContentColumn"
+                                   Property="Width"
+                                   Value="Auto" />
+                           <Setter TargetName="secondContentColumn"
+                                   Property="Width"
+                                   Value="*" />
+                           <Setter TargetName="contentPresenter"
+                                   Property="Grid.Column"
+                                   Value="1" />
+                           <Setter TargetName="gridContent"
+                                   Property="Grid.Column"
+                                   Value="0" />
+                        </Trigger>
+                     </ControlTemplate.Triggers>
                 </ControlTemplate>
             </Setter.Value>
         </Setter>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml
index 91d1fb13..72c4f0c5 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ButtonSpinner/Themes/Generic.xaml
@@ -44,12 +44,12 @@
                <Border x:Name="Border" SnapsToDevicePixels="True" Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" >
                   <Grid>
                      <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="*" />
-                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition x:Name="firstContentColumn" Width="*" />
+                        <ColumnDefinition x:Name="secondContentColumn" Width="Auto" />
                      </Grid.ColumnDefinitions>
-                     <ContentPresenter Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
+                     <ContentPresenter x:Name="contentPresenter" Focusable="False" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
 
-                     <Grid Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
+                     <Grid x:Name="gridContent" Grid.Column="1" Visibility="{TemplateBinding ShowButtonSpinner, Converter={StaticResource BooleanToVisibilityConverter}}" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
                         <Grid.RowDefinitions>
                            <RowDefinition Height="*" />
                            <RowDefinition Height="*" />
@@ -77,6 +77,21 @@
                   <Trigger SourceName="PART_DecreaseButton" Property="IsEnabled" Value="False">
                      <Setter TargetName="PART_DecreaseButton" Property="ContentTemplate" Value="{StaticResource DecreaseGlyphDisabledKey}" />
                   </Trigger>
+                  <Trigger Property="ButtonSpinnerLocation"
+                           Value="Left">
+                     <Setter TargetName="firstContentColumn"
+                             Property="Width"
+                             Value="Auto" />
+                     <Setter TargetName="secondContentColumn"
+                             Property="Width"
+                             Value="*" />
+                     <Setter TargetName="contentPresenter"
+                             Property="Grid.Column"
+                             Value="1" />
+                     <Setter TargetName="gridContent"
+                             Property="Grid.Column"
+                             Value="0" />
+                  </Trigger>
                </ControlTemplate.Triggers>
             </ControlTemplate>
          </Setter.Value>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs
index 20907e41..eb0a4876 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControl.cs
@@ -23,17 +23,21 @@ using System.Reflection;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
+using Xceed.Wpf.Toolkit.PropertyGrid;
 
 namespace Xceed.Wpf.Toolkit
 {
   [TemplatePart( Name = PART_NewItemTypesComboBox, Type = typeof( ComboBox ) )]
+  [TemplatePart( Name = PART_PropertyGrid, Type = typeof( PropertyGrid.PropertyGrid ) )]
   public class CollectionControl : Control
   {
     private const string PART_NewItemTypesComboBox = "PART_NewItemTypesComboBox";
+    private const string PART_PropertyGrid = "PART_PropertyGrid";
 
     #region Private Members
 
     private ComboBox _newItemTypesComboBox;
+    private PropertyGrid.PropertyGrid _propertyGrid;
 
     #endregion
 
@@ -177,6 +181,20 @@ namespace Xceed.Wpf.Toolkit
 
       if( _newItemTypesComboBox != null )
         _newItemTypesComboBox.Loaded += new RoutedEventHandler( this.NewItemTypesComboBox_Loaded );
+
+      _propertyGrid = GetTemplateChild( PART_PropertyGrid ) as PropertyGrid.PropertyGrid;
+    }
+
+    public PropertyGrid.PropertyGrid PropertyGrid
+    {
+      get
+      {
+        if( _propertyGrid == null )
+        {
+          this.ApplyTemplate();
+        }
+        return _propertyGrid;
+      }
     }
 
     #endregion
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml
index 76e3a691..6dfcf1ca 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml
@@ -29,7 +29,7 @@
          <RowDefinition Height="Auto" />
       </Grid.RowDefinitions>
 
-      <local:CollectionControl x:Name="_propertyGrid"
+      <local:CollectionControl x:Name="_collectionControl"
                               ItemsSourceType="{Binding ItemsSourceType, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"
                               ItemsSource="{Binding ItemsSource, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}, Mode=TwoWay}"
                               NewItemTypes="{Binding NewItemTypes, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs
index ef3f803a..ddea5371 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Implementation/CollectionControlDialog.xaml.cs
@@ -80,6 +80,14 @@ namespace Xceed.Wpf.Toolkit
       }
     }
 
+    public CollectionControl CollectionControl
+    {
+      get
+      {
+        return _collectionControl;
+      }
+    }
+
     #endregion //Properties
 
     #region Constructors
@@ -107,7 +115,7 @@ namespace Xceed.Wpf.Toolkit
 
     private void OkButton_Click( object sender, RoutedEventArgs e )
     {
-      _propertyGrid.PersistChanges();
+      _collectionControl.PersistChanges();
       this.DialogResult = true;
       Close();
     }
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml
index 85272fb1..5bf7d60b 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Aero2.NormalColor.xaml
@@ -124,13 +124,14 @@
                                     <RowDefinition />
                                 </Grid.RowDefinitions>
                                 <TextBlock Grid.Column="1" Text="Properties:" />
-                                <pg:PropertyGrid Grid.Row="1"
-                                         Grid.Column="1"
-                                         Margin="0,5,0,0"
-                                         HorizontalAlignment="Stretch"
-                                         VerticalAlignment="Stretch"
-                                         SelectedObject="{Binding SelectedItem, RelativeSource={RelativeSource TemplatedParent}}"
-                                         IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}" />
+                                <pg:PropertyGrid x:Name="PART_PropertyGrid"
+                                                 Grid.Row="1"
+                                                 Grid.Column="1"
+                                                 Margin="0,5,0,0"
+                                                 HorizontalAlignment="Stretch"
+                                                 VerticalAlignment="Stretch"
+                                                 SelectedObject="{Binding SelectedItem, RelativeSource={RelativeSource TemplatedParent}}"
+                                                 IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}" />
                             </Grid>
                         </Grid>
                     </Border>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml
index e64b51c4..46756d4e 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/CollectionControl/Themes/Generic.xaml
@@ -123,7 +123,8 @@
                            <RowDefinition />
                         </Grid.RowDefinitions>
                         <TextBlock Grid.Column="1" Text="Properties:" />
-                        <pg:PropertyGrid Grid.Row="1"
+                        <pg:PropertyGrid x:Name="PART_PropertyGrid"
+                                         Grid.Row="1"
                                          Grid.Column="1"
                                          Margin="0,5,0,0"
                                          HorizontalAlignment="Stretch"
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs
index 0417d9b7..a2bc0f33 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorCanvas/Implementation/ColorCanvas.cs
@@ -385,6 +385,8 @@ namespace Xceed.Wpf.Toolkit
       Point p = e.GetPosition( _colorShadingCanvas );
       UpdateColorShadeSelectorPositionAndCalculateColor( p, true );
       _colorShadingCanvas.CaptureMouse();
+      //Prevent from closing ColorCanvas after mouseDown in ListView
+      e.Handled = true; 
     }
 
     void ColorShadingCanvas_MouseLeftButtonUp( object sender, MouseButtonEventArgs e )
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml
index e51ac830..35a5aafc 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Aero2.NormalColor.xaml
@@ -117,6 +117,7 @@
     </Style>
 
      <Style x:Key="ColorDisplayStyle" TargetType="ContentControl">
+      <Setter Property="Focusable" Value="False" />
       <Setter Property="ContentTemplate">
          <Setter.Value>
             <DataTemplate>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml
index e4ef913c..93a2d404 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/ColorPicker/Themes/Generic.xaml
@@ -142,6 +142,8 @@
    </Style>
 
    <Style x:Key="ColorDisplayStyle" TargetType="ContentControl">
+      <Setter Property="Focusable"
+              Value="False" />
       <Setter Property="ContentTemplate">
          <Setter.Value>
             <DataTemplate>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs
index d8d3e00d..44be449d 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/InputBase.cs
@@ -26,6 +26,34 @@ namespace Xceed.Wpf.Toolkit.Primitives
   {
     #region Properties
 
+    #region AllowTextInput
+
+    public static readonly DependencyProperty AllowTextInputProperty = DependencyProperty.Register( "AllowTextInput", typeof( bool ), typeof( InputBase ), new UIPropertyMetadata( true, OnAllowTextInputChanged ) );
+    public bool AllowTextInput
+    {
+      get
+      {
+        return ( bool )GetValue( AllowTextInputProperty );
+      }
+      set
+      {
+        SetValue( AllowTextInputProperty, value );
+      }
+    }
+
+    private static void OnAllowTextInputChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    {
+      InputBase inputBase = o as InputBase;
+      if( inputBase != null )
+        inputBase.OnAllowTextInputChanged( ( bool )e.OldValue, ( bool )e.NewValue );
+    }
+
+    protected virtual void OnAllowTextInputChanged( bool oldValue, bool newValue )
+    {
+    }
+
+    #endregion //AllowTextInput
+
     #region CultureInfo
 
     public static readonly DependencyProperty CultureInfoProperty = DependencyProperty.Register( "CultureInfo", typeof( CultureInfo ), typeof( InputBase ), new UIPropertyMetadata( CultureInfo.CurrentCulture, OnCultureInfoChanged ) );
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs
index d4ef3b0a..11f25f99 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/Selector.cs
@@ -420,16 +420,27 @@ namespace Xceed.Wpf.Toolkit.Primitives
 
     #region Methods
 
-    protected object GetItemValue( object item )
+    protected object GetPathValue( object item, string propertyPath )
     {
-      if( !String.IsNullOrEmpty( ValueMemberPath ) && ( item != null ) )
-      {
-        var property = item.GetType().GetProperty( ValueMemberPath );
-        if( property != null )
-          return property.GetValue( item, null );
-      }
+      if( item == null )
+        throw new ArgumentNullException( "item" );
 
-      return item;
+      if( String.IsNullOrEmpty( propertyPath )
+        || propertyPath == "." )
+        return item;
+
+
+      PropertyInfo prop = item.GetType().GetProperty( propertyPath );
+      return ( prop != null )
+        ? prop.GetValue( item, null )
+        : null;
+    }
+
+    protected object GetItemValue( object item )
+    {
+      return ( item != null )
+        ? this.GetPathValue( item, this.ValueMemberPath )
+        : null;
     }
 
     protected object ResolveItemByValue( string value )
@@ -490,7 +501,7 @@ namespace Xceed.Wpf.Toolkit.Primitives
     /// </summary>
     /// <param name="sender"></param>
     /// <param name="e"></param>
-    private void OnSelectedItemsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
+    protected virtual void OnSelectedItemsCollectionChanged( object sender, NotifyCollectionChangedEventArgs e )
     {
       if( _ignoreSelectedItemsCollectionChanged > 0 )
         return;
@@ -646,6 +657,26 @@ namespace Xceed.Wpf.Toolkit.Primitives
       this.UpdateFromSelectedItems();
     }
 
+    internal void UpdateSelectedItems( IList selectedItems )
+    {
+      if( selectedItems == null )
+        throw new ArgumentNullException( "selectedItems" );
+
+      // Just check if the collection is the same..
+      if( selectedItems.Count == this.SelectedItems.Count
+        && selectedItems.Cast<object>().SequenceEqual( this.SelectedItems.Cast<object>() ) )
+        return;
+
+      _ignoreSelectedItemsCollectionChanged++;
+      this.SelectedItems.Clear();
+      foreach( object newItem in selectedItems )
+      {
+        this.SelectedItems.Add( newItem );
+      }
+      _ignoreSelectedItemsCollectionChanged--;
+      this.UpdateFromSelectedItems();
+    }
+
     /// <summary>
     /// Updates the following based on the content of SelectedItems:
     /// - All SelectorItems "IsSelected" properties
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs
index a3a57c09..6a40ca41 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Primitives/UpDownBase.cs
@@ -49,6 +49,8 @@ namespace Xceed.Wpf.Toolkit.Primitives
     private bool _isSyncingTextAndValueProperties;    
     private bool _isSpinnerCaptured;
 
+    private bool _internalValueSet;
+
     #endregion //Members
 
     #region Properties
@@ -81,6 +83,23 @@ namespace Xceed.Wpf.Toolkit.Primitives
 
     #endregion //AllowSpin
 
+    #region ButtonSpinnerLocation
+
+    public static readonly DependencyProperty ButtonSpinnerLocationProperty = DependencyProperty.Register( "ButtonSpinnerLocation", typeof( Location ), typeof( UpDownBase<T> ), new UIPropertyMetadata( Location.Right ) );
+    public Location ButtonSpinnerLocation
+    {
+      get
+      {
+        return ( Location )GetValue( ButtonSpinnerLocationProperty );
+      }
+      set
+      {
+        SetValue( ButtonSpinnerLocationProperty, value );
+      }
+    }
+
+    #endregion //ButtonSpinnerLocation
+
     #region ClipValueToMinMax
 
     public static readonly DependencyProperty ClipValueToMinMaxProperty = DependencyProperty.Register( "ClipValueToMinMax", typeof( bool ), typeof( UpDownBase<T> ), new UIPropertyMetadata( false ) );
@@ -122,7 +141,7 @@ namespace Xceed.Wpf.Toolkit.Primitives
     {
       if( this.IsInitialized && string.IsNullOrEmpty( Text ))
       {
-        this.SyncTextAndValueProperties( true, Text );
+        this.SyncTextAndValueProperties( false, Text );
       }
     }
 
@@ -339,6 +358,19 @@ namespace Xceed.Wpf.Toolkit.Primitives
       }
     }
 
+    private void SetValueInternal( T value )
+    {
+      _internalValueSet = true;
+      try
+      {
+        this.Value = value;
+      }
+      finally
+      {
+        _internalValueSet = false;
+      }
+    }
+
     private static object OnCoerceValue( DependencyObject o, object basevalue )
     {
       return ( ( UpDownBase<T> )o ).OnCoerceValue( basevalue );
@@ -358,9 +390,9 @@ namespace Xceed.Wpf.Toolkit.Primitives
 
     protected virtual void OnValueChanged( T oldValue, T newValue )
     {
-      if( this.IsInitialized )
+      if( !_internalValueSet && this.IsInitialized )
       {
-        SyncTextAndValueProperties( false, null );
+        SyncTextAndValueProperties( false, null, true );
       }
 
       SetValidSpinDirection();
@@ -630,13 +662,17 @@ namespace Xceed.Wpf.Toolkit.Primitives
           if( string.IsNullOrEmpty( text ) )
           {
             // An empty input sets the value to the default value.
-            Value = this.DefaultValue;
+            this.SetValueInternal( this.DefaultValue );
           }
           else
           {
             try
             {
-              Value = this.ConvertTextToValue( text );
+              T newValue = this.ConvertTextToValue( text );
+              if( !object.Equals( newValue, this.Value ) )
+              {
+                this.SetValueInternal( newValue );
+              }
             }
             catch( Exception e )
             {
@@ -660,7 +696,11 @@ namespace Xceed.Wpf.Toolkit.Primitives
           bool shouldKeepEmpty = !forceTextUpdate && string.IsNullOrEmpty( Text ) && object.Equals( Value, DefaultValue ) && !this.DisplayDefaultValueOnEmptyText;
           if(  !shouldKeepEmpty )
           {
-            Text = ConvertValueToText();
+            string newText = ConvertValueToText();
+            if( !object.Equals( this.Text, newText ) )
+            {
+              Text = newText;
+            }
           }
 
           // Sync Text and textBox
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs
new file mode 100644
index 00000000..bf896adb
--- /dev/null
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Core/Utilities/DateTimeUtilities.cs
@@ -0,0 +1,36 @@
+/*************************************************************************************
+
+   Extended WPF Toolkit
+
+   Copyright (C) 2007-2013 Xceed Software Inc.
+
+   This program is provided to you under the terms of the Microsoft Public
+   License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license 
+
+   For more features, controls, and fast professional support,
+   pick up the Plus Edition at http://xceed.com/wpf_toolkit
+
+   Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
+
+  ***********************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Xceed.Wpf.Toolkit.Core.Utilities
+{
+  internal static class DateTimeUtilities
+  {
+    public static DateTime GetContextNow( DateTimeKind kind )
+    {
+      if( kind == DateTimeKind.Unspecified )
+        return DateTime.SpecifyKind( DateTime.Now, DateTimeKind.Unspecified );
+
+      return ( kind == DateTimeKind.Utc )
+        ? DateTime.UtcNow
+        : DateTime.Now;
+    }
+  }
+}
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs
index cc2a2a7a..e0f5fa4a 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimePicker/Implementation/DateTimePicker.cs
@@ -258,7 +258,7 @@ namespace Xceed.Wpf.Toolkit
       {
         _calendar.SelectedDatesChanged += Calendar_SelectedDatesChanged;
         _calendar.SelectedDate = Value ?? null;
-        _calendar.DisplayDate = Value ?? DateTime.Now;
+        _calendar.DisplayDate = Value ?? this.ContextNow;
         this.SetBlackOutDates();
       }
 
@@ -281,9 +281,15 @@ namespace Xceed.Wpf.Toolkit
 
     protected override void OnValueChanged( DateTime? oldValue, DateTime? newValue )
     {
-      if( (_calendar != null) && (_calendar.SelectedDate != newValue) )
+      //The calendar only select the Date part, not the time part.
+      DateTime? newValueDate = (newValue != null) 
+        ? newValue.Value.Date 
+        : (DateTime?)null;
+
+      if( _calendar != null && _calendar.SelectedDate != newValueDate)
       {
-        _calendar.SelectedDate = newValue;
+        _calendar.SelectedDate = newValueDate;
+        _calendar.DisplayDate = newValue.GetValueOrDefault( this.ContextNow );
       }
 
       base.OnValueChanged( oldValue, newValue );
@@ -357,8 +363,16 @@ namespace Xceed.Wpf.Toolkit
       {
         var newDate = ( DateTime? )e.AddedItems[ 0 ];
 
-        if( ( Value != null ) && ( newDate != null ) && newDate.HasValue )
+        //The Calendar will always return a date with an "Unspecified" Kind.
+        //Force the expected kind to the value.
+        if( newDate != null )
         {
+          newDate = DateTime.SpecifyKind( newDate.Value, this.Kind );
+        }
+
+        if( ( Value != null ) && ( newDate != null ) )
+        {
+
           // Only change the year, month, and day part of the value. Keep everything to the last "tick."
           // "Milliseconds" aren't precise enough. Use a mathematical scheme instead.
           newDate = newDate.Value.Date + Value.Value.TimeOfDay;
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs
index 7efed265..b8fac171 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeParser.cs
@@ -55,6 +55,15 @@ namespace Xceed.Wpf.Toolkit
       var dateTimeParts = dateTime.Split( dateTimeSeparators, StringSplitOptions.RemoveEmptyEntries ).ToList();
       var formats = format.Split( dateTimeSeparators, StringSplitOptions.RemoveEmptyEntries ).ToList();
 
+      //Auto-complete missing date parts
+      if( dateTimeParts.Count < formats.Count )
+      {
+        while( dateTimeParts.Count != formats.Count  )
+        {
+          dateTimeParts.Add( "0" );
+        }
+      }
+
       //something went wrong
       if( dateTimeParts.Count != formats.Count )
         return string.Empty;
@@ -65,12 +74,12 @@ namespace Xceed.Wpf.Toolkit
         if( !f.Contains( "ddd" ) && !f.Contains( "GMT" ) )
         {
           if( f.Contains( "M" ) )
-            dateParts[ "Month" ] = dateTimeParts[ i ];
+            dateParts[ "Month" ] = dateTimeParts[ i ] != "0" ? dateTimeParts[ i ] : "1";
           else if( f.Contains( "d" ) )
-            dateParts[ "Day" ] = dateTimeParts[ i ];
+            dateParts[ "Day" ] = dateTimeParts[ i ] != "0" ? dateTimeParts[ i ] : "1";
           else if( f.Contains( "y" ) )
           {
-            dateParts[ "Year" ] = dateTimeParts[ i ];
+            dateParts[ "Year" ] = dateTimeParts[ i ] != "0" ? dateTimeParts[ i ] : "0001";
 
             if( dateParts[ "Year" ].Length == 2 )
               dateParts[ "Year" ] = string.Format( "{0}{1}", currentDate.Year / 100, dateParts[ "Year" ] );
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs
index 8662fb0e..a28cba5a 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Implementation/DateTimeUpDown.cs
@@ -24,6 +24,7 @@ using Xceed.Wpf.Toolkit.Primitives;
 using System.Windows.Controls;
 using System.Linq;
 using Xceed.Wpf.Toolkit.Core.Primitives;
+using Xceed.Wpf.Toolkit.Core.Utilities;
 
 namespace Xceed.Wpf.Toolkit
 {
@@ -31,7 +32,8 @@ namespace Xceed.Wpf.Toolkit
   {
     #region Members
 
-    private DateTime? _lastValidDate;
+    private DateTime? _lastValidDate; //null
+    private bool _setKindInternal = false;
 
     #endregion
 
@@ -110,6 +112,75 @@ namespace Xceed.Wpf.Toolkit
 
     #endregion //FormatString
 
+    #region Kind
+
+    public static readonly DependencyProperty KindProperty = DependencyProperty.Register( "Kind", typeof( DateTimeKind ), typeof( DateTimeUpDown ), 
+      new FrameworkPropertyMetadata( DateTimeKind.Unspecified, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnKindChanged ) );
+    public DateTimeKind Kind
+    {
+      get
+      {
+        return ( DateTimeKind )GetValue( KindProperty );
+      }
+      set
+      {
+        SetValue( KindProperty, value );
+      }
+    }
+
+    private static void OnKindChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    {
+      DateTimeUpDown dateTimeUpDown = o as DateTimeUpDown;
+      if( dateTimeUpDown != null )
+        dateTimeUpDown.OnKindChanged( ( DateTimeKind )e.OldValue, ( DateTimeKind )e.NewValue );
+    }
+
+    protected virtual void OnKindChanged( DateTimeKind oldValue, DateTimeKind newValue )
+    {
+      //Upate the value based on kind. (Postpone to EndInit if not yet initialized)
+      if( !_setKindInternal
+        && this.Value != null 
+        && this.IsInitialized )
+      {
+        this.Value = this.ConvertToKind( this.Value.Value, newValue );
+      }
+    }
+
+    private void SetKindInternal( DateTimeKind kind )
+    {
+      _setKindInternal = true;
+      try
+      {
+#if VS2008
+        // Warning : Binding could be lost
+        this.Kind = kind;
+#else
+        //We use SetCurrentValue to not erase the possible underlying 
+        //OneWay Binding. (This will also update correctly any
+        //possible TwoWay bindings).
+        this.SetCurrentValue( DateTimeUpDown.KindProperty, kind );
+#endif
+      }
+      finally
+      {
+        _setKindInternal = false;
+      }
+    }
+
+    #endregion //Kind
+
+    #region ContextNow (Private)
+
+    internal DateTime ContextNow
+    {
+      get
+      {
+        return DateTimeUtilities.GetContextNow( this.Kind );
+      }
+    }
+
+    #endregion
+
     #endregion //Properties
 
     #region Constructors
@@ -148,7 +219,7 @@ namespace Xceed.Wpf.Toolkit
         if( Value.HasValue )
           UpdateDateTime( 1 );
         else
-          Value = DefaultValue ?? DateTime.Now;
+          Value = DefaultValue ?? this.ContextNow;
       }
     }
 
@@ -159,7 +230,7 @@ namespace Xceed.Wpf.Toolkit
         if( Value.HasValue )
           UpdateDateTime( -1 );
         else
-          Value = DefaultValue ?? DateTime.Now;
+          Value = DefaultValue ?? this.ContextNow;
       }
     }
 
@@ -179,6 +250,21 @@ namespace Xceed.Wpf.Toolkit
       DateTime result;
       this.TryParseDateTime( text, out result );
 
+      //Do not force "unspecified" to a time-zone specific
+      //parsed text value. This would result in a lost of precision and
+      //corrupt data. Let the value impose the Kind to the
+      //DateTimePicker. 
+      if( this.Kind != DateTimeKind.Unspecified )
+      {
+
+        //Keep the current kind (Local or Utc) 
+        //by imposing it to the parsed text value.
+        //
+        //Note: A parsed UTC text value may be
+        //      adjusted with a Local kind and time.
+        result = this.ConvertToKind( result, this.Kind );
+      }
+
       if( this.ClipValueToMinMax )
       {
         return this.GetClippedMinMaxValue( result );
@@ -214,10 +300,28 @@ namespace Xceed.Wpf.Toolkit
         this.Spinner.ValidSpinDirection = validDirections;
     }
 
+    protected override object OnCoerceValue( object newValue )
+    {
+      //Since only changing the "kind" of a date
+      //Ex. "2001-01-01 12:00 AM, Kind=Utc" to "2001-01-01 12:00 AM Kind=Local"
+      //by setting the "Value" property won't trigger a property changed,
+      //but will call this callback (coerce), we update the Kind here.
+      DateTime? value = ( DateTime? )base.OnCoerceValue( newValue );
+
+      //Let the initialized determine the final "kind" value.
+      if(value != null && this.IsInitialized)
+      {
+        //Update kind based on value kind
+        this.SetKindInternal( value.Value.Kind );
+      }
+
+      return value;
+    }
+
     protected override void OnValueChanged( DateTime? oldValue, DateTime? newValue )
     {
-      //whenever the value changes we need to parse out the value into out DateTimeInfo segments so we can keep track of the individual pieces
-      //but only if it is not null
+        //whenever the value changes we need to parse out the value into out DateTimeInfo segments so we can keep track of the individual pieces
+        //but only if it is not null
       if( newValue != null )
         ParseValueIntoDateTimeInfo();
 
@@ -248,6 +352,29 @@ namespace Xceed.Wpf.Toolkit
       return this.TryParseDateTime( this.TextBox.Text, out result );
     }
 
+    protected override void OnInitialized( EventArgs e )
+    {
+      base.OnInitialized( e );
+      if( this.Value != null )
+      {
+        DateTimeKind valueKind = this.Value.Value.Kind;
+
+        if( valueKind != this.Kind )
+        {
+          //Conflit between "Kind" property and the "Value.Kind" value.
+          //Priority to the one that is not "Unspecified".
+          if( this.Kind == DateTimeKind.Unspecified )
+          {
+            this.SetKindInternal( valueKind );
+          }
+          else
+          {
+            this.Value = this.ConvertToKind( this.Value.Value, this.Kind );
+          }
+        }
+      }
+    }
+
     #endregion //Base Class Overrides
 
     #region Methods
@@ -709,9 +836,8 @@ namespace Xceed.Wpf.Toolkit
     private bool TryParseDateTime( string text, out DateTime result )
     {
       bool isValid = false;
-      result = DateTime.Now;
 
-      DateTime current = this.Value.HasValue ? this.Value.Value : DateTime.Parse( DateTime.Now.ToString(), this.CultureInfo.DateTimeFormat );
+      DateTime current = this.Value.HasValue ? this.Value.Value : DateTime.Parse( this.ContextNow.ToString(), this.CultureInfo.DateTimeFormat );
       isValid = DateTimeParser.TryParse( text, this.GetFormatString( Format ), current, this.CultureInfo, out result );
 
       if( !isValid )
@@ -720,11 +846,31 @@ namespace Xceed.Wpf.Toolkit
       }
 
       if( !isValid )
+      {
         result = ( _lastValidDate != null ) ? _lastValidDate.Value : current;
+      }
 
       return isValid;
     }
 
+    private DateTime ConvertToKind( DateTime dateTime, DateTimeKind kind )
+    {
+      //Same kind, just return same value.
+      if( kind == dateTime.Kind )
+        return dateTime;
+
+      //"ToLocalTime()" from an unspecified will assume
+      // That the time was originaly Utc and affect the datetime value. 
+      // Just "Force" the "Kind" instead.
+      if( dateTime.Kind == DateTimeKind.Unspecified 
+        || kind == DateTimeKind.Unspecified )
+        return DateTime.SpecifyKind( dateTime, kind );
+
+      return ( kind == DateTimeKind.Local )
+         ? dateTime.ToLocalTime()
+         : dateTime.ToUniversalTime();
+    }
+
     #endregion //Methods
   }
 }
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml
index c3610996..33327a15 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Aero2.NormalColor.xaml
@@ -58,7 +58,6 @@
                                           FontWeight="{TemplateBinding FontWeight}" 
                                           Foreground="{TemplateBinding Foreground}" 
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
                                           Padding="{TemplateBinding Padding}"
@@ -73,7 +72,24 @@
                         <Trigger Property="IsMouseOver" Value="True">
                             <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
                         </Trigger>
-                        <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                     <MultiDataTrigger>
+                        <MultiDataTrigger.Conditions>
+                           <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                           <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                        </MultiDataTrigger.Conditions>
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </MultiDataTrigger>
+                     <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                  Value="True">
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </DataTrigger>
+                     <Trigger Property="IsKeyboardFocusWithin" Value="True">
                             <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
                         </Trigger>
                         <Trigger Property="IsEnabled" Value="False">
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml
index cc84bf73..906c1e7d 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/DateTimeUpDown/Themes/Generic.xaml
@@ -57,7 +57,6 @@
                                           FontWeight="{TemplateBinding FontWeight}" 
                                           Foreground="{TemplateBinding Foreground}" 
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
                                           Padding="{TemplateBinding Padding}"
@@ -72,6 +71,23 @@
                    <Trigger Property="IsFocused" Value="True">
                        <Setter TargetName="PART_TextBox" Property="FocusManager.FocusedElement" Value="{Binding ElementName=PART_TextBox}" />
                    </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                        <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </MultiDataTrigger>
+                  <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                               Value="True">
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </DataTrigger>
                </ControlTemplate.Triggers>
             </ControlTemplate>
          </Setter.Value>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs
index 75ef5d45..c7205d91 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MessageBox/Implementation/MessageBox.cs
@@ -767,27 +767,6 @@ namespace Xceed.Wpf.Toolkit
       return msgBox.MessageBoxResult;
     }
 
-    /// <summary>
-    /// Resolves the owner Window of the MessageBox.
-    /// </summary>
-    /// <returns>the owner Window</returns>
-    private static Window ComputeOwnerWindow()
-    {
-      Window owner = null;
-      if( Application.Current != null )
-      {
-        foreach( Window w in Application.Current.Windows )
-        {
-          if( w.IsActive )
-          {
-            owner = w;
-            break;
-          }
-        }
-      }
-      return owner;
-    }
-
     /// <summary>
     /// Sets the message image source.
     /// </summary>
@@ -839,7 +818,6 @@ namespace Xceed.Wpf.Toolkit
       newWindow.AllowsTransparency = true;
       newWindow.Background = Brushes.Transparent;
       newWindow.Content = this;
-      newWindow.Owner = _owner ?? ComputeOwnerWindow();
 
       if( newWindow.Owner != null )
         newWindow.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterOwner;
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs
index 2b0ec3da..f1149772 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Implementation/MultiLineTextEditor.cs
@@ -19,18 +19,22 @@ using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using System.Windows.Input;
+using System.Windows.Threading;
 using Xceed.Wpf.Toolkit.Core.Utilities;
 
 namespace Xceed.Wpf.Toolkit
 {
   [TemplatePart( Name = PART_ResizeThumb, Type = typeof( Thumb ) )]
+  [TemplatePart( Name = PART_TextBox, Type = typeof( TextBox ) )]
   public class MultiLineTextEditor : ContentControl
   {
     private const string PART_ResizeThumb = "PART_ResizeThumb";
+    private const string PART_TextBox = "PART_TextBox";
 
     #region Members
 
-    Thumb _resizeThumb;
+    private Thumb _resizeThumb;
+    private TextBox _textBox;
 
     #endregion //Members
 
@@ -90,7 +94,8 @@ namespace Xceed.Wpf.Toolkit
 
     protected virtual void OnIsOpenChanged( bool oldValue, bool newValue )
     {
-
+      // Focus the content of the popup, after its loaded
+      Dispatcher.BeginInvoke(new Action(()=>_textBox.Focus()), DispatcherPriority.Background);
     }
 
     #endregion //IsOpen
@@ -214,6 +219,8 @@ namespace Xceed.Wpf.Toolkit
 
       if( _resizeThumb != null )
         _resizeThumb.DragDelta += ResizeThumb_DragDelta;
+
+      _textBox = GetTemplateChild( PART_TextBox ) as TextBox;
     }
 
     #endregion //Bass Class Overrides
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml
index ff34c8e7..e605aed4 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/MultiLineTextEditor/Themes/Aero2.NormalColor.xaml
@@ -21,85 +21,113 @@
                     xmlns:themes="clr-namespace:Xceed.Wpf.Toolkit.Themes"
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-    <ResourceDictionary.MergedDictionaries>
-        <ResourceDictionary Source="../../Themes/Aero2/Common.xaml" />
-    </ResourceDictionary.MergedDictionaries>
-
-    <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
-
-    <Image x:Key="DefaultContent" x:Shared="False" Height="16" Width="18" Source="./../Images/Notes16.png" />
-
-    <Style x:Key="ToggleButtonStyle" TargetType="ToggleButton">
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="ToggleButton">
-                    <Grid SnapsToDevicePixels="True">
-
-                        <Grid>
-                            <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="*" />
-                                <ColumnDefinition Width="Auto" />
-                            </Grid.ColumnDefinitions>
-
-                            <Border Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Padding="{TemplateBinding Padding}" SnapsToDevicePixels="True">
-                                <ContentPresenter Content="{TemplateBinding Content}"
+   <ResourceDictionary.MergedDictionaries>
+      <ResourceDictionary Source="../../Themes/Aero2/Common.xaml" />
+   </ResourceDictionary.MergedDictionaries>
+
+   <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
+
+   <Image x:Key="DefaultContent"
+          x:Shared="False"
+          Height="16"
+          Width="18"
+          Source="./../Images/Notes16.png" />
+
+   <Style x:Key="ToggleButtonStyle"
+          TargetType="ToggleButton">
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="ToggleButton">
+               <Grid SnapsToDevicePixels="True">
+
+                  <Grid>
+                     <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                     </Grid.ColumnDefinitions>
+
+                     <Border Background="{TemplateBinding Background}"
+                             BorderBrush="{TemplateBinding BorderBrush}"
+                             BorderThickness="{TemplateBinding BorderThickness}"
+                             Padding="{TemplateBinding Padding}"
+                             SnapsToDevicePixels="True">
+                        <ContentPresenter Content="{TemplateBinding Content}"
                                           ContentTemplate="{TemplateBinding ContentTemplate}"
                                           ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
                                           VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
                                           HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" />
-                            </Border>
+                     </Border>
 
-                            <chrome:ButtonChrome x:Name="ToggleButtonChrome"
+                     <chrome:ButtonChrome x:Name="ToggleButtonChrome"
                                           Grid.Column="1"
                                           CornerRadius="0"
                                           RenderChecked="{Binding IsOpen, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=local:MultiLineTextEditor}}"
                                           RenderEnabled="{Binding IsEnabled, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=local:MultiLineTextEditor}}"
-											         RenderMouseOver="{TemplateBinding IsMouseOver}"
-											         RenderPressed="{TemplateBinding IsPressed}">
-                                <Grid x:Name="arrowGlyph" IsHitTestVisible="False" Grid.Column="1" Margin="5">
-                                    <Path x:Name="Arrow"  Width="7" Height="4" Data="M 0,1 C0,1 0,0 0,0 0,0 3,0 3,0 3,0 3,1 3,1 3,1 4,1 4,1 4,1 4,0 4,0 4,0 7,0 7,0 7,0 7,1 7,1 7,1 6,1 6,1 6,1 6,2 6,2 6,2 5,2 5,2 5,2 5,3 5,3 5,3 4,3 4,3 4,3 4,4 4,4 4,4 3,4 3,4 3,4 3,3 3,3 3,3 2,3 2,3 2,3 2,2 2,2 2,2 1,2 1,2 1,2 1,1 1,1 1,1 0,1 0,1 z" Fill="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
-                                </Grid>
-                            </chrome:ButtonChrome>
+                                          RenderMouseOver="{TemplateBinding IsMouseOver}"
+                                          RenderPressed="{TemplateBinding IsPressed}">
+                        <Grid x:Name="arrowGlyph"
+                              IsHitTestVisible="False"
+                              Grid.Column="1"
+                              Margin="5">
+                           <Path x:Name="Arrow"
+                                 Width="7"
+                                 Height="4"
+                                 Data="M 0,1 C0,1 0,0 0,0 0,0 3,0 3,0 3,0 3,1 3,1 3,1 4,1 4,1 4,1 4,0 4,0 4,0 7,0 7,0 7,0 7,1 7,1 7,1 6,1 6,1 6,1 6,2 6,2 6,2 5,2 5,2 5,2 5,3 5,3 5,3 4,3 4,3 4,3 4,4 4,4 4,4 3,4 3,4 3,4 3,3 3,3 3,3 2,3 2,3 2,3 2,2 2,2 2,2 1,2 1,2 1,2 1,1 1,1 1,1 0,1 0,1 z"
+                                 Fill="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
                         </Grid>
-
-                    </Grid>
-                    <ControlTemplate.Triggers>
-                        <Trigger Property="IsEnabled" Value="False">
-                            <Setter Property="Fill" TargetName="Arrow" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
-                            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
-                        </Trigger>
-                    </ControlTemplate.Triggers>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-    </Style>
-
-
-    <!-- =============================================================================== -->
-    <!-- MultiLineTextEditor                                                             -->
-    <!-- =============================================================================== -->
-
-    <Style TargetType="{x:Type local:MultiLineTextEditor}">
-        <Setter Property="Background" Value="White"/>
-        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
-        <Setter Property="BorderThickness" Value="1,1,0,1" />
-        <Setter Property="Content" Value="{StaticResource DefaultContent}" />
-        <Setter Property="Focusable" Value="False" />
-        <Setter Property="Padding" Value="2,0,0,0" />
-        <Setter Property="HorizontalContentAlignment" Value="Center" />
-        <Setter Property="VerticalContentAlignment" Value="Center" />
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="{x:Type local:MultiLineTextEditor}">
-                    <Grid x:Name="Root">
-                        <ToggleButton x:Name="PART_DropDownButton"
+                     </chrome:ButtonChrome>
+                  </Grid>
+
+               </Grid>
+               <ControlTemplate.Triggers>
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+                     <Setter Property="Fill"
+                             TargetName="Arrow"
+                             Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
+                     <Setter Property="Foreground"
+                             Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
+                  </Trigger>
+               </ControlTemplate.Triggers>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+
+   <!-- =============================================================================== -->
+   <!-- MultiLineTextEditor                                                             -->
+   <!-- =============================================================================== -->
+
+   <Style TargetType="{x:Type local:MultiLineTextEditor}">
+      <Setter Property="Background"
+              Value="White" />
+      <Setter Property="BorderBrush"
+              Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
+      <Setter Property="BorderThickness"
+              Value="1,1,0,1" />
+      <Setter Property="Content"
+              Value="{StaticResource DefaultContent}" />
+      <Setter Property="Focusable"
+              Value="False" />
+      <Setter Property="Padding"
+              Value="2,0,0,0" />
+      <Setter Property="HorizontalContentAlignment"
+              Value="Center" />
+      <Setter Property="VerticalContentAlignment"
+              Value="Center" />
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="{x:Type local:MultiLineTextEditor}">
+               <Grid x:Name="Root">
+                  <ToggleButton x:Name="PART_DropDownButton"
                                 Grid.Column="1"
                                 IsTabStop="True"
                                 MinHeight="22"
                                 SnapsToDevicePixels="True"
-                                Background="{TemplateBinding Background}" 
-                                BorderBrush="{TemplateBinding BorderBrush}" 
-                                BorderThickness="{TemplateBinding BorderThickness}" 
+                                Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
                                 Padding="{TemplateBinding Padding}"
                                 Content="{TemplateBinding Content}"
                                 ContentTemplate="{TemplateBinding ContentTemplate}"
@@ -109,7 +137,7 @@
                                 IsHitTestVisible="{Binding IsOpen, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource InverseBoolConverter}}"
                                 VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
                                 HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}" />
-                        <Popup IsOpen="{Binding IsChecked, ElementName=PART_DropDownButton}"
+                  <Popup IsOpen="{Binding IsChecked, ElementName=PART_DropDownButton}"
                          StaysOpen="False"
                          Placement="Bottom"
                          SnapsToDevicePixels="True"
@@ -118,9 +146,11 @@
                          PopupAnimation="Slide"
                          Width="{TemplateBinding DropDownWidth}"
                          Height="{TemplateBinding DropDownHeight}">
-                            <Border BorderThickness="1" Background="White" BorderBrush="{StaticResource PopupDarkBorderBrush}">
-                                <Grid>
-                                    <TextBox x:Name="PART_TextBox"
+                     <Border BorderThickness="1"
+                             Background="White"
+                             BorderBrush="{StaticResource PopupDarkBorderBrush}">
+                        <Grid>
+                           <TextBox x:Name="PART_TextBox"
                                     AcceptsReturn="true"
                                     TextWrapping="{TemplateBinding TextWrapping}"
                                     Padding="{TemplateBinding Padding}"
@@ -131,31 +161,40 @@
                                     Text="{Binding Text, RelativeSource={RelativeSource TemplatedParent}}"
                                     TextAlignment="{TemplateBinding TextAlignment}"
                                     Margin="3" />
-                                    <Thumb x:Name="PART_ResizeThumb" HorizontalAlignment="Right" VerticalAlignment="Bottom" Cursor="SizeNWSE">
-                                        <Thumb.Template>
-                                            <ControlTemplate TargetType="{x:Type Thumb}">
-                                                <Grid Background="Transparent">
-                                                    <Path Data="M0.5,6.5 L6.5,0.5 M6.5,3.5 L3.5,6.5" Stroke="Black" StrokeThickness="1" />
-                                                </Grid>
-                                            </ControlTemplate>
-                                        </Thumb.Template>
-                                    </Thumb>
-                                </Grid>
-                            </Border>
-                        </Popup>
-                    </Grid>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-
-        <Style.Triggers>
-            <Trigger Property="IsMouseOver" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
-            </Trigger>
-            <Trigger Property="IsKeyboardFocusWithin" Value="True">
-                <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
-            </Trigger>
-        </Style.Triggers>
-    </Style>
+                           <Thumb x:Name="PART_ResizeThumb"
+                                  HorizontalAlignment="Right"
+                                  VerticalAlignment="Bottom"
+                                  Cursor="SizeNWSE">
+                              <Thumb.Template>
+                                 <ControlTemplate TargetType="{x:Type Thumb}">
+                                    <Grid Background="Transparent">
+                                       <Path Data="M0.5,6.5 L6.5,0.5 M6.5,3.5 L3.5,6.5"
+                                             Stroke="Black"
+                                             StrokeThickness="1" />
+                                    </Grid>
+                                 </ControlTemplate>
+                              </Thumb.Template>
+                           </Thumb>
+                        </Grid>
+                     </Border>
+                  </Popup>
+               </Grid>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+
+      <Style.Triggers>
+         <Trigger Property="IsMouseOver"
+                  Value="True">
+            <Setter Property="BorderBrush"
+                    Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
+         </Trigger>
+         <Trigger Property="IsKeyboardFocusWithin"
+                  Value="True">
+            <Setter Property="BorderBrush"
+                    Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
+         </Trigger>
+      </Style.Triggers>
+   </Style>
 
 </ResourceDictionary>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml
index 00f907b3..fdb564bb 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Aero2.NormalColor.xaml
@@ -21,44 +21,58 @@
                     xmlns:prim="clr-namespace:Xceed.Wpf.Toolkit.Primitives"
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-    <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
-
-    <DataTemplate x:Key="DefaultWatermarkTemplate">
-        <ContentControl Content="{Binding}" Foreground="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" Focusable="False" Margin="0,0,3,0" />
-    </DataTemplate>
-
-    <Style x:Key="NumericUpDown" TargetType="{x:Type prim:InputBase}">
-        <Setter Property="Background" Value="{DynamicResource {x:Static SystemColors.WindowBrushKey}}" />
-        <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
-        <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
-        <Setter Property="BorderThickness" Value="1" />
-        <Setter Property="HorizontalContentAlignment" Value="Right" />
-        <Setter Property="Focusable"  Value="False" />
-        <Setter Property="VerticalContentAlignment" Value="Center" />
-        <Setter Property="TextAlignment" Value="Right" />
-        <Setter Property="WatermarkTemplate" Value="{StaticResource DefaultWatermarkTemplate}" />
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="Control">
-                    <local:ButtonSpinner x:Name="PART_Spinner"
+   <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
+
+   <DataTemplate x:Key="DefaultWatermarkTemplate">
+      <ContentControl Content="{Binding}"
+                      Foreground="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"
+                      Focusable="False"
+                      Margin="0,0,3,0" />
+   </DataTemplate>
+
+   <Style x:Key="NumericUpDown"
+          TargetType="{x:Type prim:InputBase}">
+      <Setter Property="Background"
+              Value="{DynamicResource {x:Static SystemColors.WindowBrushKey}}" />
+      <Setter Property="Foreground"
+              Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}" />
+      <Setter Property="BorderBrush"
+              Value="{DynamicResource {x:Static themes:ResourceKeys.ControlNormalBorderKey}}" />
+      <Setter Property="BorderThickness"
+              Value="1" />
+      <Setter Property="HorizontalContentAlignment"
+              Value="Right" />
+      <Setter Property="Focusable"
+              Value="False" />
+      <Setter Property="VerticalContentAlignment"
+              Value="Center" />
+      <Setter Property="TextAlignment"
+              Value="Right" />
+      <Setter Property="WatermarkTemplate"
+              Value="{StaticResource DefaultWatermarkTemplate}" />
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate TargetType="Control">
+               <local:ButtonSpinner x:Name="PART_Spinner"
                                     IsTabStop="False"
                                     Background="{TemplateBinding Background}"
                                     BorderThickness="{TemplateBinding BorderThickness}"
                                     BorderBrush="{TemplateBinding BorderBrush}"
                                     AllowSpin="{Binding AllowSpin, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}">
-                        <local:WatermarkTextBox x:Name="PART_TextBox"
+                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ButtonSpinnerLocation="{Binding ButtonSpinnerLocation, RelativeSource={RelativeSource TemplatedParent}}">
+                  <local:WatermarkTextBox x:Name="PART_TextBox"
                                           BorderThickness="0"
                                           Background="{TemplateBinding Background}"
                                           ContextMenu="{TemplateBinding ContextMenu}"
-                                          FontFamily="{TemplateBinding FontFamily}" 
-                                          FontSize="{TemplateBinding FontSize}" 
+                                          FontFamily="{TemplateBinding FontFamily}"
+                                          FontSize="{TemplateBinding FontSize}"
                                           FontStretch="{TemplateBinding FontStretch}"
-                                          FontStyle="{TemplateBinding FontStyle}" 
-                                          FontWeight="{TemplateBinding FontWeight}" 
-                                          Foreground="{TemplateBinding Foreground}" 
+                                          FontStyle="{TemplateBinding FontStyle}"
+                                          FontWeight="{TemplateBinding FontWeight}"
+                                          Foreground="{TemplateBinding Foreground}"
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
+
                                           IsTabStop="{TemplateBinding IsTabStop}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
@@ -67,43 +81,69 @@
                                           AutoSelectBehavior="{Binding AutoSelectBehavior, RelativeSource={RelativeSource TemplatedParent}}"
                                           AutoMoveFocus="{Binding AutoMoveFocus, RelativeSource={RelativeSource TemplatedParent}}"
                                           TextAlignment="{Binding TextAlignment, RelativeSource={RelativeSource TemplatedParent}}"
-                                          TextWrapping="NoWrap" 
+                                          TextWrapping="NoWrap"
                                           TabIndex="{TemplateBinding TabIndex}"
                                           VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
                                           Watermark="{Binding Watermark, RelativeSource={RelativeSource TemplatedParent}}"
                                           WatermarkTemplate="{Binding WatermarkTemplate, RelativeSource={RelativeSource TemplatedParent}}" />
-                    </local:ButtonSpinner>
-
-                    <ControlTemplate.Triggers>
-                        <Trigger Property="IsMouseOver" Value="True">
-                            <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
-                        </Trigger>
-                        <Trigger Property="IsKeyboardFocusWithin" Value="True">
-                            <Setter Property="BorderBrush" Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
-                        </Trigger>
-                        <Trigger Property="IsEnabled" Value="False">
-                            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
-                        </Trigger>
-                        <Trigger Property="IsFocused" Value="True">
-                            <Setter TargetName="PART_TextBox" Property="FocusManager.FocusedElement" Value="{Binding ElementName=PART_TextBox}" />
-                        </Trigger>
-                    </ControlTemplate.Triggers>
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-    </Style>
+               </local:ButtonSpinner>
+
+               <ControlTemplate.Triggers>
+                  <Trigger Property="IsMouseOver"
+                           Value="True">
+                     <Setter Property="BorderBrush"
+                             Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
+                  </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                        <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions> 
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox"/>
+                  </MultiDataTrigger>
+                  <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                               Value="True">
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </DataTrigger>
+                  <Trigger Property="IsKeyboardFocusWithin"
+                           Value="True">
+                     <Setter Property="BorderBrush"
+                             Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
+                  </Trigger>
+                  <Trigger Property="IsEnabled"
+                           Value="False">
+                     <Setter Property="Foreground"
+                             Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
+                  </Trigger>
+                  <Trigger Property="IsFocused"
+                           Value="True">
+                     <Setter TargetName="PART_TextBox"
+                             Property="FocusManager.FocusedElement"
+                             Value="{Binding ElementName=PART_TextBox}" />
+                  </Trigger>
+               </ControlTemplate.Triggers>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
 
-    <!-- =============================================================================== -->
-    <!-- DecimalUpDown                                                                   -->
-    <!-- =============================================================================== -->
-    <Style TargetType="{x:Type local:DecimalUpDown}" BasedOn="{StaticResource NumericUpDown}" />
+   <!-- =============================================================================== -->
+   <!-- DecimalUpDown                                                                   -->
+   <!-- =============================================================================== -->
+   <Style TargetType="{x:Type local:DecimalUpDown}" BasedOn="{StaticResource NumericUpDown}" />
 
-    <!-- =============================================================================== -->
-    <!-- DoubleUpDown                                                                    -->
-    <!-- =============================================================================== -->
-    <Style TargetType="{x:Type local:DoubleUpDown}" BasedOn="{StaticResource NumericUpDown}" />
+   <!-- =============================================================================== -->
+   <!-- DoubleUpDown                                                                    -->
+   <!-- =============================================================================== -->
+   <Style TargetType="{x:Type local:DoubleUpDown}" BasedOn="{StaticResource NumericUpDown}" />
 
-    <!-- =============================================================================== -->
+   <!-- =============================================================================== -->
     <!-- IntegerUpDown                                                                   -->
     <!-- =============================================================================== -->
     <Style TargetType="{x:Type local:IntegerUpDown}" BasedOn="{StaticResource NumericUpDown}" />
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml
index a40aa0ae..944e45e2 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/NumericUpDown/Themes/Generic.xaml
@@ -46,7 +46,8 @@
                                     BorderThickness="{TemplateBinding BorderThickness}"
                                     BorderBrush="{TemplateBinding BorderBrush}"
                                     AllowSpin="{Binding AllowSpin, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}">
+                                    ShowButtonSpinner="{Binding ShowButtonSpinner, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ButtonSpinnerLocation="{Binding ButtonSpinnerLocation, RelativeSource={RelativeSource TemplatedParent}}">
                         <local:WatermarkTextBox x:Name="PART_TextBox"
                                           BorderThickness="0"
                                           Background="{TemplateBinding Background}"
@@ -58,7 +59,6 @@
                                           FontWeight="{TemplateBinding FontWeight}" 
                                           Foreground="{TemplateBinding Foreground}" 
                                           HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                          IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                           IsTabStop="{TemplateBinding IsTabStop}"
                                           MinWidth="20"
                                           AcceptsReturn="False"
@@ -74,6 +74,23 @@
                                           WatermarkTemplate="{Binding WatermarkTemplate, RelativeSource={RelativeSource TemplatedParent}}" />
                </local:ButtonSpinner>
                <ControlTemplate.Triggers>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                        <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </MultiDataTrigger>
+                  <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                               Value="True">
+                     <Setter Property="IsReadOnly"
+                             Value="True"
+                             TargetName="PART_TextBox" />
+                  </DataTrigger>
                   <Trigger Property="IsEnabled" Value="False">
                      <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
                   </Trigger>
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToForeignKeyConverter.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs
similarity index 57%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToForeignKeyConverter.cs
rename to ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs
index 779b5cab..7ed0af19 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.DataGrid/Converters/FilterCriterionToForeignKeyConverter.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Converters/IsStringEmptyConverter.cs
@@ -18,39 +18,23 @@ using System;
 using System.Globalization;
 using System.Windows.Data;
 
-using Xceed.Wpf.DataGrid.FilterCriteria;
-
-namespace Xceed.Wpf.DataGrid.Converters
+namespace Xceed.Wpf.Toolkit.PropertyGrid.Converters
 {
-  [ValueConversion( typeof( FilterCriterion ), typeof( Nullable<bool> ) )]
-  internal class FilterCriterionToForeignKeyConverter : IValueConverter
+  public class IsStringEmptyConverter : IValueConverter
   {
-    #region IValueConverter Members
-
     public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
     {
-      EqualToFilterCriterion filterCriterion = value as EqualToFilterCriterion;
-
-      if( filterCriterion != null )
+      if( value is string )
       {
-        return filterCriterion.Value;
+        return string.IsNullOrEmpty( ( string )value );
       }
 
-      return null;
+      return false;
     }
 
     public object ConvertBack( object value, Type targetType, object parameter, CultureInfo culture )
     {
-      if( ( value == null ) || ( value == DBNull.Value ) )
-      {
-        return null;
-      }
-      else
-      {
-        return new EqualToFilterCriterion( value );
-      }
+      throw new NotImplementedException();
     }
-
-    #endregion
   }
 }
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs
index 37a285aa..53533f90 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/CustomPropertyItem.cs
@@ -34,6 +34,11 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
   {
     internal CustomPropertyItem() { }
 
+    internal CustomPropertyItem( bool isPropertyGridCategorized )
+    {
+      _isPropertyGridCategorized = isPropertyGridCategorized;
+    }
+
     #region Category
 
     public static readonly DependencyProperty CategoryProperty =
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs
index 6d28674a..b1490e1e 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/Definitions/EditorDefinitionBase.cs
@@ -42,16 +42,28 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     {
       object currentValue = this.GetValue( definitionProperty );
       object localValue = this.ReadLocalValue( definitionProperty );
+      object elementValue = element.GetValue( elementProp );
+      bool areEquals = false;
+
       // Avoid setting values if it does not affect anything 
       // because setting a local value may prevent a style setter from being active.
-      if( ( localValue != DependencyProperty.UnsetValue )
-        || currentValue != element.GetValue( elementProp ) )
-      {
-        element.SetValue( elementProp, currentValue );
-      }
-      else
+      if( localValue != DependencyProperty.UnsetValue )
       {
-        element.ClearValue( elementProp );
+        if( ( elementValue != null ) && ( currentValue != null ) )
+        {
+          areEquals = ( elementValue.GetType().IsValueType && currentValue.GetType().IsValueType )
+                      ? elementValue.Equals( currentValue )  // Value Types
+                      : currentValue == element.GetValue( elementProp ); // Reference Types
+        }
+
+        if( !areEquals )
+        {
+          element.SetValue( elementProp, currentValue );
+        }
+        else
+        {
+          element.ClearValue( elementProp );
+        }
       }
     }
   }
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs
index 98d2f66b..fc3a4a9f 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/DescriptorPropertyDefinitionBase.cs
@@ -79,6 +79,9 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     {
       return null;
     }
+
+
+
     protected virtual int ComputeDisplayOrder( bool isPropertyGridCategorized )
     {
       return int.MaxValue;
@@ -242,6 +245,10 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
               : null;
     }
 
+
+
+
+
     internal object ComputeDisplayOrderForItem( object item )
     {
       PropertyDescriptor pd = item as PropertyDescriptor;
@@ -407,6 +414,9 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       get { return _displayName; }
       internal set { _displayName = value; }
     }
+
+
+
     public string Description
     {
       get { return _description; }
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs
index e044a6a6..358f35f8 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/IPropertyContainer.cs
@@ -31,6 +31,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
 
 
+
     ContainerHelperBase ContainerHelper { get; }
 
     Style PropertyContainerStyle { get; }
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs
index 0991ad88..b5c66e45 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/ObjectContainerHelperBase.cs
@@ -47,7 +47,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     {
       _propertyItemCollection = new PropertyItemCollection( new ObservableCollection<PropertyItem>() );
       UpdateFilter();
-      UpdateCategorization();
+      UpdateCategorization( false );
 
     }
 
@@ -137,7 +137,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
     protected override void OnCategorizationChanged()
     {
-      UpdateCategorization();
+      UpdateCategorization( true );
     }
 
     protected override void OnAutoGeneratePropertiesChanged()
@@ -165,9 +165,20 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
         ?? PropertyItemCollection.CreateFilter( filterInfo.InputString );
     }
 
-    private void UpdateCategorization()
+    private void UpdateCategorization( bool updateSubPropertiesCategorization )
     {
       _propertyItemCollection.UpdateCategorization( this.ComputeCategoryGroupDescription(), this.PropertyContainer.IsCategorized );
+      if( updateSubPropertiesCategorization && (_propertyItemCollection.Count > 0) )
+      {
+        foreach( PropertyItem propertyItem in _propertyItemCollection )
+        {
+          PropertyItemCollection subPropertyItemsCollection = propertyItem.Properties as PropertyItemCollection;
+          if( subPropertyItemsCollection != null )
+          {
+            subPropertyItemsCollection.UpdateCategorization( this.ComputeCategoryGroupDescription(), this.PropertyContainer.IsCategorized );
+          }
+        }
+      }
     }
 
     private GroupDescription ComputeCategoryGroupDescription()
@@ -218,7 +229,6 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
         propertyItem.PropertyChanged -= OnChildrenPropertyChanged;
       }
 
-
       PropertyItems.UpdateItems( subProperties );
 
       //Add the event callback to the new childrens
@@ -309,6 +319,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       propertyItem.IsReadOnly = pd.IsReadOnly;
       propertyItem.DisplayName = pd.DisplayName;
       propertyItem.Description = pd.Description;
+
       propertyItem.Category = pd.Category;
       propertyItem.PropertyOrder = pd.DisplayOrder;
 
@@ -344,7 +355,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       propertyItem.SetBinding( itemProperty, binding );
     }
 
-    private FrameworkElement GenerateChildrenEditorElement( PropertyItem propertyItem )
+    internal FrameworkElement GenerateChildrenEditorElement( PropertyItem propertyItem )
     {
       FrameworkElement editorElement = null;
       DescriptorPropertyDefinitionBase pd = propertyItem.DescriptorDefinition;
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs
index 8d12011c..8a1059f0 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyDefinitionBaseCollection.cs
@@ -15,17 +15,26 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
+using System.Windows.Documents;
 
 namespace Xceed.Wpf.Toolkit.PropertyGrid
 {
-  public class PropertyDefinitionCollection : PropertyDefinitionBaseCollection<PropertyDefinition> { }
-  public class EditorDefinitionCollection : PropertyDefinitionBaseCollection<EditorDefinitionBase> { }
+  public class PropertyDefinitionCollection : PropertyDefinitionBaseCollection<PropertyDefinition>
+  {
+  }
+  public class EditorDefinitionCollection : PropertyDefinitionBaseCollection<EditorDefinitionBase>
+  {
+  }
 
 
   public abstract class PropertyDefinitionBaseCollection<T> : DefinitionCollectionBase<T> where T : PropertyDefinitionBase
   {
-    internal PropertyDefinitionBaseCollection() { }
+    internal PropertyDefinitionBaseCollection()
+    {
+    }
 
     public T this[ object propertyId ]
     {
@@ -35,6 +44,24 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
         {
           if( item.TargetProperties.Contains( propertyId ) )
             return item;
+
+          // Using the special character "*" in a string of TargetProperties will
+          // return all the items containing the string (before or after) the "*".
+          // ex : Prop* will return properties named Prop1, Prop2, Prop3...
+          List<string> stringTargetProperties = item.TargetProperties.OfType<string>().ToList();
+          if( (stringTargetProperties != null) && (stringTargetProperties.Count > 0) && ( propertyId is string ) )
+          {
+            string stringPropertyID = ( string )propertyId;
+            foreach( var targetPropertyString in stringTargetProperties )
+            {
+              if( targetPropertyString.Contains( "*" ) )
+              {
+                string searchString = targetPropertyString.Replace( "*", "" );
+                if( stringPropertyID.StartsWith( searchString ) || stringPropertyID.EndsWith( searchString ) )
+                  return item;
+              }
+            }
+          }
         }
 
         return null;
@@ -56,7 +83,9 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
   public abstract class DefinitionCollectionBase<T> : ObservableCollection<T> where T : DefinitionBase
   {
-    internal DefinitionCollectionBase() { }
+    internal DefinitionCollectionBase()
+    {
+    }
 
     protected override void InsertItem( int index, T item )
     {
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs
index 5a9f1ff8..61086d0c 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyGrid.cs
@@ -94,6 +94,23 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
     #endregion //AutoGenerateProperties
 
+    #region ShowDescriptionByTooltip
+
+    public static readonly DependencyProperty ShowDescriptionByTooltipProperty = DependencyProperty.Register( "ShowDescriptionByTooltip", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( false ) );
+    public bool ShowDescriptionByTooltip
+    {
+      get
+      {
+        return ( bool )GetValue( ShowDescriptionByTooltipProperty );
+      }
+      set
+      {
+        SetValue( ShowDescriptionByTooltipProperty, value );
+      }
+    }
+
+    #endregion //ShowDescriptionByTooltip
+
     #region ShowSummary
 
     public static readonly DependencyProperty ShowSummaryProperty = DependencyProperty.Register( "ShowSummary", typeof( bool ), typeof( PropertyGrid ), new UIPropertyMetadata( true ) );
@@ -721,7 +738,6 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       CommandBindings.Add( new CommandBinding( PropertyGridCommands.ClearFilter, ClearFilter, CanClearFilter ) );
     }
 
-
     #endregion //Constructors
 
     #region Base Class Overrides
@@ -818,6 +834,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       NameColumnWidth = Math.Max( 0, NameColumnWidth + e.HorizontalChange );
     }
 
+
     #endregion //Event Handlers
 
     #region Commands
@@ -917,6 +934,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
 
 
+
     #endregion //Methods
 
     #region Events
@@ -1129,6 +1147,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
       }
     }
 
+
     #endregion
 
 
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs
index fb7f09e4..a89a75be 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItem.cs
@@ -196,7 +196,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     #region Constructors
 
     internal PropertyItem( DescriptorPropertyDefinitionBase definition )
-      : base()
+      : base( definition.IsPropertyGridCategorized )
     {
       if( definition == null )
         throw new ArgumentNullException( "definition" );
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs
index 3b52f4b8..049b5c9f 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Implementation/PropertyItemBase.cs
@@ -40,6 +40,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
     private ContentControl _valueContainer;
     private ContainerHelperBase _containerHelper;
     private IPropertyContainer _parentNode;
+    internal bool _isPropertyGridCategorized;
 
     #region Properties
 
@@ -416,6 +417,7 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
 
 
+
     Style IPropertyContainer.PropertyContainerStyle
     {
       get { return this.PropertyContainerStyle; }
@@ -441,7 +443,10 @@ namespace Xceed.Wpf.Toolkit.PropertyGrid
 
     bool IPropertyContainer.IsCategorized 
     {
-      get { return false; }
+      get
+      {
+        return _isPropertyGridCategorized;
+      }
     }
 
     bool IPropertyContainer.AutoGenerateProperties
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml
index ec009d6d..c329a4f1 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Aero2.NormalColor.xaml
@@ -44,6 +44,7 @@
     <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
     <pgconv:ExpandableObjectMarginConverter x:Key="ExpandableObjectMarginConverter" />
     <pgconv:ObjectToUIElementConverter x:Key="ObjectToUIElementConverter" />
+    <pgconv:IsStringEmptyConverter x:Key="IsStringEmptyConverter" />
 
    <x:Static x:Key="EmptyString" Member="sys:String.Empty" />
 
@@ -500,7 +501,25 @@
         </Setter>
     </Style>
 
-    <ContextMenu x:Key="{ComponentResourceKey 
+   <Style x:Key="PropertyItemGroupContainerStyle"
+          TargetType="{x:Type GroupItem}">
+      <Style.Resources>
+      </Style.Resources>
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Border>
+                  <Expander Header="{Binding Name}"
+                            Style="{StaticResource ExpanderStyle}">
+                     <ItemsPresenter />
+                  </Expander>
+               </Border>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+   <ContextMenu x:Key="{ComponentResourceKey 
                   TypeInTargetAssembly={x:Type pg:PropertyGrid}, 
                   ResourceId=SelectedObjectAdvancedOptionsMenu}">
         <MenuItem Header="Reset Value" Command="commands:PropertyItemCommands.ResetValue" />
@@ -615,6 +634,11 @@
                                  <VirtualizingStackPanel />
                               </ItemsPanelTemplate>
                            </ItemsControl.ItemsPanel>
+
+                           <ItemsControl.GroupStyle>
+                              <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}"/>
+                           </ItemsControl.GroupStyle>
+
                         </pg:PropertyItemsControl>
                      </Expander>
                   </Grid>
@@ -641,6 +665,17 @@
                              TargetName="_text"
                              Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
                   </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding ShowDescriptionByTooltip, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=pg:PropertyGrid}}"
+                                   Value="True" />
+                        <Condition Binding="{Binding Description, RelativeSource={RelativeSource Self}, Converter={StaticResource IsStringEmptyConverter}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="ToolTipService.ToolTip"
+                             Value="{Binding Description, RelativeSource={RelativeSource TemplatedParent}}"
+                             TargetName="PART_Name" />
+                  </MultiDataTrigger>
                   <Trigger Property="Validation.HasError"
                            Value="true">
                      <Setter Property="ToolTip"
@@ -815,25 +850,8 @@
                                         </ItemsControl.ItemsPanel>
 
                                         <ItemsControl.GroupStyle>
-                                            <GroupStyle>
-                                                <GroupStyle.ContainerStyle>
-                                                    <Style TargetType="{x:Type GroupItem}">
-                                                        <Setter Property="Template">
-                                                            <Setter.Value>
-                                                                <ControlTemplate>
-                                                                    <Border>
-                                                                        <Expander Header="{Binding Name}"
-                                                                                  Style="{StaticResource ExpanderStyle}">
-                                                                            <ItemsPresenter />
-                                                                        </Expander>
-                                                                    </Border>
-                                                                </ControlTemplate>
-                                                            </Setter.Value>
-                                                        </Setter>
-                                                    </Style>
-                                                </GroupStyle.ContainerStyle>
-                                            </GroupStyle>
-                                        </ItemsControl.GroupStyle>
+                                          <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}" />
+                                       </ItemsControl.GroupStyle>
 
                                     </pg:PropertyItemsControl>
                                 </ScrollViewer>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml
index 944a4a6e..a993532f 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/PropertyGrid/Themes/Generic.xaml
@@ -41,6 +41,7 @@
    <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
    <conv:InverseBoolConverter x:Key="InverseBoolConverter" />
    <pgconv:ExpandableObjectMarginConverter x:Key="ExpandableObjectMarginConverter" />
+   <pgconv:IsStringEmptyConverter x:Key="IsStringEmptyConverter" />
 
    <x:Static x:Key="EmptyString" Member="sys:String.Empty" />
 
@@ -197,6 +198,12 @@
             </MultiTrigger.Conditions>
             <Setter Property="BorderBrush" Value="Transparent" />
          </MultiTrigger>
+         <MultiTrigger>
+            <MultiTrigger.Conditions>
+               <Condition Property="IsEnabled" Value="False"/>
+            </MultiTrigger.Conditions>
+            <Setter Property="BorderThickness" Value="0" />
+         </MultiTrigger>          
       </Style.Triggers>
    </Style>
 
@@ -557,6 +564,24 @@
       </Setter>
    </Style>
 
+   <Style x:Key="PropertyItemGroupContainerStyle"
+          TargetType="{x:Type GroupItem}">
+      <Style.Resources>
+      </Style.Resources>
+      <Setter Property="Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Border>
+                  <Expander Header="{Binding Name}"
+                            Style="{StaticResource ExpanderStyle}">
+                     <ItemsPresenter />
+                  </Expander>
+               </Border>
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
    <ContextMenu x:Key="{ComponentResourceKey 
                   TypeInTargetAssembly={x:Type pg:PropertyGrid}, 
                   ResourceId=SelectedObjectAdvancedOptionsMenu}">
@@ -656,6 +681,11 @@
                                  <VirtualizingStackPanel />
                               </ItemsPanelTemplate>
                            </ItemsControl.ItemsPanel>
+
+                           <ItemsControl.GroupStyle>
+                              <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}" />
+                           </ItemsControl.GroupStyle>
+
                         </pg:PropertyItemsControl>
                      </Expander>
                   </Grid>
@@ -676,6 +706,17 @@
                              TargetName="_text"
                              Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}" />
                   </Trigger>
+                  <MultiDataTrigger>
+                     <MultiDataTrigger.Conditions>
+                        <Condition Binding="{Binding ShowDescriptionByTooltip, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=pg:PropertyGrid}}"
+                                   Value="True" />
+                        <Condition Binding="{Binding Description, RelativeSource={RelativeSource Self}, Converter={StaticResource IsStringEmptyConverter}}"
+                                   Value="False" />
+                     </MultiDataTrigger.Conditions>
+                     <Setter Property="ToolTipService.ToolTip"
+                             Value="{Binding Description, RelativeSource={RelativeSource TemplatedParent}}"
+                             TargetName="PART_Name" />
+                  </MultiDataTrigger>
                   <Trigger Property="Validation.HasError" Value="true">
                         <Setter Property="ToolTip"
                                 Value="{Binding RelativeSource={x:Static RelativeSource.Self}, Path=(Validation.Errors).CurrentItem.ErrorContent}"/>
@@ -806,24 +847,7 @@
                               </ItemsControl.ItemsPanel>
 
                               <ItemsControl.GroupStyle>
-                                 <GroupStyle>
-                                    <GroupStyle.ContainerStyle>
-                                       <Style TargetType="{x:Type GroupItem}">
-                                          <Setter Property="Template">
-                                             <Setter.Value>
-                                                <ControlTemplate>
-                                                   <Border >
-                                                        <Expander Header="{Binding Name}"
-                                                                    Style="{StaticResource ExpanderStyle}">
-                                                            <ItemsPresenter />
-                                                        </Expander>
-                                                    </Border>
-                                                </ControlTemplate>
-                                             </Setter.Value>
-                                          </Setter>
-                                       </Style>
-                                    </GroupStyle.ContainerStyle>
-                                 </GroupStyle>
+                                 <GroupStyle ContainerStyle="{StaticResource PropertyItemGroupContainerStyle}" />
                               </ItemsControl.GroupStyle>
 
                            </pg:PropertyItemsControl>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs
index c96ee1ee..a36deced 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/Converters/SliderThumbWidthConverter.cs
@@ -25,6 +25,7 @@ using System.Windows.Data;
 
 namespace Xceed.Wpf.Toolkit.Converters
 {
+  [Obsolete("This class is no longer used internaly and may be removed in a future release")]
   public class SliderThumbWidthConverter : IValueConverter
   {
     public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs
index fff651b4..14f39322 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Implementation/RangeSlider.cs
@@ -49,16 +49,6 @@ namespace Xceed.Wpf.Toolkit
 
       #endregion Members
 
-      #region Enums
-
-      public enum OrientationEnum
-      {
-          Horizontal,
-          Vertical
-      };
-
-      #endregion Enums
-
       #region Constructors
 
       static RangeSlider()
@@ -177,7 +167,7 @@ namespace Xceed.Wpf.Toolkit
       /// HigherValue property represents the higher value within the selected range.
       /// </summary>
       public static readonly DependencyProperty HigherValueProperty = DependencyProperty.Register( "HigherValue", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnHigherValueChanged, RangeSlider.CoerceHigherValue ) );
+        , new FrameworkPropertyMetadata( 0d, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, RangeSlider.OnHigherValueChanged ) );
 
       public double HigherValue
       {
@@ -191,14 +181,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceHigherValue( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        return Math.Max( rangeSlider.LowerValue, Math.Max( rangeSlider.Minimum, Math.Min( rangeSlider.Maximum, newValue ) ) );
-      }
-
       private static void OnHigherValueChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -210,7 +192,7 @@ namespace Xceed.Wpf.Toolkit
 
       protected virtual void OnHigherValueChanged( double oldValue, double newValue )
       {
-        this.AdjustWidths( this.Minimum, this.Maximum, this.LowerValue, newValue );
+        this.AdjustView();
 
         RoutedEventArgs args = new RoutedEventArgs();
         args.RoutedEvent = RangeSlider.HigherValueChangedEvent;
@@ -273,7 +255,7 @@ namespace Xceed.Wpf.Toolkit
       /// 
 
       private static DependencyPropertyKey LowerRangeWidthPropertyKey = DependencyProperty.RegisterAttachedReadOnly( "LowerRangeWidth", typeof( double )
-        , typeof( RangeSlider ), new PropertyMetadata( 0d ) );
+        , typeof( RangeSlider ), new PropertyMetadata( 0d  ) );
 
       public static readonly DependencyProperty LowerRangeWidthProperty = LowerRangeWidthPropertyKey.DependencyProperty;
 
@@ -319,7 +301,7 @@ namespace Xceed.Wpf.Toolkit
       /// LowerValue property represents the lower value within the selected range.
       /// </summary>
       public static readonly DependencyProperty LowerValueProperty = DependencyProperty.Register( "LowerValue", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnLowerValueChanged, RangeSlider.CoerceLowerValue ) );
+        , new FrameworkPropertyMetadata( 0d, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, RangeSlider.OnLowerValueChanged ) );
 
       public double LowerValue
       {
@@ -333,19 +315,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceLowerValue( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        if( ( rangeSlider.HigherValue == 0 ) && ( rangeSlider.LowerValue == 0 ) )
-          newValue = Math.Max( rangeSlider.Minimum, Math.Min( rangeSlider.Maximum, newValue ) );
-        else
-          newValue = Math.Min( Math.Max( rangeSlider.Minimum, Math.Min( rangeSlider.Maximum, newValue ) ), rangeSlider.HigherValue );
-
-        return newValue;
-      }
-
       private static void OnLowerValueChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -357,9 +326,7 @@ namespace Xceed.Wpf.Toolkit
 
       protected virtual void OnLowerValueChanged( double oldValue, double newValue )
       {
-        this.HigherValue = Math.Max( this.HigherValue, newValue );
-
-          this.AdjustWidths( this.Minimum, this.Maximum, newValue, this.HigherValue );
+          this.AdjustView();
 
           RoutedEventArgs args = new RoutedEventArgs();
           args.RoutedEvent = RangeSlider.LowerValueChangedEvent;
@@ -374,7 +341,7 @@ namespace Xceed.Wpf.Toolkit
       /// Maximum property represents the maximum value, which can be selected, in a range.
       /// </summary>
       public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register( "Maximum", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnMaximumChanged, RangeSlider.CoerceMaximum ) );
+        , new FrameworkPropertyMetadata( RangeSlider.OnMaximumChanged ) );
 
       public double Maximum
       {
@@ -388,14 +355,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceMaximum( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        return Math.Max( newValue, rangeSlider.HigherValue );
-      }
-
       private static void OnMaximumChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -407,7 +366,7 @@ namespace Xceed.Wpf.Toolkit
 
       protected virtual void OnMaximumChanged( double oldValue, double newValue )
       {
-        this.AdjustWidths( this.Minimum, newValue, this.LowerValue, this.HigherValue );
+        this.AdjustView();
       }
 
       #endregion Maximum
@@ -418,7 +377,7 @@ namespace Xceed.Wpf.Toolkit
       /// Minimum property represents the minimum value, which can be selected, in a range.
       /// </summary>
       public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register( "Minimum", typeof( double ), typeof( RangeSlider )
-        , new FrameworkPropertyMetadata( RangeSlider.OnMinimumChanged, RangeSlider.CoerceMinimum ) );
+        , new FrameworkPropertyMetadata( RangeSlider.OnMinimumChanged ) );
 
       public double Minimum
       {
@@ -432,23 +391,6 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
-      private static object CoerceMinimum( DependencyObject sender, object value )
-      {
-        RangeSlider rangeSlider = sender as RangeSlider;
-        double newValue = ( double )value;
-
-        if( ( rangeSlider.Minimum == 0.0 ) && ( rangeSlider.LowerValue == 0 ) && ( rangeSlider.HigherValue == 0 ) && ( rangeSlider.Maximum == 0 ) )
-        {
-          newValue = Math.Max( newValue, rangeSlider.LowerValue );
-        }
-        else
-        {
-          newValue = Math.Min( newValue, rangeSlider.LowerValue );
-        }
-
-        return newValue;
-      }
-
       private static void OnMinimumChanged( DependencyObject sender, DependencyPropertyChangedEventArgs args )
       {
         RangeSlider rangeSlider = sender as RangeSlider;
@@ -461,7 +403,7 @@ namespace Xceed.Wpf.Toolkit
       protected virtual void OnMinimumChanged( double oldValue, double newValue )
       {
         // adjust the range width
-        this.AdjustWidths( newValue, this.Maximum, this.LowerValue, this.HigherValue );
+        this.AdjustView();
       }
 
       #endregion Minimum
@@ -472,14 +414,14 @@ namespace Xceed.Wpf.Toolkit
       /// # TODODOC
       /// Get/Set the RangeSlider orientation.
       /// </summary>
-      public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register( "Orientation", typeof( OrientationEnum ), typeof( RangeSlider ),
-          new FrameworkPropertyMetadata( OrientationEnum.Horizontal, RangeSlider.OnOrientationChanged ) );
+      public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register( "Orientation", typeof( Orientation ), typeof( RangeSlider ),
+          new FrameworkPropertyMetadata( Orientation.Horizontal, RangeSlider.OnOrientationChanged ) );
 
-      public OrientationEnum Orientation
+      public Orientation Orientation
       {
         get
         {
-          return ( OrientationEnum )GetValue( RangeSlider.OrientationProperty );
+          return ( Orientation )GetValue( RangeSlider.OrientationProperty );
         }
         set
         {
@@ -492,11 +434,11 @@ namespace Xceed.Wpf.Toolkit
         RangeSlider rangeSlider = sender as RangeSlider;
         if( rangeSlider != null )
         {
-          rangeSlider.OnOrientationChanged( ( OrientationEnum )e.OldValue, ( OrientationEnum )e.NewValue );
+          rangeSlider.OnOrientationChanged( ( Orientation )e.OldValue, ( Orientation )e.NewValue );
         }
       }
 
-      protected virtual void OnOrientationChanged( OrientationEnum oldValue, OrientationEnum newValue )
+      protected virtual void OnOrientationChanged( Orientation oldValue, Orientation newValue )
       {
       }
 
@@ -635,21 +577,25 @@ namespace Xceed.Wpf.Toolkit
         if( _lowerSlider != null )
         {
           _lowerSlider.Loaded -= this.Slider_Loaded;
+          _lowerSlider.ValueChanged -= LowerSlider_ValueChanged;
         }
         _lowerSlider = this.Template.FindName( PART_LowerSlider, this ) as Slider;
         if( _lowerSlider != null )
         {
           _lowerSlider.Loaded += this.Slider_Loaded;
+          _lowerSlider.ValueChanged += LowerSlider_ValueChanged;
         }
 
         if( _higherSlider != null )
         {
-            _higherSlider.Loaded -= this.Slider_Loaded;    
+            _higherSlider.Loaded -= this.Slider_Loaded;
+            _higherSlider.ValueChanged -= HigherSlider_ValueChanged;
         }
         _higherSlider = this.Template.FindName( PART_HigherSlider, this ) as Slider;
         if( _higherSlider != null )
         {
-          _higherSlider.Loaded += this.Slider_Loaded; 
+          _higherSlider.Loaded += this.Slider_Loaded;
+          _higherSlider.ValueChanged += HigherSlider_ValueChanged;
         }
       }
 
@@ -690,19 +636,22 @@ namespace Xceed.Wpf.Toolkit
         return 0d;
       }
 
-      private void AdjustWidths( double minimum, double maximum, double lowerValue, double higherValue )
+      private void AdjustView()
       {
+        //Coerce values to make them consistent.
+        CoercedValues cv = this.GetCoercedValues();
+
         double actualWidth = 0;
         double lowerSliderThumbWidth = 0d;
         double higherSliderThumbWidth = 0d;
 
-        if( this.Orientation == OrientationEnum.Horizontal )
+        if( this.Orientation == Orientation.Horizontal )
         {
           actualWidth = this.ActualWidth;
           lowerSliderThumbWidth = RangeSlider.GetThumbWidth( _lowerSlider );
           higherSliderThumbWidth = RangeSlider.GetThumbWidth( _higherSlider );
         }
-        else if( this.Orientation == OrientationEnum.Vertical )
+        else if( this.Orientation == Orientation.Vertical )
         {
           actualWidth = this.ActualHeight;
           lowerSliderThumbWidth = RangeSlider.GetThumbHeight( _lowerSlider );
@@ -711,20 +660,34 @@ namespace Xceed.Wpf.Toolkit
 
         actualWidth -= ( lowerSliderThumbWidth + higherSliderThumbWidth );
 
-        double entireRange = maximum - minimum;
+        this.SetLowerSliderValues( cv.LowerValue, cv.Minimum, cv.Maximum );
+        this.SetHigherSliderValues( cv.HigherValue, cv.Minimum, cv.Maximum );
+
+        double entireRange = cv.Maximum - cv.Minimum;
+
+        if( entireRange > 0 )
+        {
+          this.HigherRangeWidth = ( actualWidth * ( cv.Maximum - cv.HigherValue ) ) / entireRange;
+
+          this.RangeWidth = ( actualWidth * ( cv.HigherValue - cv.LowerValue ) ) / entireRange;
 
-        this.HigherRangeWidth = ( actualWidth * ( maximum - higherValue ) ) / entireRange;
+          this.LowerRangeWidth = ( actualWidth * ( cv.LowerValue - cv.Minimum ) ) / entireRange;
+        }
+        else
+        {
+          this.HigherRangeWidth = 0d;
+          this.RangeWidth = 0d;
+          this.LowerRangeWidth = actualWidth;
+        }
 
-        this.RangeWidth = ( actualWidth * ( higherValue - lowerValue ) ) / entireRange;
 
-        this.LowerRangeWidth = ( actualWidth * ( lowerValue - minimum ) ) / entireRange;
       }
 
       private void SetSlidersMargins()
       {
         if( ( _lowerSlider != null ) && ( _higherSlider != null ) )
         {
-          if( this.Orientation == OrientationEnum.Horizontal )
+          if( this.Orientation == Orientation.Horizontal )
           {
             double lowerSliderThumbWidth = RangeSlider.GetThumbWidth( _lowerSlider );
             double higherSliderThumbWidth = RangeSlider.GetThumbWidth( _higherSlider );
@@ -743,6 +706,53 @@ namespace Xceed.Wpf.Toolkit
         }
       }
 
+      private CoercedValues GetCoercedValues()
+      {
+        CoercedValues cv = new CoercedValues();
+        cv.Minimum = Math.Min( this.Minimum, this.Maximum );
+        cv.Maximum = Math.Max( cv.Minimum, this.Maximum );
+        cv.LowerValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, this.LowerValue ) );
+        cv.HigherValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, this.HigherValue ) );
+        cv.HigherValue = Math.Max( cv.LowerValue, cv.HigherValue );
+
+        return cv;
+      }
+
+      private void SetLowerSliderValues( double value, double? minimum, double? maximum )
+      {
+        this.SetSliderValues( _lowerSlider, this.LowerSlider_ValueChanged, value, minimum, maximum );
+      }
+
+      private void SetHigherSliderValues( double value, double? minimum, double? maximum )
+      {
+        this.SetSliderValues( _higherSlider, this.HigherSlider_ValueChanged, value, minimum, maximum );
+      }
+
+      private void SetSliderValues(
+        Slider slider,
+        RoutedPropertyChangedEventHandler<double> handler,
+        double value,
+        double? minimum,
+        double? maximum )
+      {
+        if( slider != null )
+        {
+          slider.ValueChanged -= handler;
+
+          slider.Value = value;
+          if( minimum != null )
+          {
+            slider.Minimum = minimum.Value;
+          }
+          if( maximum != null )
+          {
+            slider.Maximum = maximum.Value;
+          }
+
+          slider.ValueChanged += handler;
+        }
+      }
+
       #endregion
 
       #region Events
@@ -779,25 +789,73 @@ namespace Xceed.Wpf.Toolkit
 
       private void LowerRange_Click(object sender, RoutedEventArgs e)
       {
-        this.LowerValue -= this.Step;
+        CoercedValues cv = this.GetCoercedValues();
+        //When Maximum is not greater than Minimum, the
+        //slider display is in an inconsistant state. Don't 
+        //consider any operation from the user
+        if( cv.Minimum < cv.Maximum )
+        {
+          double newValue = cv.LowerValue - this.Step;
+          this.LowerValue = Math.Min( cv.Maximum, Math.Max( cv.Minimum, newValue ) );
+        }
       }
 
       private void HigherRange_Click(object sender, RoutedEventArgs e)
       {
-        this.HigherValue += this.Step;
+        CoercedValues cv = this.GetCoercedValues();
+        //When Maximum is not greater than Minimum, the
+        //slider display is in an inconsistant state. Don't 
+        //consider any operation from the user
+        if( cv.Minimum < cv.Maximum )
+        {
+          double newValue = cv.HigherValue + this.Step;
+          this.HigherValue = Math.Min( cv.Maximum, Math.Max( cv.Minimum, newValue ) );
+        }
       }
 
       private void RangeSlider_SizeChanged( object sender, SizeChangedEventArgs e )
       {
-        this.AdjustWidths( this.Minimum, this.Maximum, this.LowerValue, this.HigherValue );
+        this.AdjustView();
       }
 
       private void Slider_Loaded( object sender, RoutedEventArgs e )
       {
         this.SetSlidersMargins();
-        this.AdjustWidths( this.Minimum, this.Maximum, this.LowerValue, this.HigherValue );
+        this.AdjustView();
+      }
+
+      private void LowerSlider_ValueChanged( object sender, RoutedPropertyChangedEventArgs<double> e )
+      {
+        if( _lowerSlider.IsLoaded )
+        {
+          CoercedValues cv = this.GetCoercedValues();
+          double newValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, e.NewValue ) );
+          newValue = Math.Min( newValue, cv.HigherValue );
+          this.SetLowerSliderValues( newValue, null, null );
+          this.LowerValue = newValue;
+        }
+      }
+
+      private void HigherSlider_ValueChanged( object sender, RoutedPropertyChangedEventArgs<double> e )
+      {
+        if( _higherSlider.IsLoaded )
+        {
+          CoercedValues cv = this.GetCoercedValues();
+          double newValue = Math.Max( cv.Minimum, Math.Min( cv.Maximum, e.NewValue ) );
+          newValue = Math.Max( newValue, cv.LowerValue );
+          this.SetHigherSliderValues( newValue, null, null );
+          this.HigherValue = newValue;
+        }
       }
 
       #endregion Events Handlers
+
+      private struct CoercedValues
+      {
+        public double Minimum;
+        public double Maximum;
+        public double LowerValue;
+        public double HigherValue;
+      }
     }
 }
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml
index 499c266c..2776dfc9 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Aero2.NormalColor.xaml
@@ -22,30 +22,46 @@
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Converters"
                     xmlns:coreConv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-   <conv:SliderThumbWidthConverter x:Key="SliderThumbWidthConverter" />
    <coreConv:SolidColorBrushToColorConverter x:Key="SolidColorBrushToColorConverter" />
 
     <!-- //#TODODOC
          Repeat Button - This is used by RangeSlider for the LowerRange, Range, and HigherRange buttons -->
    <Style x:Key="DefaultRangeStyle"
           TargetType="{x:Type RepeatButton}">
+      <Setter Property="Focusable"
+              Value="False" />
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type RepeatButton}">
                <Grid>
                   <Rectangle x:Name="MainBorder"
-                             Fill="Transparent"
-                             Opacity="1" />
+                             Fill="{TemplateBinding Background}" />
                </Grid>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
    </Style>
 
+   <!--//##TODODOC-->
+   <!--Since a thumb is pretty small, we put a bigger visual clue
+   outside the thumb bounds to give the user a hint where the focus is-->
+   <Style x:Key="ThumbFocusVisualStyle">
+      <Setter Property="Control.Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Rectangle Margin="-2"
+                          StrokeThickness="1"
+                          Stroke="Black"
+                          StrokeDashArray="1 2" />
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>
+
+   <!-- ********************** -->
+    <!-- Thumb Template    -->
     <!-- ********************** -->
-    <!-- LowerThumb Template    -->
-    <!-- ********************** -->
-   <ControlTemplate x:Key="LowerThumbTemplate"
+   <ControlTemplate x:Key="ThumbTemplate"
                     TargetType="{x:Type Thumb}">
       <Grid>
          <Rectangle x:Name="BackgroundFadingRect"
@@ -53,17 +69,17 @@
                     Width="11"
                     Height="20" />
          <Rectangle x:Name="MainBorder"
-                    Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue=#FFF0F0F0}"
+                    Fill="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background, TargetNullValue=#FFF0F0F0}"
                     StrokeThickness="1"
                     Stroke="#FFACACAC"
                     Opacity="1"
                     Width="11"
                     Height="20"
-                    ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
+                    ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Value, StringFormat=\{0:00.00\}}"
                     SnapsToDevicePixels="True" />
       </Grid>
       <ControlTemplate.Triggers>
-         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background, Converter={StaticResource SolidColorBrushToColorConverter}}"
                       Value="Transparent">
             <Setter Property="Visibility"
                     TargetName="BackgroundFadingRect"
@@ -75,11 +91,9 @@
                     TargetName="MainBorder"
                     Value="0.75" />
          </Trigger>
-         <!-- //# TODODOC
-               Do something else when MouseOver and LowerThumbBackground is null -->
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background}"
                           Value="{x:Null}" />
                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
@@ -107,451 +121,192 @@
                     TargetName="MainBorder"
                     Value="#FFF0F0F0" />
          </Trigger>
-      </ControlTemplate.Triggers>
-   </ControlTemplate>
-
-    <!-- ********************** -->
-    <!-- HigherThumb Template    -->
-    <!-- ********************** -->
-   <ControlTemplate x:Key="HigherThumbTemplate"
-                    TargetType="{x:Type Thumb}">
-      <Grid>
-         <Rectangle x:Name="BackgroundFadingRect"
-                    Fill="Black"
-                    Width="11"
-                    Height="20" />
-         <Rectangle Name="MainBorder"
-                    Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue=#FFF0F0F0}"
-                    StrokeThickness="1"
-                    Stroke="#FFACACAC"
-                    Opacity="1"
-                    Width="11"
-                    Height="20"
-                    ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                    SnapsToDevicePixels="True" />
-      </Grid>
-      <ControlTemplate.Triggers>
-         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
-                      Value="Transparent">
-            <Setter Property="Visibility"
-                    TargetName="BackgroundFadingRect"
-                    Value="Collapsed" />
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Orientation}"
+                      Value="Vertical">
+            <Setter TargetName="MainBorder"
+                    Property="Width"
+                    Value="20" />
+            <Setter TargetName="MainBorder"
+                    Property="Height"
+                    Value="11" />
+            <Setter TargetName="BackgroundFadingRect"
+                    Property="Width"
+                    Value="20" />
+            <Setter TargetName="BackgroundFadingRect"
+                    Property="Height"
+                    Value="11" />
          </DataTrigger>
-         <Trigger Property="IsMouseOver"
-                  Value="True">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="0.75" />
-         </Trigger>
-         <!-- //# TODODOC
-               Do something else when MouseOver and HigherThumbBackground is null -->
-         <MultiDataTrigger>
-            <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                          Value="{x:Null}" />
-               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                          Value="True" />
-            </MultiDataTrigger.Conditions>
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="1" />
-            <Setter Property="Stroke"
-                    TargetName="MainBorder"
-                    Value="#FF7EB4EA" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="#FFDCECFC" />
-         </MultiDataTrigger>
-
-         <Trigger Property="IsEnabled"
-                  Value="False">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="1" />
-            <Setter Property="Stroke"
-                    TargetName="MainBorder"
-                    Value="#FFD9D9D9" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="#FFF0F0F0" />
-         </Trigger>
       </ControlTemplate.Triggers>
    </ControlTemplate>
 
     <!-- ********************** -->
-    <!-- LowerSlider Template     -->
+    <!-- Slider Template     -->
     <!-- ********************** -->
-   <ControlTemplate x:Key="LowerSliderTemplate"
+   <ControlTemplate x:Key="SliderTemplate"
                     TargetType="{x:Type Slider}">
       <Border SnapsToDevicePixels="true"
               BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
-            <Grid.RowDefinitions>
-               <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
-               <RowDefinition Height="Auto" />
-            </Grid.RowDefinitions>
-
             <Track x:Name="PART_Track"
+                   Orientation="{TemplateBinding Orientation}"
                    Grid.Row="1">
                <Track.Thumb>
                   <Thumb x:Name="Thumb"
-                         Template="{StaticResource LowerThumbTemplate}">
+                         Focusable="True"
+                         FocusVisualStyle="{StaticResource ThumbFocusVisualStyle}"
+                         Background="{TemplateBinding Background}"
+                         Template="{StaticResource ThumbTemplate}">
                   </Thumb>
                </Track.Thumb>
             </Track>
-         </Grid>
       </Border>
    </ControlTemplate>
 
     <!-- ********************** -->
-    <!-- HigherSlider Template   -->
+    <!-- Vertical RangeSlider Template -->
     <!-- ********************** -->
-   <ControlTemplate x:Key="HigherSliderTemplate"
-                    TargetType="{x:Type Slider}">
-      <Border SnapsToDevicePixels="true"
-              BorderBrush="{TemplateBinding BorderBrush}"
-              BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
+   <ControlTemplate x:Key="VerticalRangeSlider"
+                    TargetType="{x:Type local:RangeSlider}">
+      <Border BorderBrush="{TemplateBinding BorderBrush}"
+              BorderThickness="{TemplateBinding BorderThickness}"
+              Background="{TemplateBinding Background}">
+         <Grid HorizontalAlignment="Left"
+               VerticalAlignment="Top">
+            <!-- //#TODODOC 
+             Get Thumbs's height to set the good RangeSlider height.-->
             <Grid.RowDefinitions>
+               <RowDefinition Height="11" />
+               <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
                <RowDefinition Height="Auto" />
+               <RowDefinition Height="11" />
             </Grid.RowDefinitions>
 
-            <Track x:Name="PART_Track"
-                   Grid.Row="1">
-               <Track.Thumb>
-                  <Thumb x:Name="Thumb"
-                         Template="{StaticResource HigherThumbTemplate}" />
-               </Track.Thumb>
-            </Track>
+            <Border Grid.Row="1"
+                    Grid.RowSpan="3"
+                    BorderThickness="1"
+                    BorderBrush="#FFD6D6D6"
+                    Background="#FFE7EAEA"
+                    VerticalAlignment="Stretch"
+                    HorizontalAlignment="Center"
+                    Width="4" />
+
+            <RepeatButton x:Name="PART_LowerRange"
+                          Height="{TemplateBinding LowerRangeWidth}"
+                          Grid.Row="3"
+                          Background="{TemplateBinding LowerRangeBackground}"
+                          Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton Height="{TemplateBinding RangeWidth}"
+                          Grid.Row="2"
+                          Background="{TemplateBinding RangeBackground}"
+                          Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton x:Name="PART_HigherRange"
+                          Height="{TemplateBinding HigherRangeWidth}"
+                          Grid.Row="1"
+                          Background="{TemplateBinding HigherRangeBackground}"
+                          Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
+            <Slider x:Name="PART_LowerSlider"
+                    Orientation="Vertical"
+                    Grid.RowSpan="5"
+                    Focusable="False"
+                    Background="{TemplateBinding LowerThumbBackground}"
+                    Template="{StaticResource SliderTemplate}">
+            </Slider>
+
+            <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+            <Slider x:Name="PART_HigherSlider"
+                    Grid.RowSpan="5"
+                    Orientation="Vertical"
+                    Focusable="False"
+                    Background="{TemplateBinding HigherThumbBackground}"
+                    Template="{StaticResource SliderTemplate}">
+            </Slider>
          </Grid>
       </Border>
    </ControlTemplate>
 
-    <!-- ********************** -->
-    <!-- Vertical RangeSlider Template -->
-    <!-- ********************** -->
-   <ControlTemplate x:Key="VerticalRangeSlider"
-                    TargetType="{x:Type local:RangeSlider}">
-      <Grid Width="50">
-         <!-- //#TODODOC 
-             Get Thumbs's height to set the good RangeSlider height.-->
-         <Grid.RowDefinitions>
-            <RowDefinition Height="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-         </Grid.RowDefinitions>
-
-         <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="Auto" />
-            <ColumnDefinition Width="Auto"
-                              MinWidth="50" />
-         </Grid.ColumnDefinitions>
-
-         <Border Grid.Column="1"
-                 Grid.Row="1"
-                 Grid.RowSpan="3"
-                 BorderThickness="1"
-                 BorderBrush="#FFD6D6D6"
-                 Background="#FFE7EAEA"
-                 VerticalAlignment="Stretch"
-                 HorizontalAlignment="Center"
-                 Width="4" />
-
-         <RepeatButton x:Name="PART_LowerRange"
-                       Height="{TemplateBinding LowerRangeWidth}"
-                       Width="15"
-                       Grid.Column="1"
-                       Grid.Row="3"
-                       Background="{TemplateBinding LowerRangeBackground}"
-                       Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True"/>
-
-         <RepeatButton Height="{TemplateBinding RangeWidth}"
-                       Width="15"
-                       Grid.Row="2"
-                       Grid.Column="1"
-                       Background="{TemplateBinding RangeBackground}"
-                       Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True"/>
-
-         <RepeatButton x:Name="PART_HigherRange"
-                       Height="{TemplateBinding HigherRangeWidth}"
-                       Width="15"
-                       Grid.Row="1"
-                       Grid.Column="1"
-                       Background="{TemplateBinding HigherRangeBackground}"
-                       Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True"/>
-
-         <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
-         <Slider x:Name="PART_LowerSlider"
-                 Grid.Column="1"
-                 Orientation="Vertical"
-                 Grid.RowSpan="5"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Rectangle x:Name="BackgroundFadingRect"
-                                                     Fill="Black"
-                                                     Width="20"
-                                                     Height="11" />
-                                          <Rectangle x:Name="MainBorder"
-                                                     Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue=#FFF0F0F0}"
-                                                     StrokeThickness="1"
-                                                     Stroke="#FFACACAC"
-                                                     Width="20"
-                                                     Height="11"
-                                                     Opacity="1"
-                                                     ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
-                                                     SnapsToDevicePixels="True" />
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
-                                                       Value="Transparent">
-                                             <Setter Property="Visibility"
-                                                     TargetName="BackgroundFadingRect"
-                                                     Value="Collapsed" />
-                                          </DataTrigger>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.75" />
-                                          </Trigger>
-                                          <!-- //# TODODOC
-                                             Do something else when MouseOver and LowerThumbBackground is null -->
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FF7EB4EA" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFDCECFC" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD9D9D9" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF0F0F0" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-
-         <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-         <Slider x:Name="PART_HigherSlider"
-                 Grid.Column="1"
-                 Grid.RowSpan="5"
-                 Orientation="Vertical"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Rectangle x:Name="BackgroundFadingRect"
-                                                     Fill="Black"
-                                                     Width="20"
-                                                     Height="11" />
-                                          <Rectangle Name="MainBorder"
-                                                     Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue=#FFF0F0F0}"
-                                                     StrokeThickness="1"
-                                                     Stroke="#FFACACAC"
-                                                     Width="20"
-                                                     Height="11"
-                                                     ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                                                     SnapsToDevicePixels="True" />
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, Converter={StaticResource SolidColorBrushToColorConverter}}"
-                                                       Value="Transparent">
-                                             <Setter Property="Visibility"
-                                                     TargetName="BackgroundFadingRect"
-                                                     Value="Collapsed" />
-                                          </DataTrigger>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter TargetName="MainBorder"
-                                                     Property="Opacity"
-                                                     Value="0.75" />
-                                          </Trigger>
-                                          <!-- //# TODODOC
-                                                Do something else when MouseOver and HigherThumbBackground is null -->
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FF7EB4EA" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFDCECFC" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD9D9D9" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF0F0F0" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-      </Grid>
-   </ControlTemplate>
-
     <!-- ********************** -->
     <!-- RangeSlider Style -->
     <!-- ********************** -->
    <Style TargetType="{x:Type local:RangeSlider}">
+      <Setter Property="IsTabStop"
+              Value="False" />
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type local:RangeSlider}">
-               <Grid>
-                  <Grid.RowDefinitions>
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto"
-                                    MinHeight="{TemplateBinding MinHeight}" />
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto" />
-                  </Grid.RowDefinitions>
-
-                  <!-- //#TODODOC 
+               <Border BorderBrush="{TemplateBinding BorderBrush}"
+                       BorderThickness="{TemplateBinding BorderThickness}"
+                       Background="{TemplateBinding Background}">
+                  <Grid HorizontalAlignment="Left"
+                        VerticalAlignment="Top">
+                     <!-- //#TODODOC 
                         Get Thumbs's width to set the good RangeSlider width.-->
-                  <Grid.ColumnDefinitions>
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
-                     <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
-                  </Grid.ColumnDefinitions>
-
-                  <Border Grid.Row="1"
-                          Grid.Column="1"
-                          Grid.ColumnSpan="3"
-                          BorderThickness="1"
-                          BorderBrush="#FFD6D6D6"
-                          Background="#FFE7EAEA"
-                          VerticalAlignment="Center"
-                          Height="4" />
-
-                  <RepeatButton x:Name="PART_LowerRange"
-                                Width="{TemplateBinding LowerRangeWidth}"
-                                Grid.Column="1"
-                                Grid.Row="1"
-                                Background="{TemplateBinding LowerRangeBackground}"
-                                Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}" 
-                                SnapsToDevicePixels="True"/>
-
-                  <RepeatButton Width="{TemplateBinding RangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="2"
-                                Background="{TemplateBinding RangeBackground}"
-                                Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <RepeatButton x:Name="PART_HigherRange"
-                                Width="{TemplateBinding HigherRangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="3"
-                                Background="{TemplateBinding HigherRangeBackground}"
-                                Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True"/>
-
-                  <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
-                  <Slider x:Name="PART_LowerSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource LowerSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-
-                  <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-                  <Slider x:Name="PART_HigherSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource HigherSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-               </Grid>
+                     <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="11" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="11" />
+                     </Grid.ColumnDefinitions>
+
+                     <Border Grid.Row="1"
+                             Grid.Column="1"
+                             Grid.ColumnSpan="3"
+                             BorderThickness="1"
+                             BorderBrush="#FFD6D6D6"
+                             Background="#FFE7EAEA"
+                             VerticalAlignment="Center"
+                             Height="4" />
+
+                     <RepeatButton x:Name="PART_LowerRange"
+                                   Width="{TemplateBinding LowerRangeWidth}"
+                                   Grid.Column="1"
+                                   Grid.Row="1"
+                                   Background="{TemplateBinding LowerRangeBackground}"
+                                   Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <RepeatButton Width="{TemplateBinding RangeWidth}"
+                                   Grid.Row="1"
+                                   Grid.Column="2"
+                                   Background="{TemplateBinding RangeBackground}"
+                                   Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <RepeatButton x:Name="PART_HigherRange"
+                                   Width="{TemplateBinding HigherRangeWidth}"
+                                   Grid.Row="1"
+                                   Grid.Column="3"
+                                   Background="{TemplateBinding HigherRangeBackground}"
+                                   Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
+                     <Slider x:Name="PART_LowerSlider"
+                             Grid.Row="1"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding LowerThumbBackground}"
+                             Template="{StaticResource SliderTemplate}">
+                     </Slider>
+
+                     <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+                     <Slider x:Name="PART_HigherSlider"
+                             Grid.Row="1"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding HigherThumbBackground}"
+                             Template="{StaticResource SliderTemplate}">
+                     </Slider>
+                  </Grid>
+               </Border>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml
index fa49a941..d4c7af8b 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RangeSlider/Themes/Generic.xaml
@@ -22,7 +22,6 @@
                     xmlns:conv="clr-namespace:Xceed.Wpf.Toolkit.Converters"
                     xmlns:coreConv="clr-namespace:Xceed.Wpf.Toolkit.Core.Converters">
 
-   <conv:SliderThumbWidthConverter x:Key="SliderThumbWidthConverter" />
    <coreConv:SolidColorBrushToColorConverter x:Key="SolidColorBrushToColorConverter" />
 
    <LinearGradientBrush x:Key="NormalThumbFillBackground"
@@ -80,123 +79,58 @@
          Repeat Button - This is used by RangeSlider for the LowerRange, Range, and HigherRange buttons -->
    <Style x:Key="DefaultRangeStyle"
           TargetType="{x:Type RepeatButton}">
+      <Setter Property="Focusable"
+              Value="False" />      
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type RepeatButton}">
                <Grid>
                   <Rectangle x:Name="MainBorder"
-                             Fill="Transparent"
-                             Opacity="1" />
+                             Fill="{TemplateBinding Background}"/>
                </Grid>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
    </Style>
 
-   <!-- ********************** -->
-   <!-- LowerThumb Template    -->
-   <!-- ********************** -->
-   <ControlTemplate x:Key="LowerThumbTemplate"
-                    TargetType="{x:Type Thumb}">
-      <Grid>
-         <Border x:Name="BackgroundFadingBorder"
-                 Background="Black" />
-         <Border x:Name="BackgroundBorder"
-                 BorderBrush="#FF929292"
-                 BorderThickness="1"
-                 CornerRadius="1">
-            <Rectangle x:Name="MainBorder"
-                       Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                       StrokeThickness="1"
-                       Stroke="White"
-                       Width="9"
-                       Height="20"
-                       Opacity="1"
-                       ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
-                       SnapsToDevicePixels="True" />
-         </Border>
-      </Grid>
-      <ControlTemplate.Triggers>
-         <Trigger Property="IsMouseOver"
-                  Value="True">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="0.9" />
-         </Trigger>
-         <Trigger Property="IsMouseCaptureWithin"
-                  Value="True">
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="0.8" />
-         </Trigger>
-         <MultiDataTrigger>
-            <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                          Value="{x:Null}" />
-               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                          Value="True" />
-            </MultiDataTrigger.Conditions>
-            <Setter Property="Opacity"
-                    TargetName="MainBorder"
-                    Value="1" />
-            <Setter Property="BorderBrush"
-                    TargetName="BackgroundBorder"
-                    Value="#FF3C7FB1" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="{StaticResource MouseOverThumbFillBackground}" />
-         </MultiDataTrigger>
-         <MultiDataTrigger>
-            <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                          Value="{x:Null}" />
-               <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
-                          Value="True" />
-            </MultiDataTrigger.Conditions>
-            <Setter Property="BorderBrush"
-                    TargetName="BackgroundBorder"
-                    Value="#FF2C628B" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="{StaticResource PressedThumbFillBackground}" />
-         </MultiDataTrigger>
-
-         <Trigger Property="IsEnabled"
-                  Value="False">
-            <Setter Property="BorderBrush"
-                    TargetName="BackgroundBorder"
-                    Value="#FFD7D7D7" />
-            <Setter Property="Fill"
-                    TargetName="MainBorder"
-                    Value="#FFF4F4F4" />
-            <Setter Property="Stroke"
-                    TargetName="MainBorder"
-                    Value="#FFD7D7D7" />
-         </Trigger>
-      </ControlTemplate.Triggers>
-   </ControlTemplate>
+   <!--//##TODODOC-->
+   <!--Since a thumb is pretty small, we put a bigger visual clue
+   outside the thumb bounds to give the user a hint where the focus is-->
+   <Style x:Key="ThumbFocusVisualStyle">
+      <Setter Property="Control.Template">
+         <Setter.Value>
+            <ControlTemplate>
+               <Rectangle Margin="-2"
+                          StrokeThickness="1"
+                          Stroke="Black"
+                          StrokeDashArray="1 2" />
+            </ControlTemplate>
+         </Setter.Value>
+      </Setter>
+   </Style>   
 
    <!-- ********************** -->
-   <!-- HigherThumb Template    -->
+   <!-- Thumb Template    -->
    <!-- ********************** -->
-   <ControlTemplate x:Key="HigherThumbTemplate"
+   <ControlTemplate x:Key="ThumbTemplate"
                     TargetType="{x:Type Thumb}">
       <Grid>
          <Border x:Name="BackgroundFadingBorder"
                  Background="Black" />
-         <Border x:Name="BackgroundBorder"
-                 BorderBrush="#FF929292"
-                 BorderThickness="1"
-                 CornerRadius="1">
-            <Rectangle x:Name="MainBorder"
-                       Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                       StrokeThickness="1"
-                       Stroke="White"
-                       Width="9"
-                       Height="20"
-                       ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                       SnapsToDevicePixels="True" />
-         </Border>
+            <Border x:Name="BackgroundBorder"
+                    BorderBrush="#FF929292"
+                    BorderThickness="1"
+                    CornerRadius="1">
+               <Rectangle x:Name="MainBorder"
+                          Fill="{Binding Background, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource NormalThumbFillBackground}}"
+                          StrokeThickness="1"
+                          Stroke="White"
+                          Width="9"
+                          Height="20"
+                          Opacity="1"
+                          ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Value, StringFormat=\{0:00.00\}}"
+                          SnapsToDevicePixels="True" />
+            </Border>
       </Grid>
       <ControlTemplate.Triggers>
          <Trigger Property="IsMouseOver"
@@ -211,9 +145,18 @@
                     TargetName="MainBorder"
                     Value="0.8" />
          </Trigger>
+         <DataTrigger Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type Slider}}, Path=Orientation}"
+                      Value="Vertical">
+            <Setter TargetName="MainBorder"
+                    Property="Width"
+                    Value="20" />
+            <Setter TargetName="MainBorder"
+                    Property="Height"
+                    Value="9" />
+         </DataTrigger>
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background}"
                           Value="{x:Null}" />
                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
                           Value="True" />
@@ -230,7 +173,7 @@
          </MultiDataTrigger>
          <MultiDataTrigger>
             <MultiDataTrigger.Conditions>
-               <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
+               <Condition Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Background}"
                           Value="{x:Null}" />
                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
                           Value="True" />
@@ -259,412 +202,167 @@
    </ControlTemplate>
 
    <!-- ********************** -->
-   <!-- LowerSlider Template     -->
+   <!-- Slider Template     -->
    <!-- ********************** -->
-   <ControlTemplate x:Key="LowerSliderTemplate"
+   <ControlTemplate x:Key="SliderTemplate"
                     TargetType="{x:Type Slider}">
       <Border SnapsToDevicePixels="true"
               BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
-            <Grid.RowDefinitions>
-               <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
-               <RowDefinition Height="Auto" />
-            </Grid.RowDefinitions>
-
-            <Track x:Name="PART_Track"
-                   Grid.Row="1">
-               <Track.Thumb>
-                  <Thumb x:Name="Thumb"
-                         Template="{StaticResource LowerThumbTemplate}">
-                  </Thumb>
-               </Track.Thumb>
-            </Track>
-         </Grid>
+         <Track x:Name="PART_Track"
+                Orientation="{TemplateBinding Orientation}">
+            <Track.Thumb>
+               <Thumb x:Name="thumb" 
+                      Focusable="True"
+                      FocusVisualStyle="{StaticResource ThumbFocusVisualStyle}"
+                      Background="{TemplateBinding Background}"
+                      Template="{StaticResource ThumbTemplate}">
+               </Thumb>
+            </Track.Thumb>
+         </Track>
       </Border>
    </ControlTemplate>
 
    <!-- ********************** -->
-   <!-- HigherSlider Template   -->
+   <!-- Vertical RangeSlider Template -->
    <!-- ********************** -->
-   <ControlTemplate x:Key="HigherSliderTemplate"
-                    TargetType="{x:Type Slider}">
-      <Border SnapsToDevicePixels="true"
-              BorderBrush="{TemplateBinding BorderBrush}"
-              BorderThickness="{TemplateBinding BorderThickness}">
-         <Grid>
+   <ControlTemplate x:Key="VerticalRangeSlider"
+                    TargetType="{x:Type local:RangeSlider}">
+      <Border BorderBrush="{TemplateBinding BorderBrush}"
+              BorderThickness="{TemplateBinding BorderThickness}"
+              Background="{TemplateBinding Background}">
+         <Grid HorizontalAlignment="Left"
+               VerticalAlignment="Top">
+            <!-- //#TODODOC 
+             Get Thumbs's height to set the good RangeSlider height.-->
             <Grid.RowDefinitions>
+               <!-- 11 is equal to the width of the horizontal slider thumb, (or the height of the vertical slider thumb)
+               See Thumb template -->
+               <RowDefinition Height="11" />
+               <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
-               <RowDefinition Height="Auto"
-                              MinHeight="{TemplateBinding MinHeight}" />
                <RowDefinition Height="Auto" />
+               <RowDefinition Height="11" />
             </Grid.RowDefinitions>
 
-            <Track x:Name="PART_Track"
-                   Grid.Row="1">
-               <Track.Thumb>
-                  <Thumb x:Name="Thumb"
-                         Template="{StaticResource HigherThumbTemplate}" />
-               </Track.Thumb>
-            </Track>
+            <Border Grid.Row="1"
+                    Grid.RowSpan="3"
+                    BorderThickness="1"
+                    BorderBrush="{StaticResource SliderVerticalBorderBrush}"
+                    Background="#FFE7EAEA"
+                    VerticalAlignment="Stretch"
+                    HorizontalAlignment="Center"
+                    Width="4" />
+
+            <RepeatButton x:Name="PART_LowerRange"
+                          Height="{TemplateBinding LowerRangeWidth}"
+                          Grid.Row="3"
+                          Background="{TemplateBinding LowerRangeBackground}"
+                          Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton Height="{TemplateBinding RangeWidth}"
+                          Grid.Row="2"
+                          Background="{TemplateBinding RangeBackground}"
+                          Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <RepeatButton x:Name="PART_HigherRange"
+                          Height="{TemplateBinding HigherRangeWidth}"
+                          Grid.Row="1"
+                          Background="{TemplateBinding HigherRangeBackground}"
+                          Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                          SnapsToDevicePixels="True" />
+
+            <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
+            <Slider x:Name="PART_LowerSlider"
+                    Orientation="Vertical"
+                    Grid.RowSpan="5"
+                    Focusable="False"
+                    Background="{TemplateBinding LowerThumbBackground}"
+                    Template="{StaticResource SliderTemplate}" />
+
+            <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+            <Slider x:Name="PART_HigherSlider"
+                    Grid.RowSpan="5"
+                    Orientation="Vertical"
+                    Focusable="False"
+                    Background="{TemplateBinding HigherThumbBackground}"
+                    Template="{StaticResource SliderTemplate}" />
          </Grid>
       </Border>
    </ControlTemplate>
 
-   <!-- ********************** -->
-   <!-- Vertical RangeSlider Template -->
-   <!-- ********************** -->
-   <ControlTemplate x:Key="VerticalRangeSlider"
-                    TargetType="{x:Type local:RangeSlider}">
-      <Grid Width="50">
-         <!-- //#TODODOC 
-             Get Thumbs's height to set the good RangeSlider height.-->
-         <Grid.RowDefinitions>
-            <RowDefinition Height="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=1}" />
-         </Grid.RowDefinitions>
-
-         <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="Auto" />
-            <ColumnDefinition Width="Auto"
-                              MinWidth="50" />
-         </Grid.ColumnDefinitions>
-
-         <Border Grid.Column="1"
-                 Grid.Row="1"
-                 Grid.RowSpan="3"
-                 BorderThickness="1"
-                 BorderBrush="{StaticResource SliderVerticalBorderBrush}"
-                 Background="#FFE7EAEA"
-                 VerticalAlignment="Stretch"
-                 HorizontalAlignment="Center"
-                 Width="4" />
-
-         <RepeatButton x:Name="PART_LowerRange"
-                       Height="{TemplateBinding LowerRangeWidth}"
-                       Width="15"
-                       Grid.Column="1"
-                       Grid.Row="3"
-                       Background="{TemplateBinding LowerRangeBackground}"
-                       Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True" />
-
-         <RepeatButton Height="{TemplateBinding RangeWidth}"
-                       Width="15"
-                       Grid.Row="2"
-                       Grid.Column="1"
-                       Background="{TemplateBinding RangeBackground}"
-                       Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True" />
-
-         <RepeatButton x:Name="PART_HigherRange"
-                       Height="{TemplateBinding HigherRangeWidth}"
-                       Width="15"
-                       Grid.Row="1"
-                       Grid.Column="1"
-                       Background="{TemplateBinding HigherRangeBackground}"
-                       Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                       SnapsToDevicePixels="True" />
-
-         <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb Height -->
-         <Slider x:Name="PART_LowerSlider"
-                 Grid.Column="1"
-                 Orientation="Vertical"
-                 Grid.RowSpan="5"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Border x:Name="BackgroundFadingBorder"
-                                                  Background="Black"
-                                                  Width="22" />
-                                          <Border x:Name="BackgroundBorder"
-                                                  BorderBrush="#FF929292"
-                                                  BorderThickness="1"
-                                                  Width="22"
-                                                  CornerRadius="1">
-                                             <Rectangle x:Name="MainBorder"
-                                                        Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                                                        StrokeThickness="1"
-                                                        Stroke="White"
-                                                        Width="20"
-                                                        Height="9"
-                                                        ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerValue, StringFormat=\{0:00.00\}}"
-                                                        SnapsToDevicePixels="True" />
-                                          </Border>
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.9" />
-                                          </Trigger>
-                                          <Trigger Property="IsMouseCaptureWithin"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.8" />
-                                          </Trigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF3C7FB1" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource MouseOverThumbFillBackground}" />
-                                          </MultiDataTrigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=LowerThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF2C628B" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource PressedThumbFillBackground}" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FFD7D7D7" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF4F4F4" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD7D7D7" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-
-         <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-         <Slider x:Name="PART_HigherSlider"
-                 Grid.Column="1"
-                 Grid.RowSpan="5"
-                 Orientation="Vertical"
-                 Minimum="{TemplateBinding Minimum}"
-                 Maximum="{TemplateBinding Maximum}"
-                 Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-            <Slider.Template>
-               <ControlTemplate TargetType="{x:Type Slider}">
-                  <Border SnapsToDevicePixels="true"
-                          BorderBrush="{TemplateBinding BorderBrush}"
-                          BorderThickness="{TemplateBinding BorderThickness}">
-                     <Grid>
-                        <Track x:Name="PART_Track">
-                           <Track.Thumb>
-                              <Thumb x:Name="Thumb">
-                                 <Thumb.Template>
-                                    <ControlTemplate TargetType="{x:Type Thumb}">
-                                       <Grid>
-                                          <Border x:Name="BackgroundFadingBorder"
-                                                  Width="22"
-                                                  Background="Black" />
-                                          <Border x:Name="BackgroundBorder"
-                                                  BorderBrush="#FF929292"
-                                                  BorderThickness="1"
-                                                  Width="22"
-                                                  CornerRadius="1">
-                                             <Rectangle x:Name="MainBorder"
-                                                        Fill="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground, TargetNullValue={StaticResource NormalThumbFillBackground}}"
-                                                        StrokeThickness="1"
-                                                        Stroke="White"
-                                                        Width="20"
-                                                        Height="9"
-                                                        ToolTip="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherValue, StringFormat=\{0:00.00\}}"
-                                                        SnapsToDevicePixels="True" />
-                                          </Border>
-                                       </Grid>
-                                       <ControlTemplate.Triggers>
-                                          <Trigger Property="IsMouseOver"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.9" />
-                                          </Trigger>
-                                          <Trigger Property="IsMouseCaptureWithin"
-                                                   Value="True">
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="0.8" />
-                                          </Trigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseOver}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="Opacity"
-                                                     TargetName="MainBorder"
-                                                     Value="1" />
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF3C7FB1" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource MouseOverThumbFillBackground}" />
-                                          </MultiDataTrigger>
-                                          <MultiDataTrigger>
-                                             <MultiDataTrigger.Conditions>
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Path=HigherThumbBackground}"
-                                                           Value="{x:Null}" />
-                                                <Condition Binding="{Binding RelativeSource={RelativeSource Self}, Path=IsMouseCaptureWithin}"
-                                                           Value="True" />
-                                             </MultiDataTrigger.Conditions>
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FF2C628B" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="{StaticResource PressedThumbFillBackground}" />
-                                          </MultiDataTrigger>
-
-                                          <Trigger Property="IsEnabled"
-                                                   Value="False">
-                                             <Setter Property="BorderBrush"
-                                                     TargetName="BackgroundBorder"
-                                                     Value="#FFD7D7D7" />
-                                             <Setter Property="Fill"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFF4F4F4" />
-                                             <Setter Property="Stroke"
-                                                     TargetName="MainBorder"
-                                                     Value="#FFD7D7D7" />
-                                          </Trigger>
-                                       </ControlTemplate.Triggers>
-                                    </ControlTemplate>
-                                 </Thumb.Template>
-                              </Thumb>
-                           </Track.Thumb>
-                        </Track>
-                     </Grid>
-                  </Border>
-               </ControlTemplate>
-            </Slider.Template>
-         </Slider>
-      </Grid>
-   </ControlTemplate>
-
    <!-- ********************** -->
    <!-- RangeSlider Style -->
    <!-- ********************** -->
    <Style TargetType="{x:Type local:RangeSlider}">
+      <Setter Property="IsTabStop"
+              Value="False" />
       <Setter Property="Template">
          <Setter.Value>
             <ControlTemplate TargetType="{x:Type local:RangeSlider}">
-               <Grid>
-                  <Grid.RowDefinitions>
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto"
-                                    MinHeight="{TemplateBinding MinHeight}" />
-                     <RowDefinition Height="Auto" />
-                     <RowDefinition Height="Auto" />
-                  </Grid.RowDefinitions>
-
-                  <!-- //#TODODOC 
+               <Border BorderBrush="{TemplateBinding BorderBrush}"
+                       BorderThickness="{TemplateBinding BorderThickness}"
+                       Background="{TemplateBinding Background}">
+                  <Grid HorizontalAlignment="Left"
+                        VerticalAlignment="Top">
+
+                     <!-- //#TODODOC 
                         Get Thumbs's width to set the good RangeSlider width.-->
                   <Grid.ColumnDefinitions>
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_LowerSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
+                     <!-- 11 is equal to the width of the horizontal slider thumb, (or the height of the vertical slider thumb)
+                     See Thumb template -->
+                     <ColumnDefinition Width="11" />
                      <ColumnDefinition Width="Auto" />
                      <ColumnDefinition Width="Auto" />
                      <ColumnDefinition Width="Auto" />
-                     <ColumnDefinition Width="{Binding ., ElementName=PART_HigherSlider, Converter={StaticResource SliderThumbWidthConverter}, ConverterParameter=0}" />
+                     <ColumnDefinition Width="11" />
                   </Grid.ColumnDefinitions>
 
-                  <Border Grid.Row="1"
-                          Grid.Column="1"
-                          Grid.ColumnSpan="3"
-                          BorderThickness="1"
-                          BorderBrush="{StaticResource SliderBorderBrush}"
-                          Background="#FFE7EAEA"
-                          VerticalAlignment="Center"
-                          Height="4" />
-
-                  <RepeatButton x:Name="PART_LowerRange"
-                                Width="{TemplateBinding LowerRangeWidth}"
-                                Grid.Column="1"
-                                Grid.Row="1"
-                                Background="{TemplateBinding LowerRangeBackground}"
-                                Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <RepeatButton Width="{TemplateBinding RangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="2"
-                                Background="{TemplateBinding RangeBackground}"
-                                Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <RepeatButton x:Name="PART_HigherRange"
-                                Width="{TemplateBinding HigherRangeWidth}"
-                                Grid.Row="1"
-                                Grid.Column="3"
-                                Background="{TemplateBinding HigherRangeBackground}"
-                                Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
-                                SnapsToDevicePixels="True" />
-
-                  <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
-                  <Slider x:Name="PART_LowerSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource LowerSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=LowerValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-
-                  <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
-                  <Slider x:Name="PART_HigherSlider"
-                          Grid.Row="1"
-                          Grid.ColumnSpan="5"
-                          Template="{StaticResource HigherSliderTemplate}"
-                          Minimum="{TemplateBinding Minimum}"
-                          Maximum="{TemplateBinding Maximum}"
-                          Value="{Binding RelativeSource={RelativeSource AncestorType={x:Type local:RangeSlider}}, Mode=TwoWay, Path=HigherValue, StringFormat=\{0:00.00\}}">
-                  </Slider>
-               </Grid>
+                     <Border Grid.Column="1"
+                             Grid.ColumnSpan="3"
+                             BorderThickness="1"
+                             BorderBrush="{StaticResource SliderBorderBrush}"
+                             Background="#FFE7EAEA"
+                             VerticalAlignment="Center"
+                             Height="4" />
+
+                     <RepeatButton x:Name="PART_LowerRange"
+                                      Width="{TemplateBinding LowerRangeWidth}"
+                                      Grid.Column="1"
+                                      Background="{TemplateBinding LowerRangeBackground}"
+                                      Style="{Binding LowerRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                      SnapsToDevicePixels="True" />
+
+                     <RepeatButton Width="{TemplateBinding RangeWidth}"
+                                   Grid.Column="2"
+                                   Background="{TemplateBinding RangeBackground}"
+                                   Style="{Binding RangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                   SnapsToDevicePixels="True" />
+
+                     <RepeatButton x:Name="PART_HigherRange"
+                                      Width="{TemplateBinding HigherRangeWidth}"
+                                      Grid.Column="3"
+                                      Background="{TemplateBinding HigherRangeBackground}"
+                                      Style="{Binding HigherRangeStyle, RelativeSource={RelativeSource TemplatedParent}, TargetNullValue={StaticResource DefaultRangeStyle}}"
+                                      SnapsToDevicePixels="True" />
+
+                     <!-- Margin is set in CodeBehind, based on HigherSlider's Thumb width -->
+                     <Slider x:Name="PART_LowerSlider"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding LowerThumbBackground}"
+                             Template="{StaticResource SliderTemplate}" />
+
+                     <!-- Margin is set in CodeBehind, based on LowerSlider's Thumb width -->
+                     <Slider x:Name="PART_HigherSlider"
+                             Grid.ColumnSpan="5"
+                             Focusable="False"
+                             Background="{TemplateBinding HigherThumbBackground}"
+                             Template="{StaticResource SliderTemplate}" />
+                  </Grid>
+               </Border>
             </ControlTemplate>
          </Setter.Value>
       </Setter>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs
index edc7de1f..5b8a9752 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/RichTextBoxFormatBar/RichTextBoxFormatBarManager.cs
@@ -79,18 +79,21 @@ namespace Xceed.Wpf.Toolkit
     {
       if( e.ChangedButton == MouseButton.Left && e.LeftButton == MouseButtonState.Released )
       {
-        TextRange selectedText = new TextRange( _richTextBox.Selection.Start, _richTextBox.Selection.End );
+        if( !_richTextBox.IsReadOnly )
+        {
+          TextRange selectedText = new TextRange( _richTextBox.Selection.Start, _richTextBox.Selection.End );
 #if !VS2008
-        if( selectedText.Text.Length > 0 && !String.IsNullOrWhiteSpace( selectedText.Text ) )
-          ShowAdorner();
+          if( selectedText.Text.Length > 0 && !String.IsNullOrWhiteSpace( selectedText.Text ) )
+            ShowAdorner();
 #else
-        if( selectedText.Text.Length > 0 && !String.IsNullOrEmpty( selectedText.Text ) )
-          ShowAdorner();
+          if( selectedText.Text.Length > 0 && !String.IsNullOrEmpty( selectedText.Text ) )
+            ShowAdorner();
 #endif
-        else
-          HideAdorner();
+          else
+            HideAdorner();
 
-        e.Handled = true;
+          e.Handled = true;
+        }
       }
       else
         HideAdorner();
diff --git a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs
similarity index 92%
rename from ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs
rename to ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs
index 325edc66..5d2139ad 100644
--- a/ExtendedWPFToolkitSolution/Src/Xceed.Wpf.Toolkit/StylableWindow/Implementation/Converters/StylableWindowClippingBorderConverter.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/StyleableWindow/Implementation/Converters/StyleableWindowClippingBorderConverter.cs
@@ -24,7 +24,7 @@ using System.Windows;
 
 namespace Xceed.Wpf.Toolkit.Converters
 {
-  public class StylableWindowClippingBorderConverter : IValueConverter
+  public class StyleableWindowClippingBorderConverter : IValueConverter
   {
     public object Convert( object value, Type targetType, object parameter, CultureInfo culture )
     {
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml
index ee4660dd..0d24459a 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Themes/Aero2/Common.xaml
@@ -40,7 +40,7 @@
 
     <!-- =============================================================================== -->
     <!-- Common Styles                                                                   -->
-    <!-- Need to find a way to share these for WindowControl and StylableWindow          -->
+   <!-- Need to find a way to share these for WindowControl and StyleableWindow          -->
     <!-- =============================================================================== -->
 
     <!-- ResizeGrip -->
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs
index b84501bf..0a374652 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Implementation/TimePicker.cs
@@ -227,6 +227,53 @@ namespace Xceed.Wpf.Toolkit
 
     #endregion //IsOpen
 
+    #region Kind
+
+    public static readonly DependencyProperty KindProperty = DependencyProperty.Register( "Kind", typeof( DateTimeKind ), typeof( TimePicker ),
+      new FrameworkPropertyMetadata( DateTimeKind.Unspecified, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault ) );
+    public DateTimeKind Kind
+    {
+      get
+      {
+        return ( DateTimeKind )GetValue( KindProperty );
+      }
+      set
+      {
+        SetValue( KindProperty, value );
+      }
+    }
+
+    #endregion //Kind
+
+    #region MaxDropDownHeight
+
+    public static readonly DependencyProperty MaxDropDownHeightProperty = DependencyProperty.Register( "MaxDropDownHeight", typeof( double ), typeof( TimePicker ), new UIPropertyMetadata( 130d, OnMaxDropDownHeightChanged ) );
+    public double MaxDropDownHeight
+    {
+      get
+      {
+        return ( double )GetValue( MaxDropDownHeightProperty );
+      }
+      set
+      {
+        SetValue( MaxDropDownHeightProperty, value );
+      }
+    }
+
+    private static void OnMaxDropDownHeightChanged( DependencyObject o, DependencyPropertyChangedEventArgs e )
+    {
+      TimePicker timePicker = o as TimePicker;
+      if( timePicker != null )
+        timePicker.OnMaxDropDownHeightChanged( ( double )e.OldValue, ( double )e.NewValue );
+    }
+
+    protected virtual void OnMaxDropDownHeightChanged( double oldValue, double newValue )
+    {
+      // TODO: Add your property changed side-effects. Descendants can override as well.
+    }
+
+    #endregion
+
     #region Maximum
 
     public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register( "Maximum", typeof( DateTime? ), typeof( TimePicker ), new UIPropertyMetadata( DateTime.MaxValue ) );
@@ -554,9 +601,9 @@ namespace Xceed.Wpf.Toolkit
       {
         TimeItem selectedTimeListItem = ( TimeItem )e.AddedItems[ 0 ];
         var time = selectedTimeListItem.Time;
-        var date = Value ?? DateTime.MinValue;
+        var date = Value ?? DateTimeUtilities.GetContextNow( this.Kind );
 
-        Value = new DateTime( date.Year, date.Month, date.Day, time.Hours, time.Minutes, time.Seconds, time.Milliseconds );
+        Value = new DateTime( date.Year, date.Month, date.Day, time.Hours, time.Minutes, time.Seconds, time.Milliseconds, date.Kind );
       }
     }
 
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml
index 0e1c2a54..8fc0ffb3 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Aero2.NormalColor.xaml
@@ -141,6 +141,7 @@
                                               Format="{TemplateBinding Format, Converter={StaticResource TimeFormatToDateTimeFormatConverter}}"
                                               FormatString="{TemplateBinding FormatString}"
                                               ShowButtonSpinner="{TemplateBinding ShowButtonSpinner}"
+                                              Kind="{Binding Kind, RelativeSource={RelativeSource TemplatedParent}}"
                                               Value="{Binding Value, RelativeSource={RelativeSource TemplatedParent}}"
                                               Minimum="{Binding Minimum, RelativeSource={RelativeSource TemplatedParent}}"
                                               Maximum="{Binding Maximum, RelativeSource={RelativeSource TemplatedParent}}"
@@ -163,7 +164,7 @@
                                         <ListBox x:Name="PART_TimeListItems"
                                        BorderThickness="0"
                                        Width="150"
-                                       Height="130"
+                                       Height="{TemplateBinding MaxDropDownHeight}"
                                        DisplayMemberPath="Display"
                                        ItemContainerStyle="{StaticResource TimeItemStyle}" />
                                     </Grid>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml
index e783d03c..354ebd05 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimePicker/Themes/Generic.xaml
@@ -134,6 +134,7 @@
                                               Format="{TemplateBinding Format, Converter={StaticResource TimeFormatToDateTimeFormatConverter}}"
                                               FormatString="{TemplateBinding FormatString}"
                                               ShowButtonSpinner="{TemplateBinding ShowButtonSpinner}"
+                                              Kind="{Binding Kind, RelativeSource={RelativeSource TemplatedParent}}"
                                               Value="{Binding Value, RelativeSource={RelativeSource TemplatedParent}}"
                                               Minimum="{Binding Minimum, RelativeSource={RelativeSource TemplatedParent}}"
                                               Maximum="{Binding Maximum, RelativeSource={RelativeSource TemplatedParent}}"
@@ -156,7 +157,7 @@
                               <ListBox x:Name="PART_TimeListItems"
                                        BorderThickness="0"
                                        Width="150"
-                                       Height="130"
+                                       Height="{TemplateBinding MaxDropDownHeight}"
                                        DisplayMemberPath="Display"
                                        ItemContainerStyle="{StaticResource TimeItemStyle}" />
                            </Grid>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml
index b0a95844..0018f640 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Aero2.NormalColor.xaml
@@ -70,7 +70,6 @@
                                                 FontWeight="{TemplateBinding FontWeight}"
                                                 Foreground="{TemplateBinding Foreground}"
                                                 HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                                IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                                 MinWidth="20"
                                                 AcceptsReturn="False"
                                                 Padding="{TemplateBinding Padding}"
@@ -87,7 +86,24 @@
                             <Setter Property="BorderBrush"
                                     Value="{DynamicResource {x:Static themes:ResourceKeys.ControlMouseOverBorderKey}}" />
                         </Trigger>
-                        <Trigger Property="IsKeyboardFocusWithin"
+                     <MultiDataTrigger>
+                        <MultiDataTrigger.Conditions>
+                           <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                           <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                      Value="False" />
+                        </MultiDataTrigger.Conditions>
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </MultiDataTrigger>
+                     <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                  Value="True">
+                        <Setter Property="IsReadOnly"
+                                Value="True"
+                                TargetName="PART_TextBox" />
+                     </DataTrigger>
+                     <Trigger Property="IsKeyboardFocusWithin"
                                  Value="True">
                             <Setter Property="BorderBrush"
                                     Value="{DynamicResource {x:Static themes:ResourceKeys.ControlSelectedBorderKey}}" />
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml
index 4a8a3cb7..14644f9f 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/TimeSpanUpDown/Themes/Generic.xaml
@@ -69,7 +69,6 @@
                                                 FontWeight="{TemplateBinding FontWeight}"
                                                 Foreground="{TemplateBinding Foreground}"
                                                 HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
-                                                IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}"
                                                 MinWidth="20"
                                                 AcceptsReturn="False"
                                                 Padding="{TemplateBinding Padding}"
@@ -81,6 +80,23 @@
                                                 WatermarkTemplate="{TemplateBinding WatermarkTemplate}" />
                     </local:ButtonSpinner>
                     <ControlTemplate.Triggers>
+                        <MultiDataTrigger>
+                           <MultiDataTrigger.Conditions>
+                              <Condition Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                         Value="False" />
+                              <Condition Binding="{Binding AllowTextInput, RelativeSource={RelativeSource Self}}"
+                                         Value="False" />
+                           </MultiDataTrigger.Conditions>
+                           <Setter Property="IsReadOnly"
+                                   Value="True"
+                                   TargetName="PART_TextBox" />
+                        </MultiDataTrigger>
+                        <DataTrigger Binding="{Binding IsReadOnly, RelativeSource={RelativeSource Self}}"
+                                     Value="True">
+                           <Setter Property="IsReadOnly"
+                                   Value="True"
+                                   TargetName="PART_TextBox" />
+                        </DataTrigger>
                         <Trigger Property="IsFocused"
                                  Value="True">
                             <Setter TargetName="PART_TextBox"
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs
index a852fbd2..31735a9d 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Wizard/Implementation/Wizard.cs
@@ -15,6 +15,7 @@
   ***********************************************************************************/
 
 using System;
+using System.Collections.Specialized;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
@@ -331,6 +332,17 @@ namespace Xceed.Wpf.Toolkit
         CurrentPage = Items[ 0 ] as WizardPage;
     }
 
+    protected override void OnItemsChanged( NotifyCollectionChangedEventArgs e )
+    {
+      base.OnItemsChanged( e );
+
+      foreach( object o in this.Items )
+      {
+        if( !( o is WizardPage ) )
+          throw new NotSupportedException( "Wizard should only contains WizardPages." );
+      }
+    }
+
     protected override void OnPropertyChanged( DependencyPropertyChangedEventArgs e )
     {
       base.OnPropertyChanged( e );
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj
index 15bffaf8..27805104 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Xceed.Wpf.Toolkit.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
+    <ProductVersion>9.0.30729</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{2C3149D9-832B-4754-A27B-898A392344B5}</ProjectGuid>
     <OutputType>library</OutputType>
@@ -404,6 +404,7 @@
     <Compile Include="Core\Converters\CornerRadiusToDoubleConverter.cs" />
     <Compile Include="Core\Converters\IntToThicknessConverter.cs" />
     <Compile Include="Core\Converters\ThicknessToDoubleConverter.cs" />
+    <Compile Include="PropertyGrid\Implementation\Converters\IsStringEmptyConverter.cs" />
     <Compile Include="PropertyGrid\Implementation\Editors\CollectionEditor.cs" />
     <Compile Include="Core\Converters\WindowContentBorderMarginConverter.cs" />
     <Compile Include="Core\Converters\WindowControlBackgroundConverter.cs" />
@@ -606,7 +607,7 @@
     <Compile Include="Core\Primitives\UpDownBase.cs" />
     <Compile Include="SplitButton\Implementation\SplitButton.cs" />
     <Compile Include="Core\Themes\ResourceKeys.cs" />
-    <Compile Include="StylableWindow\Implementation\Converters\StylableWindowClippingBorderConverter.cs" />
+    <Compile Include="StyleableWindow\Implementation\Converters\StyleableWindowClippingBorderConverter.cs" />
     <Compile Include="TimelinePanel\Implementation\DateElement.cs" />
     <Compile Include="TimelinePanel\Implementation\OverlapBehavior.cs" />
     <Compile Include="TimelinePanel\Implementation\TimelinePanel.cs" />
@@ -744,9 +745,9 @@
     <Resource Include="Themes\Generic\Images\restore_pressed.png" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Core\Utilities\DateTimeUtilities.cs" />
     <Compile Include="PropertyGrid\Implementation\Definitions\DefinitionBase.cs" />
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
   </PropertyGroup>
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml
index a3a78c96..ecf3da20 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Aero2.NormalColor.xaml
@@ -333,7 +333,7 @@
 
     <Style x:Key="{x:Type local:Zoombox}" TargetType="{x:Type local:Zoombox}">
         <Setter Property="Background" Value="Transparent" />
-        <Setter Property="Foreground" Value="White" />
+        <Setter Property="Foreground" Value="Black" />
         <Setter Property="PanDistance" Value="5.0" />
         <Setter Property="ZoomOrigin" Value="0.5,0.5" />
         <Setter Property="ZoomPercentage" Value="5.0" />
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml
index 0ebb9057..adfd6c01 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Themes/Generic.xaml
@@ -333,7 +333,7 @@
 
    <Style x:Key="{x:Type local:Zoombox}" TargetType="{x:Type local:Zoombox}">
       <Setter Property="Background" Value="Transparent" />
-      <Setter Property="Foreground" Value="White" />
+      <Setter Property="Foreground" Value="Black" />
       <Setter Property="PanDistance" Value="5.0" />
       <Setter Property="ZoomOrigin" Value="0.5,0.5" />
       <Setter Property="ZoomPercentage" Value="5.0" />
diff --git a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs
index 2ae3cbdb..7fb02dc8 100644
--- a/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs
+++ b/ExtendedWPFToolkitSolution_35/Src/Xceed.Wpf.Toolkit/Zoombox/Zoombox.cs
@@ -1907,10 +1907,11 @@ namespace Xceed.Wpf.Toolkit.Zoombox
       if( _content != null )
       {
         // measure visuals according to supplied constraint
-        base.MeasureOverride( constraint );
+        Size size = base.MeasureOverride( constraint );
 
         // now re-measure content to let the child be whatever size it desires
         _content.Measure( new Size( double.PositiveInfinity, double.PositiveInfinity ) );
+        return size;
       }
 
 
@@ -3342,7 +3343,7 @@ namespace Xceed.Wpf.Toolkit.Zoombox
         // adjust translateFrom based on relativeTo
         translateFrom = this.TranslatePoint( relativeTo, _contentPresenter );
       }
-      else
+      else if( _contentPresenter != null )
       {
         // prior to the first render, just use the ContentPresenter's transform and do not adjust translateFrom
         if( _contentPresenter.RenderTransform == Transform.Identity )