Turn on double buffering

Turning on double buffering seems to solve the problem. Normally double buffering would only help reduce flickering, since painting is being done to an off-screen buffer, but for the DataGridView it also significantly reduces the amount of functions being called internally in the DataGridView – thus reducing processor load and increasing speed. (statistics gathered with the Eqatec Tracer)

My DataGridView doesn’t have a DoubleBuffered property !?!?

For some reason Microsoft has decided to hide the DoubleBuffered property from DataGridView. Luckily you can set it anyway with reflection.

public static class ExtensionMethods
{
    public static void DoubleBuffered(this DataGridView dgv, bool setting)
    {
        Type dgvType = dgv.GetType();
        PropertyInfo pi = dgvType.GetProperty("DoubleBuffered",
            BindingFlags.Instance | BindingFlags.NonPublic);
        pi.SetValue(dgv, setting, null);
    }
}

Just drop the above class into your project somewhere, or add the function to your existing extension methods.
The extension method allows you to set the DoubleBuffered property on your DataGridView in the following manner:

dataGridView1.DoubleBuffered(true);

You now have a smooth scrolling DataGridView

The ScrollingRichTextBox

A far more elegant solution is to use the underlying message system to control the scroll. Using the SendMessage function it is possible to send a WM_VSCROLL message to the control that makes the control scroll without needing to worry about focus.
I think the best solution is to make a small class that inherits from RichTextBox, and neatly wraps the SendMessage calls necessary to make it work. Many programmers are unfamiliar with the syntax involved, so wrapping it in a more familiar syntax is a good idea.

The complete class looks like this:

class ScrollingRichTextBox : System.Windows.Forms.RichTextBox
{
  [DllImport("user32.dll", CharSet = CharSet.Auto)]
  private static extern IntPtr SendMessage(
    IntPtr hWnd,
    uint Msg,
    IntPtr wParam,
    IntPtr lParam);

  private const int WM_VSCROLL = 277;
  private const int SB_LINEUP = 0;
  private const int SB_LINEDOWN = 1;
  private const int SB_TOP = 6;
  private const int SB_BOTTOM = 7;

  public void ScrollToBottom()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_BOTTOM), new IntPtr(0));
  }

  public void ScrollToTop()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_TOP), new IntPtr(0));
  }

  public void ScrollLineDown()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_LINEDOWN), new IntPtr(0));
  }

  public void ScrollLineUp()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_LINEUP), new IntPtr(0));
  }
}

Feel free to steal…

How it works

The class imports the SendMessage function from the user32.dll system library. I’m not gonna go deeply into that function in this post. It is insanely powerfull and deserves it’s own post someday. It allows the program to send native windows messages to the control. The message in play here is the WM_VSCROLL message that takes a parameter that tells it how to scroll. These parameters are constants that are defined in the winuser.h header file.

I have implemented four functions in this class, allowing it to scroll to the top and bottom, as well as a single line up and down.

With the SendMessage function imported and using winuser.h as a reference you could easily implement even more functionality in the class, such as pageup/pagedown (SB_PAGEUP/SB_PAGEDOWN), but i don’t want to bloat the class with that for this article. The principle is what counts here.

A simple usage example

For applications that require this sort of scrolling, using the ScrollingRichTextBox over the ordinary RichTextBox is the way to go. In a previous blog post, i talked about hooking up to the OnTextChanged event of a RichTextBox and using ScrollToCaret() to do the scrolling. A method that has a few issues.
Now, using the ScrollingRichTextBox, these issues are resolved and the complete code for that event looks like this:

private void scrollingRichTextBox_TextChanged(object sender, EventArgs e)
{
  scrollingRichTextBox.ScrollToBottom();
}

Neat huh?

Tons of applications are using the .NET RichTextBox for outputting status information. You have a RichTextBox that you just keep on adding text to. This is all very simple, but when the box is completely filled with text, further text added will no longer be visible, since the RichTextBox does not scroll along with the text. Wouldn’t it be nice if you could make it scroll along with the text automatically.

Well… You can.

Use the TextChanged event

Whenever you add (or change in any way) text to the RichTextBox the TextChanged event will fire immediately after the text has changed. Just double-click on the TextChanged event in the RichTextBox’ event list to add an event handler.
Now modify the code of the event handler to look like this:

private void richTextBox_TextChanged(object sender, EventArgs e)
{
  richTextBox.SelectionStart = richTextBox.Text.Length;
  richTextBox.ScrollToCaret();
}

This code uses the ScrollToCaret function to do the actual scrolling. The function will adjust the scroll of the box, so that the “caret” is visible (think of the caret as the blinking cursor). This of course requires that the caret is placed somewhere meaningfull. This is done by setting the SelectionStart property to the last character in the box. The result is that whenever the text in the RichTextBox changes the box will scroll to the very bottom.

While this method is perfect for your basic status information box, where information is always added to the bottom, it may not always be the proper solution. This method will reset any selection the user has made in the RichTextBox, so if you need to copy text out of the box and the text changes very often this is not really the way to go.

On the other hand it is a very simple and safe way of implementing “autoscroll” and i have used it in a lot of applications without any problems.