<telerik:GridViewDataColumn Width="100"
		DataMemberBinding="{Binding YearRange}"
		Header="Årgang">
	<telerik:GridViewDataColumn.FilteringControl>
		<local:CustomGridFilter Aargang="{Binding ElementName=root, Path=VintageYear, Mode=TwoWay}" />
	</telerik:GridViewDataColumn.FilteringControl>
</telerik:GridViewDataColumn>

public class YearRange : IEquatable<int>
{
    public int FromYear { get; set; }

    public int ToYear { get; set; }

    public int Year { get; set; }

    public override string ToString()
    {
        if (FromYear == ToYear)
            return FromYear.ToString();

        return FromYear + "-" + ToYear;
    }

  #region Equals, GetHashCode

  #region Comparison operators override
}

public partial class CustomGridFilter : UserControl, IFilteringControl, INotifyPropertyChanged
{
    private GridViewBoundColumnBase column;
    private CompositeFilterDescriptor compositeFilter;
    private FilterDescriptor rangeFilter;

    #region INotifyPropertyChanged

    public void OnPropertyChanged(string name) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));

    public event PropertyChangedEventHandler PropertyChanged;

    #endregion

    #region IsActive DependencyProperty 
    public bool IsActive
    {
        get { return (bool)GetValue(IsActiveProperty); }
        set { SetValue(IsActiveProperty, value); }
    }

    public static readonly DependencyProperty IsActiveProperty =
        DependencyProperty.Register(
            "IsActive",
            typeof(bool),
            typeof(CustomGridFilter),
            new PropertyMetadata(false));
    #endregion

    #region Aargang DependencyProperty 

    public int? Aargang
    {
        get { return (int?)GetValue(AargangProperty); }
        set { SetValue(AargangProperty, value); }
    }

    public static readonly DependencyProperty AargangProperty =
        DependencyProperty.Register(
            "Aargang",
            typeof(int?),
            typeof(CustomGridFilter),
            new PropertyMetadata(
                null,
                (sender, evt) => { ((CustomGridFilter)sender).OnPropertyChanged("Aargang"); }
            )
        );

    #endregion

    public CustomGridFilter()
    {
        InitializeComponent();

        DataContext = this;

        PropertyChanged += CustomGridFilter_PropertyChanged;
    }

    private void CustomGridFilter_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "Aargang" && Aargang>1900 && Aargang<2100)
        {
            OnFilter(null, null);
        }
    }

    public void Prepare(Telerik.Windows.Controls.GridViewColumn column)
    {
        this.column = column as GridViewBoundColumnBase;

        if (this.column == null)
        {
            return;
        }

        if (compositeFilter == null)
        {
            CreateFilters();
        }
    }

    private void CreateFilters()
    {
        string dataMember = column.DataMemberBinding.Path.Path;

        compositeFilter = new CompositeFilterDescriptor();

        rangeFilter = new FilterDescriptor(dataMember, FilterOperator.IsEqualTo, null);

        compositeFilter.FilterDescriptors.Add(rangeFilter);
    }

    private void OnFilter(object sender, RoutedEventArgs e)
    {
        rangeFilter.Value = new YearRange { Year = Aargang ?? 0 };

        if (!column.DataControl.FilterDescriptors.Contains(compositeFilter))
        {
            column.DataControl.FilterDescriptors.Add(compositeFilter);
        }

        IsActive = true;

        var popup = this.ParentOfType<System.Windows.Controls.Primitives.Popup>();
        if (popup != null)
        {
            popup.IsOpen = false;
        }
    }

    private void OnClear(object sender, RoutedEventArgs e)
    {
        if (column.DataControl.FilterDescriptors.Contains(compositeFilter))
        {
            column.DataControl.FilterDescriptors.Remove(compositeFilter);
        }

        Aargang = 0;

        IsActive = false;

        var popup = this.ParentOfType<System.Windows.Controls.Primitives.Popup>();
        if (popup != null)
        {
            popup.IsOpen = false;
        }
    }

}

		private void SetTableColumns(ObservableCollection<StatisticaTableViewPerClasse> elementi
			, IEnumerable<string> sorgentiNames
			, string columnClassHeader)
		{
			GridAnalisiStatisticaTable.Columns.Clear();
			GridAnalisiStatisticaTable.ColumnGroups.Clear();
			if (elementi.Count() > 0)
			{
				//var sorgenti = elementi.GroupBy(e => e.Sorgente.Id,
				//				e => e.Sorgente.Name,
				//				(id, name) => name).Select(s => s.FirstOrDefault());
				foreach (var sorgenteName in sorgentiNames)
				{
					var groupName = GROUPNAME + sorgenteName;
					var group = new GridViewColumnGroup()
					{
						Header = sorgenteName,
						Name = groupName,
						
					};
					GridAnalisiStatisticaTable.ColumnGroups.Add(group); 
					//GridAnalisiStatisticaTable.Columns.Add(new GridViewDataColumn()
					//{
					//	Header = Utility.LoadString(ResourcesKeys.SorgenteColumnHeader),
					//	DataMemberBinding = new Binding("Sorgente.Name"),
					//	ColumnGroupName = groupName
					//});
					GridAnalisiStatisticaTable.Columns.Add(new GridViewDataColumn()
					{
						Header = columnClassHeader,
						DataMemberBinding = new Binding("ClasseHeader"),
						ColumnGroupName = groupName
					});
					GridAnalisiStatisticaTable.Columns.Add(new GridViewDataColumn()
					{
						Header = Utility.LoadString(ResourcesKeys.DistribuzioneProbabilitàHeader),
						DataMemberBinding = new Binding($"Values[{sorgenteName}].DistribuzioneValue")
						{
							StringFormat = "N2"
						},
						ColumnGroupName = groupName
					});
					GridAnalisiStatisticaTable.Columns.Add(new GridViewDataColumn()
					{
						Header = Utility.LoadString(ResourcesKeys.ProbabilitàCumulativaHeader),
						DataMemberBinding = new Binding($"Values[{sorgenteName}].CumulativaValue")
						{
							StringFormat = "N2"
						},
						ColumnGroupName = groupName
					});
				}
			}
		}

<t:RadGridView x:Name="GridAnalisiStatisticaTable" Grid.Row="1"
					   RowIndicatorVisibility="Collapsed"
					   AutoGenerateColumns="False"
						GroupRenderMode="Flat"
					   ShowGroupPanel="False"
						IsPropertyChangedAggregationEnabled="False"
					   ItemsSource="{Binding Statistiche}"/>

public class StatisticaTableView
	{
		public StatisticaTableView(KeyValuePair<decimal, double> entry, StatisticType type)
		{
			switch (type)
			{
				case StatisticType.DistribuzioneProbabilità:
					DistribuzioneValue = entry.Value;
					break;
				case StatisticType.ProbabilitàCumulativa:
					CumulativaValue = entry.Value;
					break;
				case StatisticType.LivelliPercentili:
					break;
				case StatisticType.DistribuzioneTemporale:
					break;
				default:
					break;
			}
		}
		public double DistribuzioneValue { get; set; }
		public double CumulativaValue { get; set; }
	}
	public class StatisticaTableViewPerClasse
	{
		public StatisticaTableViewPerClasse(KeyValuePair<decimal, double> entry, decimal classRange, StatisticType type, string sorgenteName)
		{
			Classe = entry.Key;
			ClasseHeader = $"{entry.Key} - {entry.Key + classRange}";
			Values.Add(sorgenteName, new(entry, type));
		}
		public decimal Classe { get; set; }
		public string ClasseHeader { get; set; }
		public Dictionary<string, StatisticaTableView> Values { get; set; } = new();
	}

if (e.AddedItems.Count > 0)
            {
                foreach (NodesModel i in e.AddedItems)
                {
                    if (i.Name != "WHDLoad")
                    {
                        if (i.Items.Count > 0)
                        {
                            foreach (NodesModel x in i.Items)
                            {
                                {
                                    //x.IsSelected = true;
                                    Nodes.SelectedItems.Add(x);
                                }
                            }
                        }
                    }
                }
            }