Currently, you can only copy the contents of the data cells to the clipboard and it is not possible to include the column/row header names.

Consider the pivot PivotGrid >> Binding With RadChartView example in our demo application. RadChartView shows all cells that are selected and there is no api to interpolate or filter them.

Developers should be able to set the initial state for rows and columns in RadPivotGrid.

ADD. RadPivotGrid - add single selection mode and expose the selected cell in property

It should be possible to group the fields in the "Choose fields" are when using LocalDataSourceProvider because in some cases when you join a few tables, you might end up with a large number of fields.

ADD. RadPivotGrid - add ability to filter by more than one condition - composite filters

Currently the only way to recognize something changed as accurate as possible is to use StatusChanged on the DataProvider, but that does not tell apart from a structure change or just a click on the Update button… it would be nice to have such events available (onUpdate, onFieldListModified etc)

Drag the field contains date from field choicer control to Column data area. Then remove one of the sum field. The exception will thrown.

Workaround: Use the DLLs for NET2.0

AutoSizeRows property which allows autosizing both header rows and data rows.

GroupDescriptions loose the Custom Name after dragging.

Change the Decimal symbol/separator  to "," and run Excel export for the RadPivotGrid. Note that all "0,00" cells are displayed as "1" in Excel and all decimal values are displayed without decimal separator.

Another scenario is when you change the Format in the Regional settings to Russia. Then, when exporting data, the decimal separator for the GrandTotal column is not correct ".", instead of ",". However, for the data cells it is OK.

Currently the words: Row, Column and Value are not localizable in the ScreenTip.

Currently they can be localized as follows:

void radPivotGrid1_ScreenTipNeeded(object sender, Telerik.WinControls.ScreenTipNeededEventArgs e)
{
    PivotCellElement cell = e.Item as PivotCellElement;
    if (cell == null || cell.ScreenTip == null)
    {
        return;
    }
 
    RadOffice2007ScreenTipElement screenTip = cell.ScreenTip asRadOffice2007ScreenTipElement;
    screenTip.MainTextLabel.Text = screenTip.MainTextLabel.Text
        .Replace("Value:", "ChangedValue:")
        .Replace("Row:", "ChangedRow:")
        .Replace("Column:", "ReplacedColumn:");
}

Workaround:

public Form1()
{
    InitializeComponent();

    this.radPivotFieldList1.ValuesControl.CreatingVisualListItem += Aggregates_CreatingVisualListItem;
}

private void Aggregates_CreatingVisualListItem(object sender, Telerik.WinControls.UI.CreatingVisualListItemEventArgs args)
{
    args.VisualItem = new MyPivotFieldListVisualItem(this.radPivotFieldList1.ViewModel);
}

    public class MyPivotFieldListVisualItem : PivotFieldListVisualItem
    {
        private FieldListViewModel viewModel;
 
        private CommandBarDropDownButton button;
        private RadMenuItem sumMenuItem;
        private RadMenuItem avgMenuItem;
        private RadMenuItem countMenuItem;
 
        public MyPivotFieldListVisualItem(FieldListViewModel viewModel)
            : base(viewModel)
        {
            this.viewModel = viewModel;
        }
 
        protected override void CreateChildElements()
        {
            base.CreateChildElements();
 
            this.sumMenuItem = this.GetType().BaseType
                .GetField("sumMenuItem", BindingFlags.Instance | BindingFlags.NonPublic)
                .GetValue(this) as RadMenuItem;
 
            this.avgMenuItem = this.GetType().BaseType
              .GetField("avgMenuItem", BindingFlags.Instance | BindingFlags.NonPublic)
              .GetValue(this) as RadMenuItem;
 
            this.countMenuItem = this.GetType().BaseType
              .GetField("countMenuItem", BindingFlags.Instance | BindingFlags.NonPublic)
              .GetValue(this) as RadMenuItem;
 
            if (sumMenuItem != null && avgMenuItem != null && countMenuItem != null)
            {
                sumMenuItem.Click += OnAggregateFunctionClick;
                avgMenuItem.Click += OnAggregateFunctionClick;
                countMenuItem.Click += OnAggregateFunctionClick;
            }
 
            this.button = this.GetType().BaseType
             .GetField("button", BindingFlags.Instance | BindingFlags.NonPublic)
             .GetValue(this) as CommandBarDropDownButton;
 
            RadMenuItem aggregateOptionsMenuItem = this.GetType().BaseType
                .GetField("aggregateOptionsMenuItem", BindingFlags.Instance | BindingFlags.NonPublic)
                .GetValue(this) as RadMenuItem;
 
            aggregateOptionsMenuItem.Click += aggregateOptionsMenuItem_Click;
 
            RadMenuItem numberFormatMenuItem = this.GetType().BaseType
                .GetField("numberFormatMenuItem", BindingFlags.Instance | BindingFlags.NonPublic)
                .GetValue(this) as RadMenuItem;
 
            numberFormatMenuItem.Click += numberFormatMenuItem_Click;
        }
 
        private void numberFormatMenuItem_Click(object sender, EventArgs e)
        {
            Value value = (this.Data.DataBoundItem as Value);
            if (value == null)
            {
                return;
            }
 
            MyNumberFormatOptionsDialog dialog =  new MyNumberFormatOptionsDialog();
            dialog.ThemeName = this.GetThemeName();
 
            QueryableAggregateDescription queryableAggregateDescription = (value.Description as QueryableAggregateDescription);
            if (queryableAggregateDescription != null)
            {
                dialog.LoadQueryableSettings(queryableAggregateDescription);
            }
 
            System.Windows.Forms.DialogResult result = dialog.ShowDialog();
 
            if (result == System.Windows.Forms.DialogResult.OK)
            {
                queryableAggregateDescription.StringFormat = dialog.SelectedStringFormat;
                this.viewModel.ExecuteUpdate();
            }
        }
 
        private void aggregateOptionsMenuItem_Click(object sender, EventArgs e)
        {
            MyAggregateOptionsDialog dialog = new MyAggregateOptionsDialog();
            dialog.ThemeName = this.GetThemeName();
 
            Value value = (this.Data.DataBoundItem as Value);
            if (value != null)
            {
                QueryablePropertyAggregateDescriptionBase queryableAggregateDescription = (value.Description as QueryablePropertyAggregateDescriptionBase);
                if (queryableAggregateDescription != null)
                {
                    dialog.LoadQueryableSettings(queryableAggregateDescription);
                }
 
                System.Windows.Forms.DialogResult result = dialog.ShowDialog();
                if (result == System.Windows.Forms.DialogResult.OK)
                {
                    queryableAggregateDescription.AggregateFunction = dialog.SelectedQueryableAggregateFunction;
                    queryableAggregateDescription.CustomName = dialog.CustomName;
 
                    this.Synchronize();
                    this.viewModel.ExecuteUpdate();
                }
            }
        }
 
        private void OnAggregateFunctionClick(object sender, EventArgs e)
        {
            Value value = (this.Data.DataBoundItem as Value);
            string function = ((RadMenuItem)sender).Text;
 
            if (value != null && this.SetNewAggregateFunction(value.Description, function))
            {
                this.Synchronize();
                this.viewModel.ExecuteUpdate();
            }
        }
 
        private bool SetNewAggregateFunction(IAggregateDescription description, string function)
        {
            QueryablePropertyAggregateDescriptionBase queryableDescription = (description as QueryablePropertyAggregateDescriptionBase);
            if (queryableDescription != null)
            {
                switch (function)
                {
                    case "Sum":
                        queryableDescription.AggregateFunction = QueryableAggregateFunction.Sum;
                        break;
                    case "Count":
                        queryableDescription.AggregateFunction = QueryableAggregateFunction.Count;
                        break;
                    case "Average":
                        queryableDescription.AggregateFunction = QueryableAggregateFunction.Average;
                        break;
                    default:
                        return false;
                }
 
                return true;
            }
 
            return false;
        }
 
        protected override void SynchronizeProperties()
        {
            base.SynchronizeProperties();
 
            Value value = (this.Data.DataBoundItem as Value);
            Label label = (this.Data.DataBoundItem as Label);
 
            if (value != null)
            {
#if !NETFX2
                QueryablePropertyAggregateDescription queryableDescription = (value.Description as QueryablePropertyAggregateDescription);
                if (queryableDescription != null)
                {
                    this.sumMenuItem.IsChecked = queryableDescription.AggregateFunction == QueryableAggregateFunction.Sum;
                    this.countMenuItem.IsChecked = queryableDescription.AggregateFunction == QueryableAggregateFunction.Count;
                    this.avgMenuItem.IsChecked = queryableDescription.AggregateFunction == QueryableAggregateFunction.Average;
                }
#endif
            }
        }
 
        private string GetThemeName()
        {
            if (this.ElementTree == null)
            {
                return string.Empty;
            }
 
            RadControl control = this.ElementTree.Control as RadControl;
 
            return control != null ? control.ThemeName : string.Empty;
        }
    }
 
public class MyAggregateOptionsDialog : AggregateOptionsDialog
    {
        private RadListControl listAggregateFunctions;
        private RadLabel labelFieldName;
        private RadTextBox textBoxCustomName;

        public MyAggregateOptionsDialog()
        {
            this.listAggregateFunctions = this.GetType().BaseType
               .GetField("listAggregateFunctions", BindingFlags.Instance | BindingFlags.NonPublic)
               .GetValue(this) as RadListControl;

            this.labelFieldName = this.GetType().BaseType
                .GetField("labelFieldName", BindingFlags.Instance | BindingFlags.NonPublic)
                .GetValue(this) as RadLabel;

            this.textBoxCustomName = this.GetType().BaseType
                .GetField("textBoxCustomName", BindingFlags.Instance | BindingFlags.NonPublic)
                .GetValue(this) as RadTextBox;
        }

        private readonly IList<QueryableAggregateFunction> availableQueryableAggregateFunctions = new List<QueryableAggregateFunction>()
            {
                QueryableAggregateFunction.Sum,
                QueryableAggregateFunction.Count,
                QueryableAggregateFunction.Average,
                QueryableAggregateFunction.Max,
                QueryableAggregateFunction.Min
            };

        public virtual QueryableAggregateFunction SelectedQueryableAggregateFunction
        {
            get
            {
                return (QueryableAggregateFunction)this.listAggregateFunctions.SelectedValue;
            }
        }

        public virtual void LoadQueryableSettings(QueryablePropertyAggregateDescriptionBase aggregateDescription)
        {
            if (this.listAggregateFunctions.DataSource != null)
            {
                this.listAggregateFunctions.DataSource = availableQueryableAggregateFunctions;
            }

            this.listAggregateFunctions.SelectedValue = aggregateDescription.AggregateFunction;
            this.labelFieldName.Text = aggregateDescription.PropertyName;
            this.Text = String.Format("{0}{1}{2}", "Aggregate Options (", aggregateDescription.PropertyName, ")");
            this.textBoxCustomName.Text = aggregateDescription.CustomName;
        }
    }

public class MyNumberFormatOptionsDialog : NumberFormatOptionsDialog
    {
        private TextBox textBox;

        public MyNumberFormatOptionsDialog()
        {
            RadDropDownList dropDownListFormat = this.GetType().BaseType
                   .GetField("dropDownListFormat", BindingFlags.Instance | BindingFlags.NonPublic)
                   .GetValue(this) as RadDropDownList;

            this.textBox = (TextBox)dropDownListFormat.DropDownListElement.EditableElement.TextBox.TextBoxItem.HostedControl;
        }

        public virtual void LoadQueryableSettings(QueryableAggregateDescriptionBase aggregateDescription)
        {
            this.textBox.Text = aggregateDescription.StringFormat;
            this.Text = String.Format(PivotGridLocalizationProvider.CurrentProvider.GetLocalizedString(PivotStringId.NumberFormatOptionsDialogFormatOptionsDescription),
                aggregateDescription.DisplayName);
            this.textBox.Select(this.textBox.Text.Length, 0);
            this.textBox.Focus();
        }
    }

Until the feature becomes available use the following workaround:

MyPivotGridChartDataProvider chartProvider = new MyPivotGridChartDataProvider(this.radPivotGrid1.PivotGridElement);
this.radPivotGrid1.ChartDataProvider = chartProvider;
this.radChartView1.DataSource = this.radPivotGrid1;
this.radChartView1.ShowLegend = true;
this.radPivotGrid1.ChartDataProvider.SeriesAxis = Telerik.Pivot.Core.PivotAxis.Rows;
this.radPivotGrid1.ChartDataProvider.GeneratedSeriesType = Telerik.WinControls.UI.GeneratedSeriesType.Line;

public class MyPivotGridChartDataProvider : PivotGridChartDataProvider
{
    public MyPivotGridChartDataProvider(RadPivotGridElement pivotGridElement)
        : base(pivotGridElement) { }

    public override void UpdateChartData()
    {
        base.UpdateChartData();

        foreach (ChartSeries series in this.ChartView.Series)
        {
            CartesianSeries cartesianSeries = series as CartesianSeries;
            if (cartesianSeries == null)
            {
                continue;
            }

            cartesianSeries.PointSize = new SizeF(7, 7);

            BindingList<PivotChartModelPoint> newData = new BindingList<PivotChartModelPoint>();
            BindingList<PivotDataPoint> points = cartesianSeries.DataSource as BindingList<PivotDataPoint>;

            foreach (PivotDataPoint point in points)
            {
                PivotChartModelPoint current = new PivotChartModelPoint() { Group = point.PivotGroup };
                if (point.Value != 0)
                {
                    current.Value = point.Value;
                }
                else
                {
                    current.Value = null;
                }

                newData.Add(current);
            }

            cartesianSeries.DataSource = null;

            cartesianSeries.CategoryMember = "Group";
            cartesianSeries.ValueMember = "Value";
            cartesianSeries.DataSource = newData;
        }
    }
}

public class PivotChartModelPoint
{
    public string Group{ get; set; }

    public double? Value { get; set; }
}

Workaround: If possible add the label filters with code
PropertyGroupDescription dateGroupDescription = new PropertyGroupDescription();
dateGroupDescription.PropertyName = "Date";

LabelGroupFilter filter = new LabelGroupFilter();
ComparisonCondition condition = new ComparisonCondition
{
    Condition = Telerik.Pivot.Core.Filtering.Comparison.IsGreaterThan,
    Than = new DateTime(2010, 6, 6)
};
filter.Condition = condition;
dateGroupDescription.GroupFilter = filter;

this.provider.RowGroupDescriptions.Add(dateGroupDescription);

Workaround: remove the localization provider before saving the layout and then add it back.