This is a migrated thread and some comments may be shown as answers.

ScrollIntoView with EnableRowVirtualization="True"

23 Answers 875 Views

GridView

This is a migrated thread and some comments may be shown as answers.

This question is locked. New answers and comments are not allowed.

23 Answers, 1 is accepted

answered on 03 Mar 2010, 03:22 PM

Hi Thomas Hetzer,

There is a special method called ScrollIntoViewAsync. You will need our Latest Internal Build for this. Here is its signature:

/// <summary>

/// Scrolls the row containing the data item into view in an asynchronous manner.

/// </summary>

/// <remarks>

/// Since this method is asynchonous, calling it will return immediately. If you need

/// to perform a certain action once the scrolling is done use the scrollFinishedCallback

/// parameter to pass in a method to execute. The FrameworkElement parameter of this

/// method will be the row that was just scrolled.

/// </remarks>

/// <param name="dataItem">The data item to scroll into view.</param>

/// <param name="scrollFinishedCallback">The method to execute when scrolling has finished.</param>

public void ScrollIntoViewAsync(object dataItem, Action<FrameworkElement> scrollFinishedCallback)

This method will launch an asynchronous scroll request and will try to find the row. There is no guarantee that it will succeed. It may take many iterations to find the row, since, as you have noticed, when the heights are unknown, we simply approximate the supposed coordinates of where the row should be.

So what this method does is basically the following. It says "I think that this row should be there" and scrolls to this position. If if finds the row, then fine. If it does not find it, it repeats the same routine again. Until it finds it or its attempt count is reached. This is to avoid the method running forever and wandering around a grid with random row heights.

All these complications are due to virtualization. If it were turned of, the normal method would work since we would be able to do the math right since we would know all of the row heights beforehand.

Once the method has succeeded, it will execute a special callback, that is provided by you. In other words you give our method the address of your method to execute when it is finished.

You can call it like this for example:

this.ScrollIntoViewAsync(dataItem, (f) =>
            {
                  Debug.WriteLine("I have found the row: " + f.ToString());
            });

You can try this and see whether it will work in your case. I hope this helps.

Kind regards,
Ross
the Telerik team

Do you want to have your say when we set our development plans? Do you want to know when a feature you care about is added or when a bug fixed? Explore the Telerik Public Issue Tracking system and vote to affect the priority of the items.

answered on 03 Mar 2010, 08:26 PM

Hello Thomas

Frankly, your idea is brilliant!

Let me introduce myself. My name is Rossen Hristov and I am the author of this asynchronous method. In fact my logic is the same as yours. I am trying to find the row. In case I can not, I am trying again, but this time I hope that it is closer to the Viewport. There is a limit though.

Originally this method was internal, but I have decided to make it public. We use it for the editing architecture. For example, edit a property on which the grid is sorted, once you enter the new value the row you were editing goes somewhere else and we have to find it, so that you can edit the next row.

Let me tell you what cases I have struck while developing this functionality. Imagine that you have a grouped grid. Let's make it more diffucult and make the grouping 3-level. Add Virtualization, the concept that makes everything so difficult to predict, since you never really know what is coming next.

No one knows what height a group will have once it is expanded. It is undeterminable. Another example is Row Details with varying height. The Row Details of every single row can have arbitrary height. No one knows how much the row details will be high once they are scrolled into view. The whole math goes wrong.

So I am trying to use something similar to the Newton's Method for approximation in order to find the row (the root of our function).

Sometimes it works, sometimes not.

If you are able to send me a dummy sample project with those variable row heights that brakes the ScrollIntoViewAsync method I will be very happy. I would be able to debug your case and see why isn't this method finding the correct row.

I cannot promise anything at this stage, but I would very much like to have this sample data for testing purposes.

Please, accept our apologies. I would like to assure you that we are doing everything to meet our customers' expectations.

Looking forward to hearing from you, Thomas.

All the best,
Ross
the Telerik team

answered on 05 Apr 2011, 12:40 PM

Hi,

Thank you for the feedback.
We have tried your scenario and we were able to reproduce the case when the new row in not scrolled correctly. However, we are not quite sure whether scrolling in such scenario can be improved. We will make a profound investigation and notify you as soon as we have more information.

Please, excuse us for the inconvenience caused.

Kind regards,
Yordanka
the Telerik team

answered on 18 Jul 2011, 01:04 PM

Yes and was able to get it working with the code below.

Q: Why is it the .ScrollIntoView() method cannot do soemthing like this?

It seems like this should not be necessary (much like having to write code to trap row double click...)

//=======================================================================================

// SCROLL INTO VIEW

//=======================================================================================

private void ScrollIntoView()

{

foreach

(MyClass itm in this.dgrParameters.Items)

{

if (itm.Id == this._itm.Id)

{

this.IsBusy = true;

this._itm = itm as MyClass;

this._scrollIntoViewAttempts = 1;

this.dgrParameters.ScrollIntoViewAsync(

this._itm,

(f) => {

this.IsBusy = false; },

new Action(this.ScrollIntoView_Failed));

break;

}

}
}

private void ScrollIntoView_Failed()

{

if (this._scrollIntoViewAttempts < 3)

{

this._scrollIntoViewAttempts++;

this.radGridView.ScrollIntoViewAsync(

this._itm,

(f) => {

this.IsBusy = false; },

new Action(this.ScrollIntoView_Failed));

}

answered on 18 Jul 2011, 02:08 PM

Hello Chris,

When row virtualizaion is turned on we cannot do the math for the rows which are not realized. Each row can have a different height based on its cell template and row details but we don't know this in advance. So, being unable to do the math, we have created the Async version of the method which uses Newton's method in trying to find the row that the user has requested. There is not guarantee that it will succeed after n attempts at all.

Your one option is to use the Async method and hope that it will manage to find the row.

The other option is to turn row virtualization off which will realize all rows and we will know their height and we will be able to do the math and calculate the scroll offset correctly. Then you can use the normal method.

I hope this helps.

Best wishes,
Ross
the Telerik team

Register for the Q2 2011 What's New Webinar Week. Mark your calendar for the week starting July 18th and book your seat for a walk through of all the exciting stuff we will ship with the new release!

answered on 13 Sep 2012, 01:26 PM

Hello Telerik,

We have a project with 2 grids that must be synchronized with each other, that is selecting a row in one grid will select the corresponding row in the other. One of the grids has virtualized rows (EnableRowVirtualization="True"). And we can't make it scroll using the ScrollIntoViewAsynch method, providing a ScrollFailCallback does not help either. And we dont' have rows of variable height.

our version of the grid is 2011.3.1116.1040

I wonder if this problem has been finally solved by Telerik?

This synchronization is a critical usability issue for our application.

UPDATE:
Explicitly setting RowHeight on the grid resolved my problem.

ScrollIntoView with EnableRowVirtualization=&quot;True&quot;

23 Answers, 1 is accepted

ScrollIntoView with EnableRowVirtualization="True"