Telerik.Windows.Controls
A view that displays the commands of a RadAIPrompt.
A view that displays the input area of a RadAIPrompt. Contains things like the input textbox, the button that makes a request to the AI model, and a list of pre-defined suggestions.
A view that displays the output area of a RadAIPrompt. Contains things like the output items, which are the responses from the AI model.
Represents the possible values of an action to be taken when an element of the RadGridView loses focus.
Provides data for the Telerik.Windows.Controls.ActivationManager.ActiveChanged event.
An ActivationManager class.
Provides an adapter for adding items to a collection in a flexible manner. This is obsolete. Use AddItemAdapterCollection instead.
Represents a collection of item adapters for the Telerik controls.
Represents a set of possible screen positions for RadDesktopAlert.
Helper methods for populating the collection of types of an object implementing the IAllowedTypesSupport interface.
Defines alternation properties for decorating TableBase area.
Contains attached property that enables analytics features for control.
A ScrollViewer control that animates the changes in its HorizontalOffset and VerticalOffset.
Represents the Application menu within the RibbonView control.
Contains state information about the appointment that has already been created.
Contains state information about the new appointment that is going to be created.
Represents the Cue item for current appointment.
Contains state information about the appointment that has been deleted.
Contains state information about the appointment that is going to be deleted.
Represents the ViewModel for the AppointmentDialog.
Contains state information about the appointment that has been edited.
Contains state information about the appointment that is going to be edited.
Provides a way to choose a DataTemplate for the AppointmentItem based on the data object and the data-bound element.
Represents a proxy object that is set as DataContext on AppointmentItem control. It is used for performance optimization.
Contains state information about the appointment that is going to be saved.
Represents different appointment data-entry modes.
Represents a panel that arranges the appointments in RadScheduleView control.
Async filtering behavior which uses multithreading for faster data processing.
Represents an object that is attached to an owning object.
Represents a collection of AttachableObject<T> instances.
Represents a control that provides functionality for autocompleting user input using a list of items.
Represents a panel that arranges its child elements in a wrap layout, providing additional capabilities for autocomplete boxes.
Specifies how the ellipsis are displayed on a RadDataPager control.
Provides data for the AutoGeneratingTile event.
Describes the means by which the automatic ToolTip is positioned on a RadSlider control.
Represents the default TickLength provider.
Contains extension methods for working with control's automation peers.
This class is used to relate a style to a backstage item's container.
Holds predefined styles for backstage items' containers.
Defines a set of standardized icons that can be associated with a Balloon Tip.
Converts byte array to image using.
Provides methods that allow getting property values without reflection.
Provides a standard set of book related commands.
Represents converter that converts Boolean to InputMode using the given parameter. If the Boolean value is true the parameter is returned. If the Boolean value is false the default value of InputMode is returned.
Represents a converter, which converts bool values.
Represents the converter that converts Boolean values to and from 1 and 0 opacity.
Represents the converter that converts Boolean values to and from Visibility enumeration values.
Represents the converter that converts Boolean values to and from maximized and normal window states.
Used in the RadTreeView to specify what will be brought into view when the BringIntoView or an equivalent method is called for a RadTreeViewItem.
Represents the converter that converts Brush values to and from Color and vice versa. It is somehow an opposite of the ColorToBrushConverter.
Specifies possible options for when a button should be visible.
Represents a converter that converts ButtonVisibility values to Visibility enumeration values.
Enum for WindowButtonsAlignment for buttons alignment in the headers of windows and dialogs in the Crystal theme.
Callout animations provided by AnimationManager.
Determines the major arrow geometry types for the callout.
Event handler for the PopupClosingEvent.
Event handler for the PopupOpeningEvent.
Represent a service that provides methods for showing a RadCallout control via animated popup.
Settings for configuring the callout popup and its showing animation.
Determines the major callout geometry types.
Contains state information and event data associated with a camera error routed event.
Represents the method that will handle camera error events.
Represents the type of error RadWebCam encountered.
Represents a control that displays all the available camera settings of RadWebCam control.
Contains state information and event data associated with a cancelable routed event.
This is a class used to store the information for a single data field.
Contains event data for auto-generation of data field descriptors in RadCardView
Represents event data for a edit ended event of a RadCardView.
Contains information on performed group operation.
Defines Grouping Event Actions that are passed as arguments to the Grouping Event on item drag.
Represents data for the CardViewGrouping event.
Represents event data for an event of a RadCardViewItem.
Contains information on performed sort operation.
Provides details about the Sorting event.
This class represents a CaretBrushHelper that workarounds an issue which is related to a bug when setting a CaretBrush to TextBox control through Style in XAML.
Class that is used to present a single field of a data item.
Class that is used to present a single data item.
Implements a selectable item inside a RadCarousel.
Presents the content of a CarouselItem.
Provides a way to choose a DataTemplate for the CarouselItemContentPresenter based on the type of the data object.
Represents a scrollable area that can contain other visible elements.
Represents a dynamic data collection of Categories that provides notifications when categories get added, removed, or when the whole list is refreshed.
Indicates the state of the cell.
Handles data-layer associated operations for RadChartView.
Handles histogram data associated operations for ScatterRangeBarSeries.
Specifies the possible modes used by a ChartSelectionBehavior to update the current selection within a RadChartBase instance.
Represents CheckMSI possible schemes for calculating a check digit.
Contains extension methods for enumerating the children of an element.
Contains state information about the dialog that is going to be closed.
Represents the Codabar symbology type.
Represents the Code11 symbology type.
Represents the Code128 symbology type.
Represents the Code128A symbology type.
Represents the Code128B symbology type.
Represents the Code128C symbology type.
Represents the Code25Interleaved symbology type.
Represents the Code39 symbology type.
Represents the Code39 symbology type.
Represents the Code39Extended symbology type.
Represents the Code93 symbology type.
Represents the Code93Extended symbology type.
Represents the CodeMSI symbology type.
Determines the type of code, such as Numeric, Alphanumeric, Byte or Kanji.
Defines the list of values a CollapseThreshold can be.
Holds extension methods for ICollection<T>.
A base class for CollectionNavigator.
ColorPaletteBase is the base class for all palettes. When you want to implement custom Palette just inherit this class and implement the methods.
This is the enum that represent the all kind of Palettes.
It enables you to add colors to the palette simply by choosing one of its values.
Represents the converter that converts Color values to and from Brush values.
Represents the converter that converts Color values with opacity as parameter to SolidColorBrush.
Describes the length of a column which could be either fixed-sized or auto-sized.
Describes the type of column length.
Represents a converter from string to ColumnLength.
Holds the information of column reordering passed when GridViewDataControl ColumnReordering Event is raised.
Represents a class that synchronizes two collections of GridViewColumns.
Defines the placement of column totals.
Contains data needed to handle the ColumnWidthChanged event.
Contains data needed to handle the ColumnWidthChanging event.
Represents a filtering behavior for RadComboBox.
Helper class for showing tooltip on non-editable RadComboBox whose selected text is clipped (trimmed).
Represents a strongly-typed collection of ControlCommandBase<T> instances.
Used in the RadTreeViewItem to specify when the Command must be executed.
Represents a strongly-typed class that provides basic infrastructure for RadControl commands.
Represents a single completion page.
Provides a way to choose a DataTemplate for a data-bound element by testing the data object against a set of predefined rules.
Provides a way to choose a Style for a data-bound element by testing the data object against a set of predefined rules.
Indicates the possible modes for changing the visible content of the RadFluidContentControl.
Represents a command abstraction that is associated with a particular ICommand instance.
Represents a converter that empties the value of a given CornerRadius based on the parameter passes.
This class provides CornerRadius helper properties.
Hold resources used in the CrystalTheme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the CrystalPalette.
A that allows access to the CrystalPalette resources from XAML.
Keys for the CrystalPalette resources.
Used to convert ResourceKey types used in CrystalResourceKey.
CrystalTheme class represents the key to the Crystal theme.
Represents control that indicates the current time in RadScheduleView control.
Determines the display location of the current time indicator of RadScheduleView.
This class is used to relate a style to an item's container.
Holds predefined styles for an items control items' containers.
Represents a custom ViewDefinitionBase that overrides the GroupDescriptions and allows custom visible range formatting.
Represents a control that provides common functionality for all Telerik WPF controls that represent data.
Data field displaying and editing boolean data.
Data field displaying and editing Enumeration and lookup data.
A field used to display and edit data in RadDataForm.
A field used to display and edit dates in RadDataForm.
Represents the different edit modes of RadDataForm.
Provides base functionality for data points implementations.
Represents the DataMatrix 2D barcode.
A rule that returns a DataTemplate when satisfied.
This class represents the data for the Date - its durations and ticks.
Describes the grouping of items using a date range as the criteria.
Represents a selection control that allows you to select time from grid.
This class represents extension methods and attached properties used by the DateTimePicker control.
Specifies the format of the DateTimePicker.
This is an adapter class that adapts RadDateTimePicker to IGridViewEditor interface. It is public because it should be initialized with reflection.
The class converts DateTime values to their string representation using the CurrentUICulture.
Provides methods for converting between the DateTime and string types.
Represents a StepTimeSpanComponentBase for picking day TimeSpan intervals.
Represents a definition of a view that shows a single day in day view mode.
Provides a type converter for converting Decimal values to and from other types.
An enumeration that defines the default layouts of a RadVirtualKeyboard.
A read-only collection containing the default time markers.
Provides a simple ICommand implementation.
Holds extension methods for DependencyObject class.
Helper for the properties in Design time.
Holds commands that can be used by a RadDesktopAlert.
Represents an item inside of the MenuItemsSource.
Class that holds all parameters for customizing RadDesktopAlert.
Contains information about the dialog which is going to be shown. It can be canceled.
Structure that holds all parameters for customizing dialog window.
Describes the type a ScheduleView dialog.
Base class for file and folder dialogs.
Describe a move direction.
Compares the distance to a given reference point.
Control used for navigating and selecting panes in RadDocking. It can be opened with Ctrl + Tab combination similar to the IDE Navigator in Visual Studio.
ItemTemplateSelector for the panels and documents lists in the DockingNavigator.
The docking panel is used as part of the RadDocking control to arrange elements.
DoubleRangeBase inherits RangeBase and introduces two new fields - SelectionStart and SelectionEnd. SelectionStart cannot be greater than SelectionEnd and SelectionEnd cannot be less than SelectionStart.
DoubleToArcConverter MultiValueConverter for the Material theme. Created to be used in the BusyIndicator Indeterminate state.
Value converter used with binding to Convert double to GridLength.
An IValueConverter that converts a double to a Thickness based on the parameter.
Represents converter that converts double to TimeSpan using the given parameter.
Represents a behavior of the drag & drop and resize functionality of the RadScheduleView control.
Represents converter, which converts Boolean value to Visibility enumeration value depending on parameter.
Represents the state of a drag or resize operation in RadScheduleView.
The EventArgs for the DragInProgress event of the RadTreeView.
The handler for the TreeViews DragOverTree event.
Represents the visual element displayed after the cursor when an item is dragged.
Represents converter that converts IEnumerable of IOccurrences to localized summary string.
Represent a visual element that is being dragged; usually wraps (fully or partially) another visual element.
This class represents extension methods and attached properties for the RadDropDownButton control.
Determines possible positions in a 2D environment.
The arguments of the TabControl.DropDownOpened and TabControl.DragDropClosed routed event.
An event handler delegate for the drop down events of the TabControl.
Provides an attached property for easier handling of Mouse wheel for DropDownButton, SplitButton, ColorPicker, DateTimePicker, TimeSpanPicker, CalculatorPicker, Breadcrumb.
Define the position where the item will be dropped.
Represents the EAN128 symbology type.
Represents the EAN128A symbology type.
Represents the EAN128B symbology type.
Represents the EAN128C symbology type.
Represents the EAN13 symbology type.
Represents the EAN8 symbology type.
Determines the Extended Channel Interpretation (ECI) mode, which allows for encoding of characters from other sets.
Enumeration that represent the action when dragging or resizing recurrence appointment.
The event args used by the EditorPrepare event of the EditableHeaderedItemsControl.
Handler for the EditorPrepare routed event of the EditableHeaderedItemsControl.
Provides elastic animation capabilities.
Defines properties for decorating TableBase area.
A Collection of ElementProperties.
Represents the encodation used to generate the DataMatrix barcode.
The EncodingMode enumeration determines the type of the acceptable data.
Represents converter, which converts Enum types to and from a boolean value using the given parameter.
Represents converter, which converts Enum types to and from a boolean value using the given parameter.
Represents converter that converts IEnumerable to Visibility.
Determines how much data is available for error correction.
Contains error information.
Represents a binding between an event and a command. The command is potentially a RoutedCommand.
Represents an ordered collection of EventBinding objects.
Behavior that execute command when given event is raised.
ExpandDirection specifies the expanding direction of a control - for example the .
The ExpandMode enumeration is used in RadPanelBar to specify the allowed number of expanded RadPanelBarItem.
Enumerator that indicates the type of the current exporting element.
Export extensions.
Enumerator that indicates the type of exporting mode in use.
Office_BlackTheme class represents the key to the Expression_DarkTheme theme.
Signifies application of special formatting to the code data.
Selects DataTemplate for the icon based on the FilePath property of the RadFilePathPicker control. If null or empty string is provided - EmptyTemplate is used, otherwise - NonEmptyTemplate.
Provides the filtering behavior for the AutoCompleteBox control, allowing users to filter data within collections.
Specifies the FilteringMode of RadComboBox.
Base document viewing control that can host RadFixedDocument.
Represents a converter, which converts Enum values to a Visibility value using the given parameter.
Hold resources used in the FluentTheme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the FluentPalette.
A that allows access to the FluentPalette resources from XAML.
Keys for the FluentPalette resources.
Used to convert ResourceKey types used in FluentResourceKey.
FluentTheme class represents the key to the Fluent theme.
Indicates the state of the RadFluidContentControl.
Provides data for the FluidContentControlStateChanged event.
Represents a helper that gets the focused element in the SL4, SL5 (including OOB) and WPF platforms.
Specifies the direction within a user interface (UI) in which a desired focus change request is attempted. The direction is either based on tab order or by relative direction in layout.
EventArgs used by the FoldActivated and FoldDeactivated events.
Enumeration used by the FoldHintPosition property.
This enumeration describes the 4 corners of the Book.
This class contains Routed commands for the GanttView control.
This control represents a splitter between Gantt's Grid area and the Timeline.
Represents a custom markup extension for creating geometries.
Geometry factory class for producing basic geometries.
Helper class that parses geometries to strings and strings to geometries. Note that strings are created for serialization purposes and cannot be recognized as Geometry Data by the WPF XAML parser.
Defines common geometry types.
GlyphAdorner class for design time support of the TelerikWebUI glyph font. Provides an attached property for TextBlock IsInDesignTime, which when set to true allows the rendering of TelerikWebUI font glyphs in design time.
Enum for the GlyphExportType for the RadGlyphExtension.
Hold resources used in the GreenTheme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the GreenPalette.
A that allows access to the GreenPalette resources from XAML.
Keys for the GreenPalette resources.
Used to convert ResourceKey types used in GreenResourceKey.
GreenTheme class represents the key to the GreenTheme theme.
Provides data for GridViewDataControl AutoGeneratingColumn event.
Contains data needed to handle the BeginningEdit event.
This class inherits from GridViewColumn and add some specific to Data properties such as DataType, DataFormatString.
Allows to control Clipboard operations on a per-cell basis.
Contains info needed to handle CellEditEndedEvent.
Contains data needed to handle the ElementExportingToDocument event when exporting Cell element.
Class that describes GridViewCell as data object. Used to get the appropriate GridViewCell (UI container) in cases when it is recycled.
Enumerator that indicates the type of the cell.
Provides data for the RadGridView.CellValidated event.
Contains data needed to handle the CellValidating event.
Represents the result of the RadGridView validation process. Identifies ErrorMessage and property which causes the error.
GridViewCheckBoxColumn is a column is used to bind to boolean data.
Defines modes that indicate how RadGridView content is copied to the Clipboard.
Allows to control RadGridView Clipboard operations.
Defines modes that indicate how content from the Clipboard is pasted into the RadGridView.
This is a dependency object used to store column's specific data.
Represents a collection of GridViewColumn objects.
EventArgs used for events related to GridViewColumn.
Represents a group of columns with a common header.
GridViewComboBoxColumn provides an easy and fast way to display and edit lookup data. The key properties to set are : valueMemberPath, DisplayMemberPath and ItemsSource.
Provides various options for exporting data in CSV format.
Represents data for the CurrentCellInfoChangedEvent.
This class inherits from GridViewBoundColumnBase and creates appropriate editor element using column's DataType.
Contains the GridViewDataControl extension methods for exporting to XLSX and PDF formats.
Provides data for the Deleted event.
Provides data for the Deleting event.
Provides various options for exporting to XLSX and PDF.
Defines visual export parameters for XLSX and PDF.
GridViewDynamicHyperlinkColumn provides an easy and fast way to display hyperlink. The column dynamically creates hyperlink based on NavigateUrlMemberPaths and NavigateUrlFormatString properties.
Contains data needed to handle the exporting events.
Contains data needed to handle the ElementExportedToDocument event.
Contains data needed to handle the ElementExporting event.
Contains data needed to handle the ElementExportingToDocument event.
Defines visual export parameters for ExcelML.
Provides various options for export.
This column can display the results of a calculation on the data item's properties.
Contains information on performed group operation.
Represents data for the GridViewGrouping event.
Defines visual export parameters for HTML.
GridViewHyperlinkColumn provides an easy and fast way to display hyperlink. The column automatically creates HyperlinkButton based on DataMemberBinding and ContentBinding properties.
GridViewImageColumn provides an easy and fast way to display image. The column automatically creates Image based on DataMemberBinding property.
GridViewLength is the type used for various length properties in GridViewDataControl.
Used to indicate the type of value that DataGridLength is holding.
GridViewMaskedInputColumn is a special column which uses RadMaskedInputBase control as an editor.
Represents a column that uses RadMultiColumnComboBox to edit a single selected value, or a list of selected values.
Provides various options for exporting data in PDF format.
GridViewPinRowColumn provides an easy and fast way to pin/freeze rows in RadGridView.
Contains data needed to handle the PreparingCellForEdit event.
Contains info needed to handle RowEditEndedEvent.
Provides data for the RadGridView.RowValidated event.
Contains data needed to handle the RowValidating event.
GridViewSelectColumn provides an easy and fast way to select rows in RadGridView.
Contains information on performed sort operation.
Provides details about the Sorting event.
Represents a table definition designed to represents data to display in a RadGridView.
Represents a control that visualizes the expand/collapse operation.
Defines the presentation (active template) for a toggle button.
GridViewToggleRowDetailsColumn provides an easy and fast way to toggle row details visibility.
Defines the row details expand behavior for a GridViewToggleRowDetailsColumn.
Defines when RadGridView should validate data.
Defines what validation types should be processed by RadGridView.
Represents a control that creates a container that has a border and a header for user interface (UI) content.
Represents observable collection of GroupDescriptions.
Represents the GroupHeader visual element in RadScheduleView control.
A RadButton implementation that serves as clickable header button. It's MouseOver and Pressed states will be inactive if no Command is attached.
Provides a way to choose a DataTemplate for the GroupHeader based on the data object and the data-bound element.
Converter that creates a string of all parent IGroup names.
Represents a variant for a Group control.
Collection of group variants.
Defines Grouping Event Actions that are passed as arguments to the Grouping Event on item drag.
Enumeration used by the HardPages property.
An interface that is used to calculate an index starting from -1 for the item which is highlighted in the DropDown of the RadAutoCompleteBox.
Represents the highlighted item in RadScheduleView.
Determines the type of a HighlightItem.
Defines different highlight modes for RadHighlightTextBlock.
Represents the highlighted panel.
Stores information for a portion of the RadHighlightTextBlock text that needs to be highlighted.
HostWindowCreatedEventArgs exposes HostWindow property for handling the host created event of a window.
Represents definition of the hot spot of the geographically positioned framework element. The hot spot is the point inside (or outside) of the framework element which should be bound to the geographic location.
Converts from/to HotSpot structure.
Units are used to position hot spot.
Coordinate system which is used to calculate location of the hotspot inside the element.
Represents a StepTimeSpanComponentBase for picking hour TimeSpan intervals.
Supports activation, which indicates whether an instance is active or not.
An interface used by classes, which support deserialization.
Defines basic methods and properties of a category.
Provides an interface for specifying CommandBinding subscription.
A generic interface for copying objects.
Interface providing a recurrence choice dialog window.
Represents the interface for a document editor presenter in the Telerik UI library.
An interface representing the properties needed to the DragDrop functionality to be configured.
Columns which can be exported through the GridViewExportingWriter.
Provides methods for filtering behavior in the AutoCompleteBox control.
An interface that is used to calculate an index starting from -1 for the item which is highlighted in the DropDown of the RadAutoCompleteBox.
All elements with sophisticated localization mechanism have to implement this interface.
Notifies client when starts and finishes updating the layout.
Provides the properties and methods allowing transactional edit operations.
Provides the base methods for a generic object factory.
Interface for radial menu item that is used to populate ItemsSource.
An interface to be used by range selecting controls.
Defines basic methods and properties of a resource.
Defines basic methods and properties of a resource type.
Supports row-like UI elements.
Provides the most important info for scrolling during dragging.
Scrolling Service is used horizontal and vertical scrolling.
A generic interface which provides information about the given service and the service itself.
An interface used to retrieve the service provider.
Defines basic members of a time indicator for ScheduleView.
Defines basic methods and properties of a time marker.
An interface representing the ticks and the corresponding DateTime to every tick.
An interface representing the ticks and the corresponding DateTime and Duration to every tick.
This interface represents a monitor which receives trace events from RadControls. You can implement it if you need to receive trace events from the controls used in your application.
Interface used to store container information.
Provides the core interface for all controls that support variants.
Contains methods and properties of a window.
Provides methods for interoperation with window functionalities.
Represents an icon converter.
Represents IconResource MarkupExtension.
Represents the IconSources resource object.
Represents the visibility of a RadNotifyIcon in the notification area.
Represents the icons sets.
Provides a type converter to convert Image objects from String representation.
Represents converter that converts IAppointment to a string that can be used as a title of a window.
Converts a zero based integer index to natural index. 0 -> 1, 1 -> 2, 2 -> 3, etc. Parameter can be used for setting bigger step. Default step is 1.
Specify the input mode of the DateTimePicker.
Enum InsertMode.
Represents a converter that converts the first object of an Array of integer objects into a double object and vise versa. If the Array is null or empty the converter returns null.
Represents the IntelligentMail symbology type.
Represents an cell info that does not have Item, Column, and it is not associated with a GridViewDataControl.
Converts Boolean values to an inverted format, where true becomes false and false becomes true.
Represents the converter that converts Boolean values to and from 1 and 0 opacity.
Represents the converter that converts Boolean values to and from Visibility enumeration values. InvertedBooleanToVisibilityConverter converts "true" to Visibility.Collapsed and "false" to Visibility.Visible.
Represents converter that converts null or empty string object to Visibility values in an inverted way.
Represents converter that converts Visibility value to its opposite.
Represents the drop relative position of the items when reordering.
Specifies the position of the image within a RadMenuItem element.
This class presents a way to query the state of the various keyboard modifier keys. It also allows you to check the state of the shortcut key for the current platform.
Represents a class that holds which keyboard modifiers are pressed. It is used for the selection behaviors.
Represents the text label for a control and provides support for access keys.
Specifies the display mode for the upper scale - it could be days or months.
Represents a expander layout group.
Represents a layout group, the default group of the RadLayoutControl.
Represents a tab layout group.
Represents a tab group item, the default item of the LayoutControlTabGroup.
The base event args used for RadDocking layout Serialization events.
The event args used for RadDocking layout Serialization cleaning event.
The event args are used for layout Serialization Loading event for custom items.
Defines event arguments used for RadDocking layout Serialization events.
The event arguments used for the RadDocking's layout Serialization Loading event.
The event arguments used for the RadDocking's layout Serialization saving event.
An IValueConverter that converts a LinearGradientBrush to a SolidColorBrush based on a parameter. If there is no converter parameter or the same is not a valid one, the first stop of the LinearGradientBrush will be taken. If the LinearGradientBrush has no stops, the result will be a transparent SolidColorBrush. If a SolidColorBrush is to be converted, the same will simply be returned as a result.
Represents a virtualized panel with smooth scrolling.
Implements a markup extension that returns a localization string.
A converter that uses a localized version of the provided parameter to format the binding value into string. Uses InvariantCulture.
A localization manager class.
Converts data member value to display value for the needs of lookup (ComboBox columns).
Specifies the MaskType used for the RadMaskedTextBox.
This is an adapter class that adapts RadMaskedCurrencyInput to IGridViewEditor interface.
This is an adapter class that adapts RadMaskedDateTimeInput to IGridViewEditor interface.
This is a base adapter class that adapts RadMaskedInputBase to IGridViewEditor interface.
This is an adapter class that adapts RadMaskedNumericInput to IGridViewEditor interface.
This is an adapter class that adapts RadMaskedTextInput to IGridViewEditor interface.
Hold resources used in the MaterialTheme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the MaterialPalette.
A that allows access to the MaterialPalette resources from XAML.
Keys for the MaterialPalette resources.
Used to convert ResourceKey types used in MaterialResourceKey.
MaterialTheme class represents the key to the Material theme.
Provides static methods not included in the standard Math class.
Represents a control that defines choices for users to select.
Defines the different roles that a RadMenuItem can have.
Describes the placement of where a RadMenuItem sub-menu appears on the screen.
Represents a StepTimeSpanComponentBase for picking millisecond TimeSpan intervals.
Represents a StepTimeSpanComponentBase for picking minute TimeSpan intervals.
Represents definition of a view that shows 42 days in month view mode.
Represents possible user actions that can activate a function of a RadNotifyIcon.
MultiBindingBooleanOrConverter.
Represents definition of a view that shows multiple days as in day view mode.
Represents a converter that multiply the value by the passed parameter.
Provides data for navigation buttons events.
A base class for the RadSlideView and RadPipsPager controls.
Exposes all the commands that NavigationSelector utilizes.
Defines constants that specify how the pane is shown in a NavigationView.
Represents control that holds the sub items of a RadNavigationViewItem.
Represents the event arguments for the PopupOpening event.
Represents the event arguments for the Selected event.
Represents converter that returns boolean whether the value is null or not.
Represents converter that converts null or empty string object to Visibility values .
Represents a converter that converts a number value to Visibility value.
An IValueConverter that converts an object to a Type based on the parameter.
A ProjectedView which notifies the user if any of its items' properties get changed.
Hold resources used in the Office2013Theme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the Office2013Palette.
A that allows access to the Office2013Palette resources from XAML.
Keys for the Office2013Palette resources.
Used to convert ResourceKey types used in Office2013ResourceKey.
Office2013Theme class represents the key to the Office2013Theme theme.
Hold resources used in the Office2016Theme theme.
A ResourceDictionary that merges the resources from the Office2016Palette.
A that allows access to the Office2016Palette resources from XAML.
Keys for the Office2016Palette resources.
Used to convert ResourceKey types used in Office2016ResourceKey.
Office2016Theme class represents the key to the Office2016 theme.
Hold resources used in the Office2016TouchTheme theme.
A ResourceDictionary that merges the resources from the Office2016TouchPalette.
A that allows access to the Office2016TouchPalette resources from XAML.
Keys for the Office2016TouchPalette resources.
Used to convert ResourceKey types used in Office2016TouchResourceKey.
Office2016TouchTheme class represents the key to the Office2016Touch theme.
Hold resources used in the Office2019Theme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the Office2019Palette.
A that allows access to the Office2019Palette resources from XAML.
Keys for the Office2019Palette resources.
Used to convert ResourceKey types used in Office2019ResourceKey.
Office2019Theme class represents the key to the Office2019Theme theme.
OfficeColorPalette is the base class for all MSOffice2007 palettes. All office palettes inherit this class and implement GetHeaderColors() and GetGeneratedColors() as well as GetColors() methods.
Office_BlackTheme class represents the key to the Office_Black theme.
Office_BlueTheme class represents the key to the Office_Blue theme.
Office_SilverTheme class represents the key to the Office_Silver theme.
Adds opacity to a specified Color or SolidColorBrush.
Specifies the type of option list that will be formed by the given item.
Provides a way to choose a style for the OrientedAppointmentItem based on the data object and the data-bound element.
Provides a way to choose a style for the OrientedGroupHeader based on the data object and the data-bound element.
Provides a way to choose a style for the OrientedResourceGroupHeader based on the data object and the data-bound element.
Provides a way to choose a style for the TimeRulerItem based on the data object and the data-bound element.
Defines the position of an RadOutlookBarItem.
Describes the ability of an item to be positioned in the Overflow area.
Represents the PDF417 symbology type.
A helper class for resolving the full path to a resource.
EventArgs used by the PreviewPageFlipStarted, PageFlipStarted and PageFlipEnded events.
This enumeration describes whether the page will perform full flip on single click or double click.
Enumeration used by the ShowPageFold property.
Provides data for a page index changed event.
Provides data for a page index changing event.
This enumeration describes the position of a page with respect to the Book.
Specifies how the page controls are displayed on a RadDataPager control.
A custom GridSplitter control used for resizing the top level RadPanelBarItems in a RadPanelBar.
Panel that arrange its children as a StackPanel if no DesiredWidth or DesiredHeight is set or if set as a Grid with Row/Column Definitions.
Contains extension methods for enumerating the parents of an element.
Contains state information and event data associated with a parse date or time routed event.
Describes the location and value of a transition point in visual effects like scale, skew, opacity.
Stores PathStop objects that are used for Opacity, Skew, and Scale effects of the RadCarouselPanel.
Allows a user to view a header and expand that header to see further details, or to collapse a section up to a header.
Allows a user to view a header for some details.
Enumerates the available layouts in TableBase.
Describes the placement of where a Popup control appears on the screen.
Represents the Planet symbology type.
Represents the modes in which the RadNotifyIcon's popup can be closed.
Provides a set of popup related commands.
This class contains attached properties for the Popup class. These properties are meant to be used to fill the gaps between the WPF Popup class and the Silverlight one.
A Popup window that can be used as a normal Window in XBAP application. It uses Popup as a placeholder.
Event arguments class used to pass data whenever a RadOutlookBarItem changes its position, i.e. from ActiveArea to MinimizedArea.
Event handler for the PositionChanged event.
Represents the Postnet symbology type.
Preview event args wrapping tab item that has been changed (Closed, Pinned, Unpinned).
Event args for the PreviewTileStateChanged event.
Defines a range color definition for use in RadCircularProgressBar.
Provides a projected view over a source list.
Panel that arrange its children as a StackPanel if no DesiredWidth or DesiredHeight is set or if set as a Grid with Row/Column Definitions.
Represents the QR symbology type.
Represents a quick access toolbar for a Ribbon.
Specifies the position of a Quick Access ToolBar within a Ribbon control.
Describes the visual appearance of elements in TableBase.
A component that bridges the gap between an app and the next-generation AI language model applications. Use the AIPrompt to provide your users with pre-determined ways to interact with a trained language model of your choice.
A button that displays a RadAIPrompt as the child of a Popup element.
Represents an AIPrompt item that has an AIPromptCommandView for its Content.
Represents an AIPrompt item that has an AIPromptInputView for its Content.
Represents an AIPrompt item, the default item of the RadAIPrompt.
Represents an AIPrompt item that has an AIPromptOutputView for its Content.
Represents a dialog alert control that provides a customizable interface for displaying alerts to the user.
The RadAlert class inherits from ContentControl and allows for the visualization of an icon with
the option to define dialog parameters. It includes an Ok event that is triggered when the user
interacts with the accept button, and it is designed to be hosted within a RadWindow. The icon
area of the dialog can be customized via the IconTemplate property. The Configure method
can be used to set up the alert's parameters and its parent window. The control also supports binding
commands for button interaction and has functionality to set a default focused button when the dialog
is displayed.
Specifies three position alignment.
The Sparkline Area chart consists of a series of data points joined by a line where the area below the line is filled. The area below Axis Origin can be displayed in a different color. Supports indicators.
Represents a customizable auto-completion box control that allows users to select from a filtered list of suggestions based on their input. The RadAutoCompleteBox supports single and multiple selection modes, provides features like watermark content, dropdown item templates, and various behaviors for filtering and highlighting items. It uses dependency properties to manage its state and appearance, including search text, selected items, and dropdown properties. This control includes built-in keyboard navigation and event handling for selection changes, making it suitable for enhancing user input experiences in applications.
Provides commands for the RadAutoCompleteBox control, including functionality to manage item selections.
This static class encapsulates command definitions, specifically the RemoveItem command, which allows
users to remove an item from the current selection. Commands are stored in a thread-safe manner and can
be accessed via properties. The commands leverage localization for user interface text representation.
Represents an item in the RadAutoCompleteBox control, providing features such as displaying text, managing selection, and integrating with data binding.
Represents a text control that makes suggestions to users as they enter text using a keyboard. The app is notified when text has been changed by the user and is responsible for providing relevant suggestions for this control to display.
Provides a set of commands for the RadAutoSuggestBox, allowing users to interact with the suggestion box functionality.
A content control which is attached to an element and usually displays a status, warning, note, count information related to the attached element.
UI control for creating and visualizing barcodes in a machine-readable format.
This control decodes images representing barcodes, such as Code 128, EAN8, etc.
Represents a book-like control that displays its items as pages, allowing users to navigate through them in a realistic manner. The control supports various features including customizable page templates, page flipping animations, virtualizing item containers, and event handling for page turn actions. It includes properties for managing the visual presentation of pages, like fold hints, page dimensions, keyboard navigation, and more. This control is part of the Telerik UI for WPF and is designed to create an interactive reading experience within an application.
Represents a page within a book, allowing for interactive page turning mechanisms such as single and double clicks, as well as drag gestures. This class is designed as a container for the pages of a book, managing the visual states for both normal and interactive behaviors. The RadBookItem class provides properties such as Index to get the page's position in the book, Position to identify the page's side (left or right), and IsHardPaper to indicate whether the page has a hard cover. Event handlers are provided for mouse interactions, allowing developers to respond to actions such as dragging and clicking on the page corners. The class handles visual elements related to shadow effects for a more realistic book presentation.
Provides a navigation control that allows users to easily keep track of their locations within applications or documents. The RadBreadcrumb class supports hierarchical navigation by enabling users to navigate through a breadcrumb-like interface. This control is designed for flexibility, allowing customization of item templates, styles, and various user interaction modes, including text input for quick navigation. It supports features such as history tracking and dynamic item modification, ensuring a seamless user experience while navigating complex data structures or documentation.
Represents an item in a breadcrumb navigation control, providing a way to display and interact with a hierarchical path of navigation. This class extends the functionality of WPF's DependencyObject and implements ISupportInitialize for initialization support. It includes properties for customizing the header, dropdown header, image, text mode path, and a source collection of child items. The Items property maintains a collection of breadcrumb items, and the class manages interaction with an ItemsSource to allow dynamic updating of the breadcrumb items. Additionally, event hooks are provided for handling changes in item collections, ensuring consistency in the displayed data.
Represents a control that indicates a busy state of an application or a specific process. The RadBusyIndicator allows customization of the busy indication through various properties such as IsBusy, BusyContent, and ProgressValue. It can be used to inform users that an operation is in progress, thereby improving user experience. Additionally, the control supports customization of the overlay and progress bar styles through the OverlayStyle and ProgressBarStyle properties. It includes functionality for displaying a localized message during the busy state via the BusyContent property, which can bind a localized string to the indicator. The DisplayAfter property specifies the duration after which the busy indicator is shown, allowing it to avoid flickering for very brief operations. The control also supports indeterminate progress indication through the IsIndeterminate property. Use this control in situations where feedback is needed while an application is busy performing tasks, such as loading data or processing user input.
Represents a customizable button control within the Telerik UI for WPF framework. The RadButton class derives from the Button class and includes additional properties, events, and behaviors that enhance its functionality, such as support for hover effects, corner radius customization, and command binding. It introduces dependency properties like HoverDelay to manage hover interactions, CornerRadius and InnerCornerRadius for visual styling, and routed events like Activate and Hover to handle button interactions. The RadButton also provides visual state management and integrates well with command patterns for MVVM design.
Represents a button group control that can contain multiple buttons, allowing for grouped actions in a navigation interface. This control is designed to facilitate the organization of buttons, providing a consistent layout and styling. It can be themed and supports both WPF and non-WPF frameworks, adapting its behavior accordingly. The RadButtonGroup control automatically adjusts button sizes based on the items it contains and provides the ability to reset themes, apply templates, and manage item containers efficiently.
The RadButtonGroupItem class represents an item in a button group container, providing functionality to manage its visual states based on its position within the parent collection. This class inherits from ContentControl and includes members for initializing its style, applying templates, and managing visual states. It defines two visual states, "FirstContainer" and "DefaultContainer," which determine the appearance of the control based on whether the item is the first container in its collection. The class also provides a method to reset the theme and manage state transitions when visual states change.
Represents a calculator control that extends the CalculatorBase class and implements the IThemable interface.
The RadCalculator provides a customizable user interface for performing arithmetic calculations, with support for various themes.
It features a dependency property for setting the font size, and it includes functionality to reset its theme, manage memory buttons,
and handle automation peers for accessibility. The control is designed to be easily styled and integrated into applications, allowing
for fine-tuned user interface behavior with respect to font and display settings.
Represents a collection of commands for the RadCalculator functionality. This static class provides access to various commands related to calculator operations, such as executing unary and binary operations, managing memory, and performing modifications to the input. Each command is represented as an ICommand and can be used to trigger specific actions within the RadCalculator interface, enhancing user interaction and functionality.
Represents a customizable calculator picker control that allows users to select and input numerical values. It features a drop-down interface for easy access to a calculator while providing properties to manage its state, such as IsDropDownOpen. The control supports automation peer implementations for accessibility purposes and handles mouse wheel events for a better user experience.
Represents a selection control that allows you to select dates from a calendar.
Represents a customizable callout control that provides various shapes and styles for displaying content in a user-friendly manner. The RadCallout class allows users to configure properties such as callout type, arrow type, geometry, text alignment, wrapping, trimming, and corner radius, enabling the creation of visually distinct callouts for user interfaces. It inherits from ContentControl and supports properties for defining geometry and visual appearance, allowing for flexible layouts and detailed customization. Ideal for enhancing user experience with informative overlays that can be styled to match application design.
RadCardView is control that layouts its items as cards based on CardLayout property.
Provides commands for RadCardView.
Represents Group Item in RadCardView.
Represents a Card Item in a RadCardView.
Represents a powerful navigation control that displays a collection of items in a carousel format. It integrates with various data sources and provides features such as touch interaction, automatic data presenter generation, and customizable item templates. The RadCarouselPanel is used for layout management, enabling developers to create visually appealing data presentations. This control supports automatic filtering, selection modes, and reflective item presentation, making it suitable for both simple and complex data visualization scenarios.
Represents a specialized panel that arranges its child elements along a specified path, enabling smooth navigation and customizable visual effects. The RadCarouselPanel supports touch gestures for swiping through items, and allows for various animation effects such as scaling, opacity, and skewing. It provides properties for configuring the number of items displayed, the items moved per swipe, and the animation duration. This panel is typically used for creating carousel-like UI components, allowing items to be brought into view dynamically, while maintaining scroll capabilities and responsive user interaction.
Represents a RadChartBase instance that uses a Cartesian Coordinate System to plot the associated data points.
Represents a 3D chart control that uses a Cartesian Coordinate System to plot the associated data points.
RadChat is control that provides the look and feel of a chat application. It exposes API for managing and display of text and media messages.
Represents a circular progress bar that visually indicates progress and completion. The RadCircularProgressBar is highly customizable, allowing settings for angles, segments, colors, and more. It inherits from RadProgressBar. Key features include:
- Customizable start and end angles to define the segment of the circle that represents progress.
- Control over the number of segments and their density, enabling varied visual representations.
- Support for indeterminate progress state for scenarios where completion cannot be defined.
- Options for rounded segments and color ranges for enhanced visual appeal.
Usage examples include loading indicators, visual completion meters, or any scenario where a circular representation of progress is required.
Represents a selection control that allows you to select time from grid.
The AutomationPeer associated with the RadClock class.
Represents a RadClockItem control.
The AutomationPeer associated with the RadClockItem. This class is obsolete. Use Telerik.Windows.Automation.Peers.RadClockItemAutomationPeer instead.
Represents a collapsible panel component, designed for navigation purposes. The RadCollapsiblePanel class inherits from the Panel class and is optimized to dynamically adjust its height based on the largest button within it. If no large buttons are present, the height is determined by the property. The panel also supports layout customization through attached properties to control the spacing between items and the number of small/medium buttons displayed per column.
Provides UI and logic for displaying and editing data in a from layout.
Exposes all the commands that RadCollectionNavigator utilizes.
The RadColorEditor control is an editor that allows you to select a custom color. It supports several color schemas: RGB, HLS, HSV, CMYK and HEX.
RadColorPaletteView represent a selectable set of colors ordered in a palette. It is an items control that consists of RadColorPaletteView items.
Represents an item in the RadColorPaletteView control.
Represents a color picker control.
ColorSelector enables you to use a group of RadcolorPaletteView objects together. Basically it consists of 3 independent palette views and has SelectedColor property.
Sparkline with rectangular bars with lengths proportional to the values that they represent. Values are indicated using different column fill color.
Represents a combo box control that provides a drop-down list for selecting items, with support for advanced features such as filtering, autocomplete and custom templates.
Registers in the CommandManager all the commands that RadComboBox exposes.
Represents extensions for RadComboBox UISelection command.
Implements a selectable item inside a RadComboBox.
Represents a dialog that prompts the user for confirmation, allowing the user
to either proceed with the action or cancel it. Inherits from the RadAlert
class and provides additional functionality like customizable margins for the
content area and the ability to handle user-triggered cancel events. The dialog
features dedicated buttons for "Ok" and "Cancel," and supports configuration
parameters that allow further customization of the dialog appearance and behavior
when shown within a RadWindow.
Represents a context menu control that allows for the hierarchical organization of elements, each with associated event handlers. This control provides the ability to customize its appearance and behavior using dependency properties such as IsOpen, StaysOpen, and Placement. The context menu can be opened via various events, with control over its positioning relative to associated elements using properties like HorizontalOffset and VerticalOffset. It supports features such as inheriting the DataContext from its associated element, attaching to events, and managing its open/close states through routed events.
The AutomationPeer associated with the RadContextMenu class.
Static container for the Theme attached property.
A base class for the horizontal and vertical data axes.
A control that contains a bar, the length of which represents a value in correspondence to the set minimum, maximum and origin value.
The base class for RadDataBars implementing common properties and logic.
Provides a user interface for creating filtering expressions.
Provides a view of the FilterDescriptors collection of a QueryableCollectionView and allows for modifying the filters through a RadDataFilter.
All commands that RadDataFilterView exposes.
Provides UI and logic for displaying and editing data in a from layout.
All commands that RadDataForm exposes.
Provides a user interface for paging through a collection of data.
All commands that RadDataPager exposes.
Provides an object for loading, paging, filtering, sorting and editing entities coming from a WCF Data Service.
Represents an input control for entering Dates.
Represents an input control for selecting a range of two dates.
Represents a control that allows the user to select dates and times.
Represents the method that will handle the Telerik.Windows.Controls.RadDateTimePicker.ParseDateTimeValue routed event.
Registers in the CommandManager all the commands that RadDateTimePicker exposes.
Represents a customizable desktop alert notification that can display information to the user through various properties and events. The RadDesktopAlert can be configured to automatically close after a specified duration, can include an icon, and offers options for showing close and menu buttons. Users can interact with the alert—clicking it raises a click event, while the presence of a command enables the invocation of predefined methods. Furthermore, it supports appearing in the Task Switcher and can display a dropdown menu, providing a flexible way to present alerts within a desktop application.
Provides management for desktop alerts, allowing registration, display, animation, and positioning of alerts on the screen. The class supports multiple constructors for customizing the alerts' screen position, offset, and distance between alerts. It includes animation functionalities for showing and hiding alerts, as well as customizing those animations' duration and behavior. The manager facilitates adding and removing alerts, controlling their visibility, and ensuring they are displayed in an organized manner according to user-defined settings. This class also manages alert positioning, enables attachment to specific windows for context-sensitive display, and provides functionality to detach alerts from those windows, restoring default behavior. The built-in event handling for alert windows allows for seamless interaction and management of alert lifecycle events.
Represents the diagram control.
The RadDiagramConnection is a special ContentControl that serves as a connection between zero, one or two shapes.
A shape which holds other shapes much like an items container.
A shape with geometric content.
Represents a panel that supports docking child elements along the edges (top, bottom, left, right) and allows the last child element to optionally fill the remaining available space. The RadDockPanel facilitates the arrangement of its children based on the specified Dock property, promoting a flexible layout structure suitable for various UI designs. It provides attached properties for setting the Dock position of individual child elements and includes a property to control whether the last child fills the available area. The layout system of RadDockPanel ensures that the child elements are measured and arranged properly during rendering, adapting to changes in size and visibility.
Represents a docking control that provides a flexible layout system for managing panes, tool windows, and document hosts.
Provides static members for managing commands associated with RadDocking panes, such as closing, pinning, making panes floating or dockable, and managing context menus. This class encapsulates a set of routed UI commands that can be utilized in the context of a user interface implementing RadDocking, enabling the manipulation and control of pane behavior in a consistent manner.
Represents a pane for displaying documents within a user interface. The RadDocumentPane class inherits from RadPane and implements the IDocumentPane interface, providing a container for document-related content. This class allows for customization of styling and behavior in WPF applications, making it suitable for use in complex document management scenarios. The static constructor initializes static members to set the default style, ensuring a consistent appearance across instances of the RadDocumentPane class.
Initializes a new instance of the RadDragCompletedEventArgs class. Provides data for the RadDragCompleted event that occurs when a user completes a drag operation with the mouse of Thumb control.
Provides data for the RadDragDelta event that occurs one or more times when a user drags a Thumb control with the mouse.
Provides data for the RadDragStarted event that occurs when a user drags a Thumb control with the mouse.
Represents a customizable drop-down button that combines the functionalities of a standard button and a pop-up. The RadDropDownButton allows for displaying a drop-down content area when clicked, enabling users to select options or display additional information. This control offers features such as:
- Configurable drop-down content and templates
- Options to manage the button's open and close behaviors, including automatic closing on Escape or Enter key presses
- Control of visibility, position, and dimensions of the drop-down area
- Events to handle opening and closing of the drop-down, providing a rich user interaction experience.
The RadDropDownButton is designed for use in UI scenarios where hierarchical options or extended actions need to be displayed without cluttering the main interface.
Provides an object for loading, paging, filtering, sorting, and editing entities coming from EntityFrameworkCore's DbContext.
Represents a collapsible content control that can expand and collapse to reveal or hide its content.
The RadExpander class derives from HeaderedContentControl and implements the IThemable interface.
It provides features for handling expansion and collapsing events, customizing the appearance of the header and button,
and managing the visual states corresponding to the various expansion directions.
The IsExpanded property determines whether the content is currently displayed.
The control also includes properties for various header alignments, orientations, and styles, as well as events that notify
when the content is expanded or collapsed.
A control that lets the user input an expression in string form, which it exposes as a LINQ expression.
Provides a number of useful RadExpressionEditor functions exposed through Commanding.
A class that contains various helpful extension methods for RadExpressionEditor
Control used for choosing a valid file / folder path via file / folder dialog or via typing in watermark text box.
The RadFluidContentControl is a specialized content control that dynamically adjusts which of its three content properties is displayed based on the available space. It utilizes customizable thresholds to precisely define the conditions under which the content changes visibility, allowing for seamless transitions between different content states: Small, Normal, and Large. This control is especially useful for responsive designs where the layout adapts to varying screen sizes or layout changes.
Represents a special chart that visualizes its data points using trapezoid segments forming a 'funnel'.
Represents a gallery control that displays a collection of items with customizable dimensions and styling.
Represents an item in a RadGallery control, which can display an image and optionally act as a header.
Represents a glyph element in the Telerik UI for WPF framework. The RadGlyph class is designed for rendering text-based icons or symbols both at runtime and design time. It includes properties to customize the glyph's appearance, such as Glyph, Foreground, Background, and FontSize. The class also supports theming through the IThemable interface, allowing it to adapt its style according to the active theme. The glyph can be used to create visually rich user interfaces, providing flexibility in customizing icons within WPF applications.
Provides a MarkupExtension for rendering glyphs using customizable fonts, sizes, and colors in a WPF application. This class allows the user to set default font properties and provides methods to obtain glyph images or geometries based on specified parameters. It supports dynamic changes to the glyph's size, foreground color, and font name, while ensuring that appropriate validation is in place for input values. The glyph can be rendered as either an image or a path based on the target property type. Default values for the font name and size are provided, making the extension easy to use in various contexts.
RadGridView is the ultimate data grid control with outstanding performance and remarkable flexibility. The component enables you to create fully customizable and highly interactive interfaces for displaying and shaping of large data.
Provides a collection of routed UI commands used for managing interactions within a RadGridView component. Each command corresponds to specific functionalities such as editing, navigating, copying, deleting, and searching within the grid view. These commands can be invoked via user interface actions (e.g., keyboard shortcuts) and are designed to enhance user experience by providing a consistent means of managing grid data operations. The class initializes commands in a static constructor and provides static properties to access each command, ensuring they are created and ready for use.
Use as a heading in ribbon context menus.
A data visualization control that represents values in a tabular display. The data is displayed in cells, aligned in rows and columns and each cell has a color that corresponds to the value of the cell. The color of the cell is generated by a HeatMapColorizer. The RadHeatMap needs a valid HeatMapDefinition in order to plot the cells and colors correctly.
Represents a customizable text block that highlights specific portions of its text based on predefined criteria. This class extends the TextBlock control, introducing properties to specify which text to highlight and how to style the highlighted text. It includes features such as case sensitivity, different highlight modes (first match, last match, all matches), and customizable foreground and background colors for the highlighted text. The RadHighlightTextBlock class supports theming through the IThemable interface, allowing it to adapt its style based on the current application theme. The highlighted text is refreshed dynamically when the underlying text or highlight properties change. Additionally, it integrates with the automation framework, enabling accessibility features.
The RadHorizontalBulletGraph control is a variation of linear gauge. It combines a number of indicators, as well as the data indicator, into one control, which is light weight, easily customizable and straightforward to setup and use. The control is a great tool for dashboards as it is the optimal way to present a lot of information in relatively small size.
Represents a visual axis with ticks and labels.
Represents horizontal linear gauge.
Represents a RadButton that functions as a hyperlink button, allowing users to navigate to a specified URI when clicked. The RadHyperlinkButton class provides several dependency properties:
- NavigateUri: The URI to navigate to upon button click.
- TargetName: The name of the target window or frame in which the URI should be opened.
- IsVisited: Indicates whether the hyperlink has been clicked at least once.
- VisitedForeground: Defines the foreground color of the hyperlink after it has been visited.
RadImageEditor is powerful UI component for image editing.
RadImageEditor is powerful UI component for image editing with predefined UI.
Represents a layout control that allows for the arrangement and manipulation of its child elements. The RadLayoutControl facilitates drag-and-drop operations, enabling users to reorder and resize layout items visually. It includes support for dynamic layouts, serialization of child elements, and customizable appearance based on themes. This control also provides mechanisms for handling user interactions such as selection changes and context menu actions, making it a versatile component for building responsive and adaptive user interfaces.
Represents a control for displaying a legend in data visualizations. The RadLegend allows you to customize the presentation of legend items through properties such as ItemsPanel, ItemTemplate, and DefaultMarkerGeometry. It supports hover effects on items via the HoverMode property and provides a collection of LegendItems to represent data categories. This control is primarily designed to enhance the interactivity and presentation of data visualizations in applications.
Sparkline that displays a set of data points connected by a line. Supports indicators and normal range.
Represents a control that displays a list of items with interactive features, allowing users to select, manipulate, and reorder items through touch and keyboard input. The RadListBox supports drag-and-drop functionality, customizable visual elements, and seamless scrolling experiences, making it suitable for advanced user interfaces. It includes various dependency properties such as DropVisualProvider and DragDropBehavior that enhance its interactivity, as well as powerful selection and navigation capabilities.
Represents the base class that is responsible for the drag and drop in the RadListBox control.
Represents drag and drop helper for the RadListBox control.
Represents a selectable item within the RadListBox control, which allows users to select and interact with items in a list. The RadListBoxItem class supports various visual states such as Normal, MouseOver, Disabled, Selected, and Unselected, enabling dynamic styling based on user interactions. This class also integrates with the UI Automation framework to improve accessibility. It can be customized through templates and extends the functionality of list items in applications built using Telerik controls.
Represents the RadMap class.
Represents the RadMaskedCurrencyInput control.
Represents the RadMaskedDateTimeInput control.
Represents the base class for RadMaskedInput controls.
Represents the RadMaskedNumericInput control.
Represents a base class for sectioned input controls.
Represents the RadMaskedTextInput control.
Represents a menu control that allows for hierarchical organization of items, providing a dynamic user interface for navigating through a set of options. The RadMenu class includes support for main menu activation, orientation configuration, delay settings for showing and hiding menu items, and keyboard navigation. It is designed to facilitate the creation of interactive menus in a WPF application, allowing for comprehensive control over the visual representation and behavior of menu items.
The AutomationPeer associated with the RadMenu class.
Represents a group item within a RadMenu, RadContextMenu, RadMenuItem or RadMenuGroupItem, allowing for hierarchical organization of menu items. This class inherits from RadMenuItem and provides enhanced keyboard navigation, style management, and focus handling tailored for menu group items. It supports both WPF and Silverlight frameworks, with specific implementations for each. It facilitates user interaction by managing focus traversal with directional navigation and handles keyboard events for navigating through the items in the menu, including handling left, right, up, and down key actions appropriately. This class also provides mechanisms to determine whether menu items should be their own containers, and to create automation peers for UI automation purposes.
Represents an item in a RadMenu or RadContextMenu. The RadMenuItem can be configured to display various visual states, handle commands, and accommodate submenu structures. It supports various properties including icons, headers, and checked states, thereby enhancing the flexibility and usability of menu navigation in WPF applications. The class implements ICommandSource interface to facilitate command binding and also inherits from HeaderedItemsControl to organize and manage child items hierarchically. The RadMenuItem is highly customizable through styling and template selection, allowing for tailored UI experiences.
The AutomationPeer associated with the RadMenuItem class.
Represents a separator item in a RadMenu, providing a visual break between menu items. The RadMenuSeparatorItem class extends RadMenuItem and is intended for use within navigation menus. It initializes as a separator with no menu text or value, ensuring a clear distinction between items. This class overrides the default style key property and handles visual states based on the orientation of the menu (either horizontal or vertical). The separator itself does not display an icon and adapts accordingly to the menu's orientation.
Represents a multi-column combo box control that allows users to select multiple items with enhanced search capabilities and customizable templates. This class derives from Control and implements the IThemable interface, allowing for theming support. The RadMultiColumnComboBox features options to customize the dropdown content, styling, and search behavior, as well as properties for managing selection visibility, editor requirements, and footer content. Events such as InitializeDropDownContentManager enable further customization during the initialization of the drop-down content manager.
Represents a control that implements a modern hamburger menu navigation system for application content. This class provides a flexible and responsive interface for managing navigation views with multiple display modes, including Compact, Expanded, and Minimal. It allows for navigation item selection, keyboard navigation, and visual feedback for item interactions. The control supports a hierarchical structure, enabling the creation of expandable items and submenus. It also includes features such as customizable panes, automatic display mode switching based on width, and event handling for item clicks, pane openings, and closures. The RadNavigationView can be styled and themed to suit different application designs, making it a versatile choice for modern applications.
Represents a navigable item in a RadNavigationView control. The RadNavigationViewItem serves as a container for navigation items, providing functionality for expanding and collapsing sub-items. It supports a variety of properties for customizing the display of icons, item templates, and item styles, as well as commands for item selection and highlighting. Additionally, it manages hierarchical relationships with support for displaying nested items and tracking selected states. Routed events for expansion and collapse allow for a responsive user interface along with built-in animations for visual transitions.
Provides a WPF control that represents a system tray icon with customizable features such as balloon tips, popups, and context menus. The RadNotifyIcon can be used to display an icon in the Windows notification area (system tray), allowing for user interaction with mouse events like clicks and movements. It offers various properties to customize its appearance and behavior such as TrayIcon, BalloonTitle, PopupContent, and more. Additionally, events are raised for user interactions, allowing developers to respond to user's actions, such as opening popups or displaying context menus.
Represents a RadNumericUpDown control.
The RadOfficeNavigationBar class represents a navigation bar that facilitates seamless navigation between various views within an application. It allows users to access a streamlined subset of a view in a popup window, dynamically manages the visibility of items through an , and provides extensive customization options via the OfficeNavigationBarDialog. The class supports features such as drag-and-drop reordering of items, compact mode for displaying minimal content, and peek popups for contextual information. The navigation bar enhances the user experience by providing intuitive keyboard navigation, responsive item selection, and automated handling of item visibility based on the available space. Overall, it serves as an effective tool for organizing and presenting content in a user-friendly manner.
Represents an item in a RadOfficeNavigationBar control that provides a peek popup feature for additional content display. This class derives from the class and implements the IThemable interface. It includes several dependency properties such as PeekPopupContent for the content of the peek popup, PeekPopupContentTemplate to define its data template, and PeekPopupStyle for its visual style. The item supports functionality for displaying and closing the peek popup based on mouse and key events, offering a responsive navigation experience.
Represents a dialog that allows user selection of filename for a file to be opened.
Represents a dialog that allows user selection of folders.
This class defines a panel capable of arranging its child elements in either two or three rows based on its size. The layout of the items can vary between the compressed (three-row) and normal (two-row) states.
Represents a navigation control that mimics the functionality of the Microsoft Outlook navigation bar. The RadOutlookBar provides a user-friendly interface for managing items in a minimized or expanded state. It allows users to navigate between different views and organize their workflow efficiently by using various items that can be arranged in active areas and minimized areas. The control also supports customization of appearance, including styles and templates for minimized items, and integrates events to handle item selection and state changes like minimizing or restoring the bar. Additionally, it handles dynamic content updates, ensuring that the UI remains responsive as items are added or removed.
Represents an item in a RadOutlookBar that can hold a header and associated content. This class allows customization of visual elements such as icons, titles, and content templates for both active and minimized states. It supports visual states, event handling for position changes, and styling through templates. The RadOutlookBarItem can be positioned in active, minimized, or overflow areas and displays different icons depending on its state. The class also provides various dependency properties to control its appearance and behavior.
Represents a pane control that can be pinned, docked, or floated within a RadDocking layout. The RadPane class inherits from RadTabItem and implements multiple interfaces such as IPane, IDocumentHostAware, IToolWindowAware, IActiveAware, and IActiveAwareExtended. It provides support for visual states, including Normal, Selected, MouseOver, Disabled, Focused, and others, allowing for extensive customization of its behavior and appearance.
The RadPane includes properties for managing its active state, hidden state and pinned state. It also supports context menus and provides events to handle activation and deactivation, making it ideal for complex UI scenarios such as tabbed interfaces, tool windows, and document hosts.
Represents a group of panes within a docking layout, providing functionality for managing and organizing panes.
Initializes a new instance of the RadTreeView class.
Represents an item in the RadPanelBar control.
Represents a password input control that allows users to enter passwords securely. This control masks the input with a specified character (default is a bullet character '●'), and provides options to show the password through a button that toggles visibility. It also supports password-related events, including notifying when the password changes. The secure password is stored using SecureString to protect sensitive data against memory inspection. Additional features include customizable button content, and visibility controls for the password display button.
Represents a customizable button control that displays a path geometry and allows for configurable content placement and style. Inherits from RadButton and provides additional properties such as PathGeometry and PathStyle to define the visual aspects of the button. The control supports multiple content placement options and margins, enhancing layout flexibility in user interfaces.
Represents a PDF viewer control that provides functionality for displaying, interacting with, and manipulating PDF documents in a WPF application. This class inherits from FixedDocumentViewerBase and includes features such as key bindings for navigation, document source management, and signature validation properties.
Represents a customizable toolbar for the RadPdfViewer control, providing various PDF viewing and manipulation functionalities such as opening, saving, printing, rotating, navigating pages, zooming, and adding signatures. The toolbar allows developers to show or hide specific buttons and options based on user needs. It utilizes dependency properties to manage the visibility of toolbar elements and provides methods for applying themes and updating visibility dynamically.
Represents a special chart that visualizes its data points using arc segments.
Represents a control that enables navigation within linearly paginated content and can be used as a navigation assistant for other controls, such as the RadSlideView. The RadPipsPager provides visual indicators, or "pips," that represent each page, allowing users to easily navigate through them. It supports features such as selectable items, customizable item size and margin, and the ability to specify the maximum number of visible pips. The class also includes automation support to enhance accessibility and provides methods to center the view around the currently selected item.
Represents a navigable item in the RadPipsPager control. This class derives from and implements the IThemable interface. It provides a visual element that can be selected to indicate pagination functionality.
A Control that is used to setup a pivot grouping.
Represents a control that displays data in a customizable pivot.
RadPivotMap displays a flat collection of items that are grouped together. Each item is represented by a rectangle where rectangle's area represents a value extracted from the underlying item. The sum of the values for all child items is equal to the value of the parent item.
Represents a RadChartBase instance that uses Polar coordinate system to plot data points.
The RadProgressBar control can be used to to indicate the progress of an operation. It gives to an end-user visual feedback about an operation he is waiting for to complete.
Represents a dialog that prompts the user for input. Inherits from RadConfirm and includes a text box for user input.
This class exposes a PromptResult property, which holds the result of the user's input, and allows customization of the dialog window
through the Configure method. The SetupBindingsAndCommands method binds the text box to the PromptResult property,
enabling two-way data binding. The class is designed for use in applications utilizing the Telerik UI components and handles initialization
and styling specific to either WPF or non-WPF platforms. This class also raises an Ok event, allowing for handling of user confirmation.
Provides infrastructure for command execution for RadPropertyGrid.
Exposes the commands defined by RadPropertyGrid.
Represents North-East oriented Quadrant radial gauge.
Represents North-West oriented Quadrant radial gauge.
Represents South-East oriented Quadrant radial gauge.
Represents South-West oriented Quadrant radial gauge.
Represents full-circle radial gauge.
Represents a radial menu control that allows users to interact with a set of commands arranged in a circular layout. This control can be customized with various options and is often used for providing quick access to frequently used functions or commands in an application.
Represents the method that handles the PreviewToolTipOpen routed events.
Defines a menu item that is used to visualize radial menu item along with its children within a RadRadialMenu component.
A RadioButton control.
Represents an abstract base class for controls that define a range of values, supporting properties such as Minimum, Maximum, SmallChange, LargeChange, and current Value. This class enables functionality for manipulating the value within defined limits and supports automatic reverse behavior when the value reaches either endpoint. It provides robust event handling for value changes, enabling easy data binding and client-side control of the range's behavior in UI applications.
Represents the event data for value change events in a range control. This class provides the old and new values that triggered the event.
Rating control is a flexible UI component that allows users to intuitively rate by selecting number of items [stars].
An item used in a rating control.
Represents a backstage view for a RadRibbonView, providing a customizable area for application-level commands and options.
Represents an item in a RadRibbonBackstage control, which can be used to display commands, separators, or other interactive elements.
Represents a customizable button control designed for use in a RadRibbonView. The RadRibbonButton class inherits from RadButton and implements the IRibbonButton and IVariantControl interfaces. This class provides properties for managing text and images across different button sizes, and includes options for auto-sizing, text splitting, and collapsing behaviors. The RadRibbonButton supports a dual-text display with properties for both TextRow1 and TextRow2, enabling rich, contextual button labeling. Additional properties such as Size and CurrentSize allow for control over the button's appearance and behavior based on available space in the Ribbon layout, while the SmallImage and LargeImage properties facilitate the setting of different icons for various button states. Inherits and extends the functionality of the base class to ensure a cohesive user experience within a Ribbon control layout. The class provides callbacks that manage property changes and layout adjustments dynamically.
Represents a combo box control designed for use within a RadRibbonView, providing enhanced styling and theming capabilities.
Represents an item within a RadRibbonComboBox control, providing additional styling and behavior specific to ribbon-based user interfaces.
Provides a set of predefined commands for managing window operations in applications with a RadRibbonView.
Represents a contextual group in a RadRibbonView control, which is used to group related ribbon tabs and visually distinguish them with a unique color and header. Contextual groups are typically used to display tabs that are relevant only in specific contexts or workflows.
Represents a button in a RadRibbonView that displays a dropdown menu, allowing for the selection of items in a navigation-style interface. This control combines button functionalities with additional properties to manage appearance, sizing, image, and text layout for different states (small, medium, and large). It supports features such as automatic sizing, customizable collapse thresholds, and image handling. The button triggers popup interactions with child controls and handles visual state changes dynamically based on its properties.
Represents a gallery control designed for use within a ribbon interface, providing a customizable and interactive way to display and select items. The RadRibbonGallery supports features such as compression thresholds, popup menus, and scrolling.
Represents a group of related controls within a RadRibbonTab in a ribbon interface.
Represents a radio button designed for use in a RadRibbonView, combining image and text support with resizing capabilities. The RadRibbonRadioButton class inherits from RadRadioButton and implements the IRibbonButton and IVariantControl interfaces, enabling a flexible and visually organized way to present radio button options in a ribbon-style layout. This button includes multiple text rows, configurable images for different button sizes, and properties that allow for automatic resizing behavior to accommodate varying display requirements. The radio button's appearance can be influenced, via dependency properties, by factors such as button size, image display, and text visibility, thus creating a tailored user experience as per the application’s UI needs.
Represents a split button control specifically designed for use within a ribbon interface. This class extends the functionality of the RadSplitButton to include features typical of a ribbon button, such as multi-line text support and automatic resizing based on the available space. The RadRibbonSplitButton includes properties for managing text, images (both small and large), and size, allowing for flexible customization. The control also provides functionality to manage drop-down popups and their behavior during user interactions, as well as various template parts for layout customization. The split button can display two rows of text and adjusts its visual appearance and behavior according to the current state and size. This control effectively enhances the user experience in ribbon-based applications by providing a visually appealing and easy-to-use button interface.
Represents a tab within a RadRibbonView, providing a container for ribbon groups and functionalities related to tab management. The RadRibbonTab control supports visual states for contextual and non-contextual tabs, as well as selection states. It allows for customization of the header visibility, background appearance when minimized, and association with contextual groups. This class also implements theming capabilities and provides hooks for event handling when the tab is selected or unselected. Additionally, it provides a way to manage visibility and layout of contained elements based on the ribbon's state.
Represents a toggle button for a RadRibbonView.
The RadRibbonToggleButton class inherits from RadToggleButton and implements
the IRibbonButton and IVariantControl interfaces.
This control allows users to toggle settings or commands with associated text and images
displayed in various sizes. It supports features such as different text labels for button states,
customizable images for small and large states, and configurable sizing behavior depending
on the available space in the ribbon layout. The button can automatically adjust its size and appearance
based on the provided CollapseThreshold settings for small and medium sizes.
Additionally, it provides properties for defining the current button size and
supports automation peer creation for user interface automation scenarios.
Represents a ribbon-style control that provides a user interface for organizing commands into tabs and groups.
Represents a window that integrates a ribbon interface, providing advanced theming, styling, and customization options.
Represents rich text box control, which can be used to visualize and edit RadDocument.
This is an adapter class that adapts RadRichTextBox to IGridViewEditor interface. It is public because it should be initialized with reflection.
This class is a base class for all UI Rows.
Represents a dialog that allows user selection of filename for file to be saved.
Scatter Sparkline displays values as a set of separated points. Supports indicators and normal range. Indicated values are shown in a different color.
RadScheduleView is a radically different scheduling component, going beyond the standard Microsoft Outlook-style control. The ScheduleView empowers end users with unprecedented control over precision and flexibility when handling their appointments. This is achieved through features such as multi-level grouping, powerful zoom for smart navigation through a large number of appointments and blazing fast scrolling.
All commands that the ScheduleViewBase exposes.
Provides data for the SelectionChanged and PreviewSelectionChanged events of RadTabControl.
Represents the method that will handle the SelectionChanged and PreviewSelectionChanged routed events of RadTabControl.
Represents East-oriented semicircle radial gauge.
Represents North-oriented semicircle radial gauge.
Represents South-oriented semicircle radial gauge.
Represents West-oriented semicircle radial gauge.
Represents a navigation control that allows users to slide between different views, enabling swipe gestures to navigate through a collection of items. This class provides functionality to configure the presentation and transition animations of the items and manage the visibility of navigation buttons. It supports both horizontal and vertical orientation for item display and allows customization of swipe behavior, including the handling of swiping thresholds to determine when the displayed view should change. This control is suitable for implementing galleries, item carousels, or any scenario where a smooth transition between views is desired.
Represents a slider control that allows users to select a value from a specified range. The RadSlider enables users to make precise selections by sliding a thumb along a track, with support for both single and multiple range selections. It offers various customization options for appearance and behavior, such as styling the thumbs, setting tooltips for enhanced usability, and enabling snapping to tick marks. This control provides user-friendly interaction for modifying values seamlessly within a designated range, making it suitable for applications requiring value selection with visual feedback.
UI AutomationPeer class for RadSlider.
Provides functionality for checking spelling in various types of controls. The class allows for spell checking in two modes: word-by-word and all at once. It manages the display of custom windows for error correction and handles the completion of spell checking tasks through events. The spell checker configuration and window display settings are customizable through the WindowSettings property. It raises the SpellCheckingCompleted event to signal when the spell checking operation is complete, allowing for appropriate responses or notifications to be triggered once checking is finished.
Represents a customizable splash screen control that provides visual feedback to users during application loading or operation stages. This class allows for configuration of various properties including progress visibility, progress values, an accompanying image, and footer content. The control includes dependency properties for managing the state and appearance of the splash screen, such as ProgressBarVisibility, ProgressValue, ImagePath, Footer, and more.
Provides a static class for managing the display and behavior of a splash screen in a WPF application.
The RadSplashScreenManager allows for customization of the splash screen's content, animations,
and initial display properties. It provides methods to show and close the splash screen, as well as
properties to configure the data context, position, and animations applied during the opening and closing
of the splash screen. Multiple instances of the splash screen cannot be displayed simultaneously, and
proper exception handling is implemented to prevent such scenarios. Defaults are provided for animation
effects and initial settings upon manager reset.
Represents a split button that facilitates a primary action and offers a drop-down menu with additional supplementary actions. This class includes properties for managing the visibility of its components, the ability to check and uncheck the button, and control over the drop-down menu's appearance and behavior. The RadSplitButton supports events for actions such as clicking the button, opening, closing, and toggling the drop-down. It is designed to be styled and customized, providing features like auto-open delays and command binding for integration into MVVM architectures.
Represents a split container that can hold multiple items in a resizable layout. The RadSplitContainer can be oriented either horizontally or vertically, allowing for flexible layouts in user interfaces. It supports docking of child items and includes functionality for managing the visibility and arrangement of its child components. This class also implements several interfaces for enhanced behavior in document hosts and tool windows, providing theming capabilities and supporting resize operations.
Represents the RadSpreadsheet control.
The ribbon of the RadSpreadsheet.
Represents a control that stacks data bars, the lengths of which represent values from an items source, in correspondence to total sum of the values.
Represents a control that stacks data bars, the lengths of which represent values from an items source, in correspondence to the set minimum and maximum.
An ItemsControl representing a multi step process where moving to the next step increases the overall progress value. Generally steps have 3 major statuses - NotStarted, Completed and Indeterminate. Usually each step from the first to the current one is in Completed state and every other is in NotStarted state.
Represents a single step item within a RadStepProgressBar control, supporting multiple states such as Not Started, Indeterminate, and Completed. This class provides properties for customizing the indicator content, layout, and appearance of the step item, including template selectors and content formatting. It automatically adjusts its size based on content and interaction, facilitating dynamic visual representation of the step's progress.
Represents a control for displaying SVG images in a WPF application. The RadSvgImage class allows for the rendering of SVG files or XML strings as visual content, providing various properties for customization such as UriSource, XmlSource, ImageSource, and options to override colors and stroke widths. It supports animations and custom brushes, enabling the user to tailor the SVG image's appearance to fit specific requirements. The class integrates with the WPF rendering system, ensuring appropriate measurement and layout through dependency properties such as SizeType. Additionally, it handles loading SVG data from various sources, including local files and URI schemes, while maintaining the application’s context through the BaseUri property.
This implements a markup extension that enables the creation of DrawingImage from SVG sources.
This is an abstract implementation of a markup extension that enables the creation of DrawingImage from SVG sources.
Class RadSyntaxEditor. Implements the ITextDocumentEditor
A navigation control used to create tabbed interface.
Represents a tab item, the default item of the RadTabControl.
A Window component which hosts RadTabControl and simulates browser behavior. Tabs can be selected, pinned, unpinned, closed, reordered.
Represents a task board control that allows users to display and manage tasks in a visual manner. The RadTaskBoard provides features for organizing tasks into columns, enabling drag-and-drop functionality, and responding to user interactions through touch and click events. Users can customize columns, control their widths, heights, and templates, and manage task grouping through various properties and events. The control supports automatic generation of columns based on the provided data source and allows for the addition, removal, and reordering of tasks with smooth animation and visual feedback.
Represents a card in a task board, allowing the display and manipulation of task-related information such as assignees, tags, icons, and categories. The RadTaskBoardCard class inherits from and provides various dependency properties to define its visual elements, including the task ID, assignee, associated tags, and templates for displaying icons and tags. It also offers functionality for resolving the category brush based on the specified category name and provides options to show or hide category indicators. The card is designed to be used within a RadTaskBoard and supports customization through styles and templates.
Represents an item in a task board that can be selected or dragged. This class derives from ContentControl and provides functionality for managing the selected state and dragging behavior of task board items.
Represents a tick bar control that allows users to select a value from a specified range by visually indicating the minimum and maximum values, as well as the directional properties of the control. The RadTickBar class extends the and includes properties such as Minimum and Maximum to define the range of values, and IsDirectionReversed to control the direction of the value selection. This class is useful in scenarios where a visual representation of a range of values is needed, such as in slider controls.
Represents a control that displays a collection of tiles in a list format, allowing for easy organization and interaction with the items. The RadTileList supports features like auto-generation of tiles, grouping, and selection handling, as well as layout management for tiles in a customizable manner. It provides various properties to control the appearance and behavior of the tiles, including TileReorderMode for reordering tiles, Grouping capabilities based on a specified property, and support for touch interactions for handling drag-and-drop scenarios.
An items control that is suitable for building interactive dashboard-like layouts.
Represents an item in the RadTileView control, providing functionality to manage its visual state, size, selection, and position. This class allows for customizing the appearance and behavior of the tile within a tile view layout, including methods to handle tile state changes, positioning, and event management. It also supports mouse interaction for dragging and toggling states (minimized, restored, and maximized).
The RadTimeBar is a time bound DataVisualization control. Its chief purpose is to allow lightweight scrolling and navigation through large periods of time.
Input control for entering time.
Represents a control that allows the user to select TimeSpans.
Represents a control that allows you to select TimeSpan values used to construct the Value of a RadTimeSpanPicker .
The RadTimeline is a time bound DataVisualization control. Its chief purpose is to allow lightweight scrolling and navigation through large periods of time.
Represents a toggle button control that allows users to switch between two states: checked and unchecked. This control supports customization of corner radius, background visibility, and command binding for a more interactive user experience. The RadToggleButton raises events when activated and allows pre-click handling through the PreviewClick event. It also provides visual state management to reflect different interaction states like mouse over, pressed, and focused.
Represents a toggle switch button that can display three states: checked, unchecked, and indeterminate. This button extends RadToggleButton and provides properties to customize the content and appearance for each state, including options for setting the width and height of the track and thumb, as well as the corner radius of the track in both checked and unchecked states. It also includes animation capabilities for state transitions.
Represents a customizable toolbar control designed for navigation within an application. The RadToolBar allows the organization of tools and commands in a horizontal or vertical layout, and supports overflow management, enabling items to be dynamically displayed or hidden based on available space. This toolbar can position items into bands, control the visibility of overflow buttons, and manage item alignment. It features an integrated overflow area that opens when there are more items than can be displayed in the main area, and includes events to handle the opening and closing of this overflow area. Additionally, the RadToolBar supports theming and customization, making it adaptable to various user interface styles.
Represents a separator in a toolbar control for organizing and grouping related toolbar items. The RadToolBarSeparator provides a way to visually separate items, enhancing the toolbar's layout and user experience. When placed within a toolbar, it helps delineate different functionalities or groups of commands. This class inherits from the Control class and supports styling and customization while ensuring that the separator is not navigable via keyboard input by default.
A tray where RadToolBar controls are positioned.
Represents a customizable tooltip control that can be attached to other UI elements. The RadToolTip class inherits from ContentControl and provides properties to control the tooltip's appearance and behavior, including its offset, visibility, placement, and the target element it is associated with. The tooltip can dynamically open and close, allowing for interactive user experiences.
Represents a control that can be set as a Content of the RadToolTip. RadToolTipContentView has predefined styles for all Telerik Themes. To enable telerik themes in RadToolTip - just set this control as Content of the RadToolTip.
The RadToolTipService class provides a comprehensive service for managing tooltips in a WPF application. It enables the user to customize tooltip behavior through various properties and events, such as show and hide delays, position offsets, and tooltip content. This service supports the attachment of events for tooltip opening and closing, and facilitates dynamic updates to tooltips as the user interacts with UI elements. Furthermore, it manages the display of tooltips based on user actions (like mouse movement) and conditions, allowing for an enhanced user experience through rich tooltip customization.
Represents a control that provides transition animations for its content using different transition effects and easing functions.
The RadTransitionControl inherits from ContentControl and allows customization of the transition's duration, easing function,
and transition effect. It includes properties to determine if the transition is idle, as well as events to handle transition status changes
and triggering. This control leverages templates for its presentation and can be styled as needed.
A Grid-Like control that can display hierarchies like a TreeView.
The EventArgs for the DragEnded event of the RadTreeView.
The handler for the RadTreeListView's DragEnded event.
Event arguments for the TreeListView Drag related events.
Event Handler for the TreeListView Drag related events.
RadTreeMap displays a hierarchical collection of items. Each item is represented by a rectangle where rectangle's area represents a value extracted from the underlying item. The sum of the values for all child items is equal to the value of the parent item.
A hierarchical control used to display a tree of items.
Arguments for the Check / Uncheck routed events of the RadTreeView.
Holds command used by RadTreeViewItem.
The EventArgs for the DragEnded event of the RadTreeView.
The handler for the TreeView DragEnded event.
Event arguments for the TreeView Drag related events.
Event Handler for the TreeView Drag related events.
Represents an item in the RadTreeView control.
Event args for the Edited event.
Event handler class for the Edited event.
The position of the RadTreeViewItem in its Parent Items collection.
The EventArgs for the ItemPrepared event of the RadTreeView.
RadUpDown exposes two repeat buttons for easily handling the RangeBase value.
The RadVerticalBulletGraph control is a variation of linear gauge. It combines a number of indicators, as well as the data indicator, into one control, which is light weight, easily customizable and straightforward to setup and use. The control is a great tool for dashboards as it is the optimal way to present a lot of information in relatively small size.
Represents a visual vertical axis with ticks and labels.
Represents vertical linear gauge.
Represents a tabular control that dynamically loads data, using a light-weight engine to display and modify it.
Provides commands for RadVirtualGrid.
Represents a virtual keyboard control that allows for customizable keyboard layouts and sound effects for key presses. The RadVirtualKeyboard supports various keyboard layouts, synchronization with system culture settings, and can handle sound playback for key presses.
This control includes properties such as VirtualKeyboardTemplateSelector for customizing key templates, Culture for setting the keyboard's culture-specific language, and IsKeyPressSoundEnabled to enable or disable sound effects when keys are pressed.
The virtual keyboard can load its layout from an XML description, which allows for dynamic key arrangements, and provides methods to reset themes and manage keyboard states (e.g., Caps Lock, Num Lock). Additionally, it implements IDisposable for resource management.
Represents a window that hosts a virtual keyboard, allowing users to input text through a visual keyboard display. This class inherits from RadWindow and is designed to provide a user-friendly interface for inputting text in scenarios where a physical keyboard may not be available. The RadVirtualKeyboard instance is set as the content of the window, facilitating the interaction between the user and the input methods.
Represents a customizable TextBox control that displays watermark text and allows for additional label functionality. The RadWatermarkTextBox includes properties for defining and styling a label, managing the visibility of watermark content based on the focused state, and provides dependency properties for maintaining text, selection behavior, and additional content. It features animations for label transitions and supports themes for visual customization. This control is designed to enhance user experience by providing contextual information and interaction cues when input fields are empty or untitled.
Provides a set of commands for interacting with a watermark text box. This static class defines command implementations that can be executed by UI elements. Currently, it includes a command to clear the text in the watermark text box.
Represents a web cam control that displays the stream provided by a web cam.
Registers in the CommandManager all the commands that RadWebCam exposes.
Sparkline with boolean representation of the data – all the data points are shown with the same magnitude with negative data points extending down from the axis while the positive ones shoot upwards.
Represents an interactive window that provides static methods for displaying standard dialog windows, including Alert, Confirm, and Prompt dialogs. The RadWindow class simplifies the creation and management of modal windows for user notifications and input, allowing developers to easily present messages and gather user responses through a customizable and styled interface.
Represents a singleton manager for handling RadWindows in an application. The RadWindowManager allows for operations on all currently open RadWindows, such as closing, minimizing, maximizing, or restoring them. It maintains a thread-safe collection of all open windows and provides methods to interact with these windows based on their current state.
The RadWizard class provides a user interface control designed to guide users through a structured sequence of steps in a wizard-like fashion. It allows complex processes to be broken down into manageable sections or pages, facilitating smooth navigation and interaction. The class maintains a collection of wizard pages, supports commands for navigating between them, and enables event handling to respond to user actions such as moving to the next or previous page, finishing the wizard, cancelling, or invoking help. This control is beneficial for applications that require users to complete processes that involve multiple steps, ensuring clear guidance and feedback throughout the experience.
Positions child elements in sequential position from left to right, breaking content to the next line at the edge of the containing box. Subsequent ordering happens sequentially from top to bottom or from right to left, depending on the value of the Orientation property.
Provides static commands for controlling the visibility of a RadRadialMenu. This class includes commands for showing and hiding the RadRadialMenu. Each command is represented by a RoutedUICommand and can be used to manage the user interface interactively.
Provides data for the Navigating event.
Exposes methods and properties associated with a range-based UI element for automation interactions.
Represents a control with two Thumbs that can be dragged by the user.
Represents the state of editor controls when parent RadPropertyGrid is ReadOnly.
Contains state information and event data associated with a recording started routed event.
Represents the method that will handle recording started events.
Specifies different modes for appointment occurrences dialog window.
Value converter - converts RecurrenceState.Exception to Visibility.Visible otherwise Visibility.Collapsed.
Value converter - converts RecurrenceState.Occurrence to Visibility.Visible otherwise Visibility.Collapsed.
A control, allowing the end user to resize other controls, which support resizing.
Represents a dynamic data collection of resources that provides notifications when resources get added, removed, or when the whole list is refreshed.
Describes the grouping of items using a ResourceTypes as the criteria.
Provides a way to choose a style for the ResourceGroupHeader based on the data object and the data-bound element.
Represents basic IResourceType implementation.
A class for a typical collection of resource types.
A selector for the data template of resource type.
Represents converter that converts collection of ResourceItem into a formatted string value.
Specifies response buttons in window that will act as default buttons upon keyboard strokes. Used by ResponseButton attached property.
Available Ribbon Routed commands.
Defines the list of variants a group can be.
Defines the list of values a LayoutMode can be.
Provides data for the MouseUp, MouseDown, and MouseMove events for the RadRowItem object.
Defines the placement of row totals.
A base class defining a rule.
A collection of rules deriving from the RuleBase type.
Specifies the name of the category in which to group the property or event in SR.
Specifies a description for a property or event in the SR.
Provides a way to choose a DataTemplate based on the data object and the data-bound element.
Provides the default drag-drop and resize implementation of the RadScheduleView control.
Provides a way to apply styles on elements in ScheduleView based on custom logic.
Represents the content of a ScheduleView dialog.
Provides the base logic for SchedulerDialog ViewModels.
Provides a default implementation of IScheduleDialogHost on RadWindow.
Represents the four edges of a screen.
Shows a screen tip for each of the RibbonView buttons.
ScreenTipState represent different state of the ScreenTip that can be used.
Contains attached behavior for enabling mouse wheel scrolling for ScrollViewer controls.
Represents attached behavior for the scrolling settings of the ScrollingHelper.
Represents a StepTimeSpanComponentBase for picking second TimeSpan intervals.
Specifies the names of the events that will automatically select the text in RadComboBox.
Provides data for a page changed event.
Provides data for a page changing event.
Initializes a new instance of the SelectionChangeEventArgs class.
Initializes a new instance of the SelectionChangingEventArgs class.
Defines which mouse button should be used for selection.
Specifies the selection modification when the control is focus.
Simple structure representing a simple Generic range.
Provides data for the SelectionStartChanged and SelectionEndChanged events.
Use as a separator between items in a RibbonGroup.
Base class for all services that support the RadControl infrastructure.
Contains information about the dialog which is going to be shown.
Determines the mode that will set the Visibility property of the button that shows the currently entered password.
Holds extension methods for PropertyChangedCallback delegate.
A SizeChangedEventManager class.
Helper TabStrip extensions.
Defines the options for barcode rendering.
Represents a control that can be dragged by the user.
Contains state information and event data associated with a snapshot taken routed event.
Represents the method that will handle snapshot taken events.
Defines a method that compares two indexes.
Describes a sorting state.
Provides a way to choose a style for the SpecialSlot based on the data object and the data-bound element.
Specifies the mode of operation for spell checking.
Defines the behavior of a range slider when a Large/Small step is performed.
Represents a base class that inherits TimeSpanComponentBase and populates its ItemsSource collection using the Minimum, Maximum and Step properties.
Represents converter that converts a glyph string value to a glyph number that can be data bound.
Provides functionality for changing control themes.
A rule that returns a Style when satisfied.
SummerTheme class represents the key to the Summer theme.
Represents the SwissQRCode symbology type.
Determines possible positions of the toggle switch button checked and unchecked contents.
Represents the symbol size of the generated barcode.
Provides a base class for all 1-dimensional barcodes.
Base class for defining a symbology type. A symbology defines the format/algorithm used to convert the Value of the Barcode to a visual barcode representation.
Event args wrapping the RadTabItem that has been changed (Closed / Pinned / Unpinned).
Specifies when drop down menu of the RadTabControl should be shown.
Specifies the scroll types that the TabControl supports.
A class representing value property extensions for the TabNavigation of Telerik Input controls.
Represents a base class for rendering tabular data.
Represents a panel that supports the layout of Table components.
Provides data for AutoGeneratingColumn event.
Provides data for the AutoGeneratingItem event.
Represents a column definition for tasks. It is either defined in XAML or autogenerated when GroupMemberPath is used.
This attribute should be used on classes which will be present in the Visual Studio toolbox.
Represents the behavior for the TextBox control in the Telerik UI for WPF library. This class provides functionalities to enhance the text box user experience, including handling input events and managing display logic.
Enables a user to quickly access items in a set by typing prefixes of strings.
Specifies how TextSearch will match items.
This attribute marks Telerik controls that take advantage of the Theme attached property.
Contains the location of the Theme.
This class is used by the design-time and XAML infrastructure to convert theme objects to strings and vice versa.
This enumeration is used to distinguish between built-in and custom themes.
The ThemeLocation attribute decorates a Theme class and carries information about where the theme is hosted. If a theme does not have that attribute, it is treated as an external theme by default.
This class supports the Telerik theming infrastructure and is not intended to be used directly from your code.
Holds infrastructure for the bound resource in different themes.
ThemeResourceKey class is used by the theming mechanism. Every visual control has a control template with different ThemeResourceKey for each theme.
Used to convert ResourceKey types used to consume ThemePalettes.
This class supports the design-time and XAML-related conversion from theme objects to strings and vice versa.
Modifies the passed thickness to thickness where only the required parameters are present. E.g. 2 3 4 5 with parameter LeftTop is returned as 2 3 0 0.
Specifies the threshold.
Represents the type of thumb in a RadWindow control.
Represents the TickBar panel.
Specifies the placement of a TickBar with respect to the track of a RadSlider control.
Specifies the data of a tick.
Specifies the position of tick marks in a RadSlider control with respect to the track in the control.
Provides a way to choose a DataTemplate for the Tick based on the data object and the data-bound element.
The type of the tick.
Visually represents an item in a RadTileList control.
Defines a visual group for tiles placed.
TileGroupContainer is an user interface (UI) element used as a container for a TileGroup.
A panel to be used as ItemsPanel within RadTileList when it is grouped.
A panel to be used as ItemsPanel within RadTileList.
Defines what kind of tile reordering the user may perform.
Enumerable holding the possible triggers that change a tile's state.
Defines what kind of tile should be rendered.
Event arguments for TileView drag-related events.
Event arguments for TileView drag-related events.
Enumerable for item states.
Enumerable for the possible maximize modes of a RadTileView control.
TileViewPanel is used to arrange, realize, virtualize and display.
Event args for the Tiles Animation Complete event.
A base class for RadTimeBar and RadTimeline.
Basic ITimeIndicator implementation - default model for indicators. Can be used to populate the TimeIndicatorsCollection of the RadScheduleView The default TimeIndicatorItemStyleSelector of the RadScheduleView has predefined style for ITimeIndicators.
Represents control that indicates a time in RadScheduleView control.
Provides a way to apply styles on time indicator elements in ScheduleView based on custom logic.
Represents a dynamic data collection of TimeIndicators that provides notifications when indicators get added, removed, or when the whole list is refreshed.
Represents a panel that arranges the time indicators in RadScheduleView control.
Represents basic ITimeMarker implementation.
Represents a dynamic data collection of TimeMarkers that provides notifications when time markers get added, removed, or when the whole list is refreshed.
Provides a way to choose a DataTemplate for the TimeRulerItem based on the data object and the data-bound element.
A ViewModel class for the TimeRuler. Contains properties and methods which define the TimeRuler.
Represents a base class used as DataContext for a RadTimeSpanPickerComponent in the drop down part of the RadTimeSpanPicker.
Represents a collection of TimeSpanComponentBase instances.
Converts a time-span string representation to a TimeSpan object.
Holds TimeSpan extension methods.
Holds commands that can be used by a RadTimeSpanPicker.
Represents a definition of a view that shows customizable number of days as in day view mode.
This class is used to relate a style to a toolbar item's container.
Holds predefined styles for toolbar items' containers.
Determines the gestures on which the ChartToolTipBehavior should show a tool tip.
This class supports the infrastructure of the controls. It has an AnalyticsMonitor property which receives trace events from certain features of the controls.
Container for the setting of the scene during the start of a new Transition.
TransparentTheme class represents the key to the Transparent theme.
The visual object used as a DragCue in RadTreeListView.
Defines the position where the item will be dropped.
A table definition which specifies the hierarchy in the RadTreeListView.
Represents a relation used in a tree list. The data source is generated using the ItemSource binding of the parent TreeListViewTableDefinition.
A banner used for displaying licensing information. This class is used internally by the Telerik UI for WPF suite and is not intended to be used directly in your code.
Contains helper extension methods for the UIElement class.
Represents the UPCA symbology type.
Represents the UPCE symbology type.
Represents the UPCSupplement2 symbology type.
Represents the UPCSupplement5 symbology type.
Specifies when the Value property will be changed.
Represents the converter that converts strings to uppercase.
Represents converter, which converts string value to Uppercase.
Specifies the state of the machine for the current user in relation to the propriety of sending a notification.
Defines constants that specify the type of ValidationErrorTemplate.
This class represents a helper which allows different ways for the Validation.ErrorTemplate to be shown.
UpDownMode determines the format of the value.
Serves as a base class for all view definitions. Contains common properties for all views.
Represents a collection of ViewDefinitionBase instances.
Provides a way to choose a DataTemplate for the ViewMode based on the data object and the data-bound element.
Base class for all ViewModel classes. It provides support for property change notifications and has a DisplayName property. This class is abstract.
Allows to control Clipboard operations on a per-cell basis.
Represents event arguments for the CellToolTipNeeded event.
Allows to control RadVirtualGrid Clipboard operations.
Selects a DataTemplate for a key using default logic.
Positions child elements in sequential position from left to right, breaking content to the next line at the edge of the containing box. Subsequent ordering happens sequentially from top to bottom or from right to left, depending on the value of the Orientation property.
Provides data for an event raised when the visibility of the element has changed.
Represents the converter that converts Visibility enumeration values to and from Boolean values.
Represents a visibility to thickness converter.
VistaTheme class represents the key to the Vista theme.
Hold resources used in the VisualStudio2013Theme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the VisualStudio2013Palette.
A that allows access to the VisualStudio2013Palette resources from XAML.
Keys for the VisualStudio2013Palette resources.
Used to convert ResourceKey types used in VisualStudio2013ResourceKey.
VisualStudio2013Theme class represents the key to the VisualStudio2013Theme theme.
Hold resources used in the VisualStudio2019Theme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the VisualStudio2019Palette.
A that allows access to the VisualStudio2019Palette resources from XAML.
Keys for the VisualStudio2019Palette resources.
Used to convert ResourceKey types used in VisualStudio2019ResourceKey.
VisualStudio2019Theme class represents the key to the VisualStudio2019 theme.
Represents converter, which converts Visual value to VisualBrush and sets the value as Visual of the brush.
Specifies when the watermark content of RadWatermarkTextBox will be hidden.
Represents a definition of a view that shows all seven week days as in day view mode.
Represents a single welcome page.
Base class for creating a custom Window.
WindowClosedEventArgs exposes DialogResult and PromptResult property for handling the closed event of a window.
Holds commands that can be used by a window.
Represents the panel used in the header of RadWindow. It provides options to align the buttons or left or right and center or not the title of the window. The panel should contain only two containers one for the title and one for the buttons. The containers should be marked with the attached ContainerType property, if two or more are marked as Buttons (for example) only the last one will be considered in the layout logic. Any other elements placed inside of the panel will be ignored when measuring and arranging the layout of the panel.
Defines the different types of the elements inside of the WindowHeaderPanel.
Represents a host control for windows in the Telerik framework.
Provides methods for interoperation with the native windowing system.
WindowClosingEventArgs exposes DialogResult and PromptResult property for handling the closing event of a window.
Hold resources used in the Windows11Theme theme.
Represents theme color variations.
A ResourceDictionary that merges the resources from the Windows11Palette.
A that allows access to the Windows11Palette resources from XAML.
Keys for the Windows11Palette resources.
Used to convert ResourceKey types used in Windows11ResourceKey.
Windows11Theme class represents the key to the Windows11Theme theme.
Allows for switching between the normal and compact mode of the Windows11Theme theme.
Windows7Theme class represents the key to the Windows7 theme.
Enumerates all colors available in the Windows8ColorPalette.
Keeps the colors used to colorize the Windows8Theme.
Hold resources used in the Windows8Theme theme.
A ResourceDictionary that merges the resources from the Windows8Palette.
A that allows access to the Windows8Palette resources from XAML.
Keys for the Windows8Palette resources.
Used to convert ResourceKey types used in Windows8ResourceKey.
Windows8Theme class represents the key to the Windows8 theme.
Provides XAML access to the Windows8TouchPalette Palette singleton through the Windows8TouchColors Palette property.
Hold resources used in the Windows8TouchTheme theme.
A ResourceDictionary that merges the resources from the Windows8TouchPalette.
A that allows access to the Windows8TouchPalette resources from XAML.
Keys for the Windows8TouchPalette resources.
Used to convert ResourceKey types used in Windows8TouchResourceKey.
Windows8TouchTheme class represents the key to the Windows8Touch theme.
Represents a single wizard's page.