Set of UI controls including Grid and classes of data presentation layer.


Public classAppearance
Appearance of UI elements (Cell, Column, etc.)
Public classCell
Represents a cell
Public classColorButton
Color button with a drop-down color picker
Public classColumn
Represents a column
Public classColumn..::..ColumnAppearance
Column and cell appearance
Public classColumn..::..ColumnSerializationState
Column serialization state
Public classColumnConfiguratorForm
Configures grid columns
Public classDragContentBeginEventArgs
Data related to the beginning of the drag and drop operation.
Public classDragContentEndEventArgs
Data related to drag and drop operation.
Public classDragContentEventArgs
Data related to drag and drop operation
Public classDragDropContentEventArgs
Data and methods enable to complete the drag and drop operation.
Public classFilter
Represents a row filter. Can be used with anonymous methods.
Public classFocusedColumnEventArgs
Provides information about changing the focused Column
Public classFocusedRowEventArgs
Provides information about changing the focused Row in the Grid
Public classGDIPlusRender
Performs basic painting operations using GDI+ (Graphics object) drawing
Public classGrid
A hierarchical event-driven .Net control with ultimate performance.
Public classGrid..::..GridAppearance
Grid appearance. Specifies appearance for even and odd rows.
Public classGrid..::..GridAppearanceSerializationState
Grid's appearance serialization state
Public classGrid..::..GridDataConnection
Data source properties
Public classGrid..::..GridDataObjects
Collection of data objects that enables searching rows by a data object.
Public classGrid..::..GridDragAndDrop
Drag and drop settings.
Public classGrid..::..GridEditInPlace
Edit in place settings.
Public classGrid..::..GridFocus
Focus settings. Specifies focus mode, color, painting mode, etc...
Public classGrid..::..GridHierarchy
Hierarchy settings
Public classGrid..::..GridHighlighting
Highlighting settings such as highlighting interval, color, mode, fading effect parameters...
Public classGrid..::..GridHitTests
Provides elements by their location inside the grid.
Public classGrid..::..GridNavigarion
Grid navigation settings and methods to handle user input such as KeyUp, KeyDows etc.
Public classGrid..::..GridPrintSettings
Print settings
Public classGrid..::..GridRowSelector
A visual element on the left side of the Grid that enables a user to manipulate the Rows, change their height, select them, show related images (error icons for example).
Public classGrid..::..GridSelection
Collection of selected Rows.
Public classGrid..::..GridSerializationState
Grid serialization state
Public classGrid..::..GridSort
Sorting settings of the Grid. Enables or disables sorting and multiple sorting.
Public classGrid..::..GridThreadsafety
Thread safety parameters of the Grid
Public classGrid..::..GridTooltips
Tooltip settings
Public classGrid..::..ThemeAppearance
Appearance of graphical elements, which can be incorporated into a theme.
Public classGridCellBeginEditEventArgs
Information about the beginning of cell editing
Public classGridCellEditableEventArgs
Information about editable cell
Public classGridCellEndEditEventArgs
Information about end of cell editing process
Public classGridCellEventArgs
Information about a Cell.
Public classGridColumnEventArgs
Information about a Column
Public classGridEditableCellEventArgs
Contains information about the next or previous editable cells
Public classGridHeaderEventArgs
Information about a Header.
Public classGridRowAddingEventArgs
Information related to conditional binding
Public classGridRowEventArgs
Provides information on the Row of the Grid.
Public classGridRowExpansionEventArgs
Provides information about the Row when it is collapsed or expanded.
Public classGridRowSelectionEventArgs
Provides information on the Row before its selection state is changed.
Public classGridRowUpdateEventArgs
Provides information on the Row and the IDataField in the Grid that have been updated.
Public classHeader
Collection of Columns.
Public classHeader..::..ColumnCollection
Collection of all available Columns.
Public classHeader..::..FixedColumnCollection
Collection of non-scrollable columns in Header
Public classHeader..::..GroupedColumnCollection
Collection of grouped Columns.
Public classHeader..::..HeaderAppearance
Appearance of Header and also even and odd rows.
Public classHeader..::..HeaderSerializationState
Header serialization state
Public classHeader..::..MergedColumnCollection
Collection of merged columns
Public classHeader..::..SortedColumnCollection
Collection of sorted Columns
Public classHeader..::..VisibleColumnCollection
Collection of visible Columns.
Public classHeaderCollection
Collection of Headers.
Public classImageSettings
Specifies image settings (padding, alignment, stretching).
Public classLassoSelectionEventArgs
Data related to the lasso selection.
Public classMeasureCellWidthEventArgs
Information related to cell width measurement.
Public classMergedColumn
Merged column enables collecting regular columns in groups
Public classNodeCollection
A collection of visible and invisible rows
Public classPaintBackgroundEventArgs
Provides data and methods to paint Grid background
Public classPaintCellEventArgs
Provides data and methods for Cell painting
Public classPaintColumnCaptionEventArgs
Provides data and methods for painting Column caption on the Header
Public classPaintColumnPanelEventArgs
Provides data and methods for painting column panel on the Header
Public classPaintGroupPanelEventArgs
Provides data and methods for painting group panel on the Header
Public classPaintGroupRowEventArgs
Provides data and methods for painting group Rows
Public classPaintHeaderEventArgs
Provides data and methods for painting the Header
Public classPaintHelper
Provides various useful functions for painting operations
Public classPaintHierarchyEventArgs
Provides data to paint the hierarchy in the Grid
Public classPaintMergedColumnEventArgs
Provides data to paint merged columns
Public classPaintRectangleEventArgs
Provides data and methods for painting in specified Grid area
Public classPaintRowEventArgs
Provides data and methods for painting the Row
Public classPreferences
Provides Grid default preferences.
Public classPreferences..::..PreferencesGrid
Default preferences of the Grid
Public classPrintGridPageEventArgs
Provides data and methods for reporting
Public classRoundButton
Represents a Windows round button control.
Public classRoundButton..::..ButtonAppearance
Provides properties that specify the appearance of RoundButton.
Public classRoundButtonPaintEventArgs
Provides data for the PaintControl event.
Public classRow
Contains a collection of Cells and information about data object, its location, hierarchy in the data grid, color, etc.
Public classRow..::..VisibleRowCollection
A collection of visible child Rows.
Public classRowCollection
Collection of all visible Rows.
Public classScrollChangeEventArgs
Provides information on scroll changes
Public classTextSettings
Specifies text settings (padding, text orientation, wrapping, trimming, etc...)
Public classToolStripGridColumn
Represents a column visibility option displayed on a Grid.HeaderContextMenu
Public classToolStripGridGroupBoxPanel
Represents a group panel visibility option displayed on a Grid.HeaderContextMenu
Public classToolStripGridHeaderConfigurator
Represents a header configurator option displayed on a Grid.HeaderContextMenu
Public classToolStripGridRemoveSort
Represents an option to remove sort displayed on a Grid.HeaderContextMenu
Public classToolTip
A small rectangular pop-up window that can contain any .Net control to display a brief description or to perform some action with a control when the user moves the cursor over the control.
Public classToolTip..::..TooltipInfo
Detailed information (location, tooltip's region, custom control, etc.) for displaying tooltip for the specified control.
Public classToolTip..::..TooltipPopupEventArgs
Provides data for the TooltipControl.Popup event. Enables customization of location and appearance of tips.
Public classTooltipHideEventArgs
An event that keeps the tooltip visible even when the AutoPopDelay interval expires.
Public classValidateCellEventArgs
Provides data and methods for to validate cell editing
Public classVerticalSpacing
Specifies vertical spacing


Public interfaceICustomSort
Defines an interface to order or sort Rows.
Public interfaceIFilter
An interface for filter Rows.
Public interfaceIRender
Interface for performing basic painting operations
Public interfaceIResetable
Public interfaceIScrollManager
An interface that handles scrolling of the grid.


Public delegateFilter..::..Callback
A callback that is called by Filter to determene whether Row is filtered


Public enumerationBorderSide
Borders of a rectangle.
Public enumerationColumnScrollType
Indicates column scroll mode
Public enumerationColumnStretchMode
Indicates how the widths of the columns in a grid are stretched
Public enumerationDropRowPosition
Specifies the location to which the data should be added during drag and drop operation.
Public enumerationElementState
Specifies state of a UI element
Public enumerationExpansionButtonBehaviour
Specifies behavior of expansion (+/-) button.
Public enumerationFocusMode
Specifies focus mode
Public enumerationGradientDirection
Gradient direction
Public enumerationGridDropMode
Indicates how the content should be added to the grid during drag and drop operation.
Public enumerationHitTestInfo
Functional element of grid.
Public enumerationImageStretch
Indicates how should the image be stretched
Public enumerationInsertionType
Possible actions upon data insertion to the grid
Public enumerationMouseWheelBehaviour
Specifies mouse wheel behavior
Public enumerationPaintPart
Specifies the parts of UI element that are to be painted.
Public enumerationRoundButton..::..ButtonState
Specifies the appearance of a RoundButton.
Public enumerationRoundButton..::..ButtonStyle
Specifies the RoundButton style.
Public enumerationRoundButton..::..PaintPart
Specifies parts of UI element that are to be painted.
Public enumerationRowDockStyle
Row docking style
Public enumerationSortDirection
Specifies sorting direction
Public enumerationValidateCellAction
Validation action


Originally the grid was designed for electronic financial markets with their stringent requirements to robustness, low consumption of memory and CPU resources, ergonomic and simple user interface and rich API. These requirements have a common objective - to gain the first place on the market, to improve development time and to keep productive work in the run-time. As the result, we create the most productive and robust hierarchical grid with one of the best object models. It can be used in a great variety of applications (not just for financial markets). It makes software user-friendly, reduces CPU and memory consumption and considerably accelerates development time with multiple services included in the grid and RAD (rapid application development) patterns.

Working modes
.Net Grid supports various working modes that that enable its use in various types of applicaitons

  • Non-event model supporting insertion of data of different types (user defined classes, IEnumerable<T>, IList<T>, IDictionary<string, object> etc.) into any level of grid hierarchy. The grid provides Grid.Rows.Add(object) and Row.Add(object) methods to work in this mode.
  • Event-driven mode is used when a programmer uses objects that implement INotifyPropertyChanged interface. We recommend to get acquainted with this mode and use it everywhere. It will enable you to eliminate all dependencies between business logic layer and the System.Windows.Forms, as well as Dapfor assemblies.
  • Data binding mode is used to connect to data sources via Grid.DataSource/Grid.DataMember properties. Supported data sources: IList, IListSource, IBindingList.

Data types
Such broad functionality of the .Net Grid is possible due to the IDataAccessor interface that is one of the most crucial part of the grid. The main purpose of this interface is to normalize presentation of different data types in the grid. There are lots of implementations of IDataAccessor interface. This way, a programmer can add his own implementation to broaden the list of data types that can be used by the .Net Grid. When you call Add(Object), an implementation of the IDataAccessor interface is created implicitly for 'your object' and the .Net Grid works with it only via the IDataAccessor proxy, making no difference between the data types.

 Copy imageCopy
//Some data object
public class Product : INotifyPropertyChanged
    //Some fields
    private double price;
    private DateTime maturity;

    [DoubleFormat(Precision = 3, ShortForm = true, ShowZero = false)]
    public double Price
        get { return price; }
            price = value;
            if(PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs("Price"));
    public DateTime Maturity
        get { return maturity; }
    public event PropertyChangedEventHandler PropertyChanged;

//Using sample
public void AddDataObjectToGrid(Grid grid)
    //Initialize the grid
    grid.Headers.Add(new Header());
    grid.Headers[0].Add(new Column("Price"));
    grid.Headers[0].Add(new Column("Maturity"));

    //Add data object to the grid. The object will be implicitly wrapped by the DataObjectAccessor class
    Product product = new Product();

    //Add a collection of values to the grid.
    //Because of this collection implements IList, it will be implicitly wrapped by the ListDataAccessor
    grid.Rows.Add(new double[] {123, 12, 45});

    //The object will notify the grid through the INotifyPropertyChanged, and the grid will automatically
    //invalidate, sort, filter and highlight the affected cells.
    product.Price = 12.34;


.Net Grid allows to present data both in tabular format and in hierarchical form. A data hierarchy may have one or more headers. Working with a single header is similar to TreeView control with multiple columns (a classic example is file explorer). Multiple headers enable separate column management for each hierarchical level. At a glance, every header consists of two panels: the grouping panel and the columns panel. These panels aren't related to each other. It means that the same column may be present in both panels simultaneously. Each column carries very important information about width, location, visibility, grouping and data sorting

Data can be added into the data grid via Add(Object) method call. This method returns object of Row type, which contains information about a data object, its location, hierarchy in the data grid, color, etc. To build a hierarchy, it is enough to call the Add(Object) method, which in turn returns a new Row object. This way a programmer can build almost any data hierarchy in the .Net Grid. All headers and rows have their own zero-based hierarchical level that is defined by Level and Level properties. To display data in every row, .Net Grid takes header of the same level as that row. However, if that level doesn't have a header, the header for the previous hierarchical level is used. In other words, if only one header is present, the grid will behave like Microsoft Windows Explorer.

When multiple headers are used, those that have level greater than 0 will be displayed in the grid above the first visible row on the same hierarchy level. A header can be hidden/shown via the Visible property.

 Copy imageCopy
public void PopulateGrid(Grid grid)
    //Add some data objects
    Row product1 = grid.Rows.Add(new Product());
    Row product2 = grid.Rows.Add(new Product());

    //Add some customers to the first product
    product1.Add(new Customer());
    product1.Add(new Customer());
    //Add some customers to the another product
    product2.Add(new Customer());


.Net Grid enables multiple data grouping in headers of the .Net Grid by any columns at any hierarchical level. When data is grouped by a specific column, .Net Grid searches all rows within a group that has similar values. When a group is organized, a row that doesn't contain a data object is added to the data grid. The Row.IsGroup property of such row will always return true, and Row["column id"].Value will return a value by which data is grouped. All rows with values that meet grouping conditions are attached to the newly created group. Before a new data object is added, .Net Grid verifies whether there is any group with the required value on the current hierarchical level. If there is no such group, a new group is created. When the Row.Update() method is invoked, the grid checks whether a row conforms to group value. If there are no more rows in the group, the group is removed from the grid.

In programming the grouping feature can be enabled via the Column.Grouped property. Sequential invocation of this property for several columns results in data grouping of these columns. The column with grouping remains visible unless Column.Visible property is set to false. Sorting (and multiple sorting) can be enabled or disabled for grouped columns because sorting and grouping are completely independent processes. The list of grouped columns can be viewed with Header.GroupedColumns collection property. A user can also group columns in the data grid. To use this ability the user just needs to drag a column to a special panel on the grid's header. However, this is not possible if height of this panel is set to 0.

Real-time grouping in non event-driven model is done with Update()()()() method. In the event-driven model Update()()()() method is called every time when a data object sends a notification. Once again we'd like to emphasize the importance of such model as it removes dependency of the business layer on System.Windows.Forms controls and on Dapfor assemblies as well.


A very important feature in .Net Grid its ability to work directly with application business logic. Business logic is a set of classes that may have certain properties returning specific values, i.g. prices, quantities, dates, etc. Generally these values are represented by primitive types, such as System.Int32, System.Double, System.Decimal etc. To show this data in grid cells, it's sufficient to convert the necessary values into the System.String type by calling ToString()()()() or Format(String, Object). However, this approach is not flexible and doesn't support parsing strings to objects. To fill in for this, the .Net Grid provides a very powerful system of formats to convert values into strings and vice-versa. These formats are fully customizable. For instance, the grid can display empty strings instead of "0" when a value equals 0 or add a separator between thousands or some prefix or suffix like "$". These formats can also parse strings back into values. For application programming it's better to have a set of format classes, where data presentation is centralized.

In programming, formats can be defined in the following places:

  • As an attribute of a class property. For example: FormatAttribute, DoubleFormatAttribute, EmptyFormatAttribute, etc:
     Copy imageCopy
    public class Product
        private double price;
        [DoubleFormat(Precision = 3, ShortForm = true, ShowZero = false)]
        public double Price
            get { return price; }
  • In a column: Column.Format = 'your format';
  • Directly in a Cell (this method requires a lot of memory): Cell.Format = 'your format';

The .Net Grid looks for IFofmat object to format values or parse strings in the following order:

  • In a Cell
  • In a Column returned by the Column property
  • In a IDataField object, returned by the DataField property.
  • If the format is still not found, the grid uses default format for the specified object type.

Some formats greatly simplify application development. For example, StringFormat, enables use of standard patterns for formatting values through Format(String, Object):

 Copy imageCopy
column.Format = new StringFormat("### ### ### ###", string.Empty, " $");
//The value 12345 will be displayed in cells as "12 345 $"

.NET Framework has similar system of type conversion based on the TypeConverter class that enables conversion of values to strings and vice versa. This conversion system is more complete, but a little bit cumbersome in the context of formating and data parsing. Althrough converters are bulky, such approach enables development of a business logic independently from data presentation. In a perfect case all these mechanisms can be completely based on Microsoft's component model and therefore have no physical dependencies on libraries of other vendors and on the Dapfor libraries as well.

 Copy imageCopy
class SomeClass
    private int intValue;

    int SomeHexdecimalValue
        get { return intValue;  }
        set { intValue = value; }


.Net Grid supports multiple ways of cell editing. When we were developing this mechanism, we based it on standard editors used in the PropertyGrid control. There are several types of these editors including controls that can be displayed in a dropdown box or as a modal dialog. Such editors enable users to edit text, colors and enumerations and to perform painting in small rectangles inside cells. There are plenty of predefined editors. For example, you can get the color editor as follows:

 Copy imageCopy
UITypeEditor editor = (UITypeEditor)TypeDescriptor.GetEditor(typeof (Color), typeof (UITypeEditor));

To edit values, these editors use the EditValue(IServiceProvider, Object) method. Within this method a mandatory control is created and placed in the dropdown box. You should note a very important detail the return from the function EditValue(IServiceProvider, Object) occurs only when editing within in the control is completed, which is convenient from the programmer's point of view. Look at this example:

 Copy imageCopy
object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
    IWindowsFormsEditorService service = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
    using (SomeControl control = new SomeControl(value))
        value = control.NewValue;
    return value;

The .Net Grid fully supports this mechanism and editors of other vendors that can be used in your applications.

Despite the convenience of this interface, we have concluded that it lacks some functionality. These editors can't be created above the edited cell with its size (for example, slider control). Besides that, they can't be painted in the whole cell just in a small rectangular area. To remediate this, we have created UITypeEditorEx a class, derived from UITypeEditor that allows to create controls directly above a cell. The process of editing is quite similar to the aforementioned code example:

 Copy imageCopy
StopEditReason EditCell(IGridEditorService service, Cell cell, StartEditReason reason)
    using (SomeControl control = new SomeControl(cell))
        return service.CellEditControl(control, cell.VirtualBounds, reason);

Besides, some editors can be used without creating graphic controls, i.e. a rating editor. It simply draws stars, and when the user clicks on a certain star, this control calculates its relative location and sets a new value. The whole editing code will look as follows:

 Copy imageCopy
StopEditReason EditCell(IGridEditorService service, Cell cell, StartEditReason reason)
    //compute a new rating
    cell.Value = rating ;
    return StopEditReason.UserStop ;

Real-time sorting

.Net Grid enables multiple row sorting upon data changes in real-time, taking into account sorting direction, grouping rules and data hierarchy.

On programming side it can be done via SortDirection property. This property sets the sorting direction or turns it off. When you sequentially set this property for several columns, you enable multiple sorting in the data grid. Every column that is involved in the sorting has its own zero-based level. Information about all sorted columns can be retrieved via SortedColumns property. It's important to mention that column visibility doesn't affect data sorting. It means that rows will be sorted without regard to column visibility or to whether column is grouped or not.

Without sorting, all grid rows are automatically indexed thereby increasing grid performance. When sorting is used for some columns, all data is sorted in ordered sequence according to sorting rules and data hierarchy. This way, when you add new data into the data grid, it is automatically added to the right position according to the above rules. When you call Update()()()() method, the .Net Grid searches a new position for the row and moves it to the right position. When you use an event-driven model (i.e. when you use the INotifyPropertyChanged interface implementation), Update()()()() method is invoked systematically. In other words, when sorting is enabled, the .Net Grid constantly stores data in ordered sequence. In addition to that, the .Net Grid properly processes data changes in several rows including processing of separate threads. You won't find some kind of Sort() method in the .Net Grid, because the data is always in the ordered sequence.

Real-time data filtration

Simply put, data filtration is managing visibility of rows in the grid. Row invisibility in the grid means that the row is still in the grid, but it is invisible together with its children. It's important to say that this row can be accessed only via Nodes/Children collection properties. In the Rows property invisible rows are absent, as it shows only visible rows. Filtration is particularly important when data is grouped. If there are no visible rows, the whole group becomes invisible (but is not removed!). If a filtered row should be made visible again, it takes certain position according to the sorting rules if any.

.Net Grid presents 3 ways of data filtration:

  • Setting boolean in the Filtered property
  • Implementing the IFilter interface and setting it with the Filter property
  • Filters in columns

The first way is the easiest to use, however, we recommend you to favor the second one that provides definite advantages.

The IFilter interface has only one property IsFiltered(Row). This method is invoked when data is inserted into the data grid. It is also invoked every time Update()()()() and FilterRefresh()()()() methods are called. Therefore, grid rows always meed the filtration criteria. However, when IFilter interface is not implemented, the invocation of Update()()()() doesn't result in data filtration and newly added data is always visible in the grid until the Filtered call. Besides, when filtering conditions are changed, invocation of FilterRefresh()()()() doesn't make the row visible the programmer should iterate through every row in the data grid via Nodes and Children collections to verify new conditions. There is an important thing to add regarding multi-threaded applications. Invocation of IsFiltered(Row) method occurs regularly in the GUI thread, and it should be considered during development of multi-threaded applications. Please note that Update()()()() method is thread-safe and can be invoked in any thread.

Data filtration implemented via IFilter interface of non-event-driven model consists in the Row.Update() method call:

 Copy imageCopy
public class CustomFilter : IFilter
    public bool IsFiltered(Row row)
        //There are three ways to get cell's value: 
        //1. Via Cell.Value property: double value = (double)row["Price"].Value
        //2. Via IDataAccessor and IDataField: double value = (double) row.DataAccessor["Price"].Value
        //3. Directly from the data object: double value = (double)((IList)row.DataObject)[2];

        if ((double)row["Price"].Value < 30000)
            //Filter the row
            return true;

        //The row is not filtered
        return false;

    public event EventHandler<EventArgs> FilterUpdated;

public void FilterUsing(Grid grid)
    //Initialize the grid
    grid.Headers.Add(new Header());
    grid.Headers[0].Add(new Column("Name"));
    grid.Headers[0].Add(new Column("Color"));
    grid.Headers[0].Add(new Column("Price"));

    //Set filter
    grid.Filter = new CustomFilter();

    //Populate the grid
    Row row1 = grid.Rows.Add(new object[] { "Mercedes", Color.Black, 25000d});

    Row row2 = grid.Rows.Add(new object[] { "BMW", Color.White, 35000d });

    //Set a new price for "Mercedes"
    row1["Price"].Value = 32000d;

Cell highlighting

.Net Grid provides an extremely convenient mechanism of data highlighting. Highlighting is the process of changing background color of a cell for a specified time interval and gradual restoration of the initial color afterwards. Background color of a cell can be changed twice (at the beginning and at the end) or with a little periodicity (about 30 ms)enabling fading effect with gradual transition between the highlight color and the original background color of the cell.

In programming cell highlighting can be achieved by calling Highlight(TimeSpan, Color). When a programmer calls this method, the grid adds specific information about cell's state into an internal container and launches timers when necessary. The second parameter is the color that may contain alpha-channel enabling mixing of the highlight color and the background color (transparency effect). It's important to mention that the .Net Grid has a very easy to use API that saves programmer's time. Highlighting management and initial parameters are accessible via Highlighting property.

Customization and painting

.Net Grid provides broad functionality of displaying various data grid elements, such as cells, rows, headers and columns. There two ways for data grid customization:

  • Setting specific appearance of the element via Appearance property. For instance, Appearance, Appearance, Appearance, Appearance, Appearance. All information about colors, fonts etc. is stored in memory. Therefore setting of this property is more suitable for Grid, Header, Column. A programmer should not use this property on Rows and Cells, as it will consume lot of memory.
  • Setting specific parameters in the very moment of painting. For most efficient memory usage, this information is stored in memory for only a short period of time. To implement this feature, a programmer should subscribe to a specific event such as PaintCell, PaintRow, PaintHeader etc.

The PaintXXXEventArgs contains the following information:

  • Full and clipped sizes of the painted element
  • Graphics object
  • Colors and parameters used for elemebt painting (they can be altered)
  • Methods for painting every single part of an element (for a Cell there are methods for painting background, text, selection, focus etc.)
  • Painting filter PaintPart, which allows to skip a certain part of an element (partial painting)
  • PaintAll() method that paints all elements defined in the PaintPart filter
  • Handled property that forbids a data grid to perform default painting

Note that the whole painting process is accumulated in PaintXXXEventArgs and consists of the following: a data grid creates PaintXXXEventArgs object, sets default parameters, fires Paint event, and if Handled property is set to false, invokes PaintAll() method. This mechanism is used to paint all elements of the .Net Grid cells, rows, columns, headers, hierarchy tree etc.

We have intentionally described the process of painting in details to show broad and rich abilities of data grid customization. In other words, you may customize any parameters, some painted elements (cell, column) and even use Graphics object to manipulate the data grid. Even better, this approach enables you to define a painting sequence. For example, you may perform some default actions and then finish drawing with the Graphics object, or do it vice versa!


It is well known that System.Windows.Forms controls use standard Windows API based on window messages. To repaint a certain part of a control, it should invoke the Invalidate(Rectangle) method, where Rectangle specifies location and size of the client surface that should be repainted. In general, the calculation of screen coordinates of an element is a quite complicated process, especially in a hierarchical data grid. The .Net Grid provides very convenient API to repaint different elements such as cells, rows, columns etc.

Below you may see a list of elements that can be repainted in the grid:


Displaying auxiliary information above a grid cell is a typical task. In the .Net Grid this process is considerably simplified. To display a tooltip is is sufficient to set text calling Cell.TooltipMessage = "some text". Color management, display time and tooltip location can be set with Grid.Tooltips property. The programmer can control tooltips via .Net Grid notifications.