Namespace Syncfusion.Windows.Controls.Cells

Classes

ArrangeCellArgs Provides layout information about a cell such as the VisibleRow, VisibleColumb, the CellRect, Covered Cell Span and also cell style information. ArrangeCellArgs is only used for "Arrange" methods in VirtualizingCellsControl. ArrangeCellArgs also has member for CellUIElements and ShouldCreateVisuals.

ArrangedCellUIElementsManager Provides routines for managing cells visuals (aka UIElement children) of rendered cells that have been associated with one or more UIElement visuals. An instance of this class can be accessed with the ArrangedCellUIElements property of a VirtualizingCellsControl.

CellArgs Provides layout information about a cell such as the VisibleRow, VisibleColumb, the CellRect, Covered Cell Span and also cell style information.

CellBorderSide Defines the border side.

CellBordersInfo Provides a StyleInfoSubObjectBase object for borders in a cell. Each border side of the cell can be configured individually with a System.Windows.Media.Pen value. Border sides that have not been initialized will inherit default values from a base style.

CellBordersInfoStore Implements the data store for the CellBordersInfo object.

CellCursors Provides you with default cursors for the grid.

CellMarginsInfo Provides a StyleInfoSubObjectBase object for margins in a cell. Each margin side of the cell can be configured individually with a System.Windows.Thickness value. Margin sides that have not been initialized will inherit default values from a base style.

CellMarginsInfoStore Implements the data store for the CellMarginsInfo object.

CellMouseControllerDispatcher VirtualizingCellsControl instantiates this MouseControllerDispatcher class which adds support for changing context of a mouse operation when pressing mouse inside a textbox or other UIElement and then switching to a cell selection mode when moving mouse outside textbox.

CellOverlappSpanInfoCollection<T> A collection with elements derived from type CellSpanInfoBase. Internally this collection maintains both a List of CellSpanInfoBase and a so called pool. The pool allows immediate lookup of cell spans given a cells row and column index. The list allows looping through cell spans in the order they were added. CellOverlappSpanInfoCollection is similar to CellSpanInfoCollection<T> but with the difference that it allows overlaps between cell spans. If a cell has an overlap and GetCellSpans(Int32, Int32) is called for this cell all cell spans will be returned in a list that contain the specified cell. CellSpanInfoCollection is a base class for the grids GridCellSpanBackgroundInfoCollection.

CellRendererBase<S> The CellRendererBase<S> class provides a default implementation of the ICellRenderer interface for a cell renderer in a VirtualizingCellsControl. You should derive from this class to implement custom cell renderer classes. There is however no dependency on CellRendererBase inside the VirtualizingCellsControl, the VirtualizingCellsControl base class only depends on this interface. If you want to implement a renderer with support for live UIElement visuals inside the cell you should derive from the VirtualizingCellRendererBase<T> or grid/treeview adapted VirtualizingCellRendererBase classes.

CellSpanBackgroundInfo Holds the range and options for a cell span background. A cell span background tells the cells control to draw the background of one cell across multiple neighbouring cells. For example you can have a picture as background and this picture will be drawn across the neighbouring cells. These cells are still independent single cells, they only share the background.

CellSpanInfo This a base class for spanned ranges such as covered cells and cell spanned backgrounds. It contains Top, Left, Bottom and Right row and column index for the spanned range.

CellSpanInfoBase This a base class for spanned ranges such as covered cells and cell spanned backgrounds. It contains Top, Left, Bottom and Right row and column index for the spanned range.

CellSpanInfoCollection<T> A collection with elements derived from type CellSpanInfoBase. Internally this collection maintains both a List of CellSpanInfoBase and a so called pool. The pool allows immediate lookup of cell spans given a cells row and column index. The list allows looping through cell spans in the order they were added. CellSpanInfoCollection assumes that there is no overlap between cell spans. For any given cell there only at most one cell span must exist. CellSpanInfoCollection is a base class for the grids GridCoveredCellInfoCollection.

CellUIElements Holds the list of UIElement child elements for a cell.

CellUIElementsDictionary A strong typed dictionary that maps RowColumnIndex to CellUIElements.

CoveredCellInfo Holds the range and options for a covered cell. A covered cell is a cell that spans over neighbouring cells. All cells in this range are treated as one single cell.

IntegerCellsArray<T>

IntegerValueCellsDictionary<T> An object with a Cells dictionary. This class is used by RowColumnIndexValueDictionary<T> for rows inside that dictionary where each row has cells.

NoHitTestDrawingVisual NoHitTestDrawingVisual is a visual object that can be used to render vector graphics on the screen. The content is persisted by the system. Use this derived object instead of the base class DrawingVisual when you do not want the object to participate in hit-testing, as for example when you want to draw a solid background rectangle over selected cells in a grid but still want the hit-test to be passed down to the underlying cells when the user moves the mouse over the rectangle.

OverlappingCellInfo Holds the range and options for a Image cell. A Image cell is a cell that spans over neighbouring cells. All cells in this range are treated as one single cell.

RenderCellArgs Provides layout information about a cell such as the VisibleRow, VisibleColumb, the CellRect, Covered Cell Span and also cell style information. RenderCellArgs is only used for "Render" methods in VirtualizingCellsControl.

RenderedCellsManager Manages the DrawingVisuals for visible cells rendered to the grid canvas and provides routines for invalidating individual cells and move rendered cells after insert or remove rows or columns operations.

RenderedCellsMoveState An object which holds state when moving rows or columns for RenderedCellsManager InsertRows, InsertColumns, RemoveRows and RemoveColumns methods. It will be initialized by the Remove operation and later applied by the subsequent Insert operation.

RowColumnIndex Holds the coordinates for a cell.

RowColumnIndexValueArray<T> A generic class that emulates a subset of a Dictionary{T}. Internally rows are hold in a dictionary and each row has a dictionary of cells. The class also provides support for adding, removing and moving rows and columns.

RowColumnIndexValueArray<T>.RowColumnIndexValueDelegate

RowColumnIndexValueDictionary<T> A generic class that emulates a subset of a Dictionary{T}. Internally rows are held in a dictionary and each row has a dictionary of cells. The class also provides support for adding, removing and moving rows and columns.

RowColumnIndexValueDictionary<T>.RowColumnIndexValueDelegate A delegate with a method to be called back while iterating through a range of cells with the Iterate(CellSpanInfoBase, RowColumnIndexValueDictionary<T>.RowColumnIndexValueDelegate) method.

SerializableKeyValuePair<TKey, TValue>

VirtualizingCellRendererBase<T> VirtualizingCellRendererBase is an abstract base class for cell renderers that need live UIElement visuals displayed in a cell. You can derive from this class and provide the type of the UIElement you want to show inside cells as type parameter. The class provides strong typed virtual methods for initializing content of the cell and arranging the cell visuals. The class manages the creation of cells UIElement objects when the cell is scrolled into view and also unloading of the elements. The class offers an optimization in which elements can be recycled when AllowRecycle is set. In this case when a cell is scrolled out of view it is moved into a recycle bin and the next time a new element is scrolled into view the element is recovered from the recycle bin and reinitialized with the new content of the cell. Another optimization is support for cells rendering themselves directly to the drawing context. When SupportsRenderOptimization is true the UIElement will only be created when the user moves the mouse over the cell or if the UIElement is needed for other reasons. After a UIElement was created the virtual methods Syncfusion.Windows.Controls.Cells.VirtualizingCellRendererBase`1.WireUIElement(`0) and Syncfusion.Windows.Controls.Cells.VirtualizingCellRendererBase`1.UnwireUIElement(`0) are called to wire any event listeners. Updates to appearance and content of child elements, creation and unloading of elements will not trigger ArrangeOverride or Render calls in parent canvas. In Grid and Tree control you should not derive from this class. Instead you should derive from the GridVirtualizingCellRendererBase and TreeVirtualizingCellRendererBase classes. These classes are the exact same code base as this class with the only difference that they derive from GridCellRendererBase and TreeCellRenderer base classes instead. It is currently not possible with C# to the base class as template type parameter. This is the reason for this copy/paste approach for the codebase of this class.

VirtualizingCellsControl VirtualizingCellsControl is an abstract base class which can be used as a base class for any control with the purpose of displaying cells in scrollable rows and columns with built-in virtualization of visual elements inside the cells. VirtualizingCellsControl queries cell contents with the GetRenderCellInfo(DependencyObject) method which returns a IRenderCellInfo object. Each cell is associated with a ICellRenderer object which provides methods for measuring, arranging and drawing contents of a cell. The VirtualizingCellsControl implements the OnArrangeContent(Size) and OnRender(DrawingContext) methods. Within implementation of the OnArrangeContent method each cells UIElement children are placed on the controls area. A cell renderer can also be without any UIElement children and instead draw all its contents directly to the DrawingContext of the VirtualizingCellsControl when the OnRender(DrawingContext) method is executed. For a cell renderer it is also possible to do both: Arrange UIElements on the controls area and draw additional contents in its render area. There are also various optimization techniques that can be implemented with the renderer and are discussed in the ICellRenderer overview. VirtualizingCellsControl provides a few standard features that can be utilized by derived grid or tree controls such as the "Covered Cell" feature (see CoveredCellsProvider), the "SpanBackground" ( CellSpanBackgroundsProvider) feature, support for MouseControllers (MouseControllerDispatcher), create an UIElement on demand when hovering mouse over cell, cell borders and methods that convert from display coordinates to cell coordinates and vice versa. The virtualization of UIElement children of cell renderers is implemented in the arrange cells code. At the time a cell is placed the cell renderer is called to create and intialize the UIElement children. When a cell is scrolled out of view the cell renderer is called to unload the UIElement children. A cell renderer can decide whether to unload a UIElement, keep it alive or move it to a recycle bin and reuse it later. The main logic of this code is implemented by the VirtualizingCellRendererBase<T> class which contains more detailed discussion about this feature.

VirtualizingCellsControlChildFrame Implements a child frame in a VirtualizingCellsControl that can be placed at the top, bottom, left and right side of the control so that contents do scroll similiar to the Internet Explorer frames concept. Each frame remembers its placement. Adding and removing elements from the children collection does not trigger calls to InvalidateMeasure. This allows adding and removing elements on the fly. A derived control is responsible to call Measure and Arrange on child elements since this base class will not do this by itsself.

VirtualizingCellUIElementBin<T> This class implements a cache of UIElement of the given type parameter T. It is used by the VirtualizingCellRendererBase<T> renderer to recycle UIElement elements for cells that were scrolled out of view and delay unloading of UIElements. This reduces the number of times the UIElement needs to be created or unloaded and instead only the contents of the UIElement will be reinitialized with cell contents. A queue is maintained for each child frame in a ScrollControl.

VisibleCellSpanBackgroundInfo This class maintains the state of visible cell span background and lets you also access the underlying CellSpanBackground for which this visible cell span background was created and the row and column section this span belongs to.

VisibleCellSpanInfo This class maintains the state of visible cell span and lets you also access the underlying CellSpan for which this visible cell span was created.

VisibleCoveredCellInfo This class maintains the state of a visible covered cell and lets you also access the underlying CoveredCell for which this visible covered cell was created.

VisibleOverlappingCellInfo This class maintains the state of a visible Overlapping Cell and lets you also access the underlying OverlappingCell for which this visible Overlapping Cell was created.

Interfaces

IAllowInvalidateCell

ICellRenderer Defines the interface for a cell renderer in a VirtualizingCellsControl. A default implementation of this interface is provided by the CellRendererBase<S> class from which you should derive custom cell renderer classes. There is however no dependency on CellRendererBase inside the VirtualizingCellsControl, the VirtualizingCellsControl base class only depends on this interface.

ICellSpanBackgroundsProvider A provider for cell span backgrounds. GridCellSpanBackgroundInfoCollection is a default implementation of this interface. The VirtualizingCellsControl retrieves cell span backgrounds through this interface from it CellSpanBackgroundsProvider

ICoveredCellsProvider A provider for covered cells. GridCoveredCellInfoCollection is a default implementation of this interface. The VirtualizingCellsControl retrieves covered cells through this interface from it CoveredCellsProvider

IOverlappingCellProvider A provider for Overlapping Cell. GridOverlappingCellInfoCollection is a default implementation of this interface. The VirtualizingCellsControl retrieves Overlapping Cell through this interface from it OverlappingCellsProvider

IRenderCellInfo Defines cell render style information.

IRowColumnIndexValueArrayCallbacks<T>

IRowColumnIndexValueDictionaryCallbacks<T> An interface for callback functions of a RowColumnIndexValueDictionary<T>. You should call SetCallback(IRowColumnIndexValueDictionaryCallbacks<T>) to register your object that implements this interface with the collection.