RadControl
Serves as the foundational base class for all Telerik WinControls, bridging the Windows Forms framework with the Telerik Presentation Framework (TPF) element-based architecture.
RadControl acts as the host and coordinator for the entire RadElement tree that defines a control's structure and behavior. It inherits from ScrollableControl for full Windows Forms compatibility while managing the sophisticated TPF element hierarchy through its RootElement.
As an IComponentTreeHandler, RadControl manages hosted controls, coordinates focus and DPI scaling, and translates Windows Forms messages into TPF element events. It implements INotifyPropertyChanged to ensure property changes are communicated to data binding systems.
All RadControls participate in the unified theming system, automatically applying themes to their element trees and responding to runtime theme changes. The control includes comprehensive design-time support for Visual Studio integration and serves as the foundation for RadButton, RadTextBox, RadGridView, and all other Telerik controls.
Definition
Namespace:Telerik.WinControls
Assembly:Telerik.WinControls.dll
Syntax:
public class RadControl : ScrollableControl, IDropTarget, ISynchronizeInvoke, IWin32Window, IBindableComponent, IComponent, IDisposable, INotifyPropertyChanged, ISupportInitializeNotification, ISupportInitialize, IComponentTreeHandler, ILayoutHandler, IAnalyticsProvider
Inheritance: objectMarshalByRefObjectComponentControlScrollableControlRadControl...
Derived Classes:
Implements:
Constructors
Fields
Stores the union of element invalidation bounds accumulated during a resize/layout calculation.
protected Rectangle invalidResizeRect
protected bool isAccessibilityRequested
Indicates that base control disposal has completed and RadControl cleanup is underway.
protected bool isDisposing2
Marks a resize pass so invalidations are accumulated and the subsequent OnLayout(LayoutEventArgs) pass skips its additional root update.
protected bool isResizing2
Properties
Indicates focus cues display, when available, based on the corresponding control type and the current UI state.
[Browsable(true)]
public virtual bool AllowShowFocusCues { get; set; }
Gets or sets the Analytics Name associated with this control. By default the Control Name property is logged. If you want to customize the information which will be logged for this control set this property to a preferred value.
[Browsable(false)]
public virtual string AnalyticsName { get; set; }
Implements:
Gets or sets a value indicating whether the control is automatically resized to display its entire contents.
[Browsable(true)]
public override bool AutoSize { get; set; }
Overrides:
Gets or sets the BackColor of the control. This is actually the BackColor property of the root element.
public override Color BackColor { get; set; }
Overrides:
Gets the input behavior for the control.
[Browsable(false)]
public ComponentInputBehavior Behavior { get; }
Gets or sets a value indicating whether the control causes validation to be performed on any controls that require validation when it receives focus.
public bool CausesValidation { get; set; }
Gets the live input-binding collection used by this control's shortcut manager.
[TypeConverter(typeof(ExpandableObjectConverter))]
public InputBindingsCollection CommandBindings { get; }
Add or remove bindings through this collection to configure keyboard commands for the control.
Gets the themable component tree that owns the control's root element and applies its theme.
[Browsable(false)]
public virtual ComponentThemableElementTree ElementTree { get; }
Gets or sets a value indicating whether the Analytics functionality is enabled or disabled for this control.
[Browsable(true)]
public virtual bool EnableAnalytics { get; set; }
Implements:
Gets or sets a value indicating whether the CodedUI Tests functionality is enabled.
[Browsable(true)]
public virtual bool EnableCodedUITests { get; set; }
Gets or sets the default value for EnableCodedUITests property.
[Browsable(true)]
public static bool EnableCodedUITestsDefaultValue { get; set; }
Gets or sets a value indicating whether the RadControls scaling logic will be used when the application is run in a high DPI environment.
public static bool EnableDpiScaling { get; set; }
Gets or sets a value indicating whether the RadControls scaling logic will be used to resize the images when the application is run in a high DPI environment.
public static bool EnableImageDpiScaling { get; set; }
Gets or sets whether Key Map (Office 2007 like accelerator keys map) is used for this specific control. Currently this option is implemented for the RadRibbonBar control only.
[Browsable(true)]
public virtual bool EnableKeyMap { get; set; }
Gets or sets a value indicating whether the RadControls Accessible custom object is enabled.
[Browsable(false)]
public virtual bool EnableRadAccessibilityObjects { get; set; }
Gets or sets a value that indicates whether to use the new auto-scaling mechanism or not. Enabled by default.
public static bool EnableRadAutoScale { get; set; }
Do not modify. For internal use only.
public static bool EnableRadFormInitialDpiScaling { get; set; }
Gets or sets a value indicating whether the RadControls will draw use the SvgImages in ImagePrimitive and LightVisualElement objects, or if [false] will draw the corresponding Image property if applicable.
public static bool EnableSvgImages { get; set; }
Gets or sets value indicating whether the control is styled through theme
public bool EnableTheming { get; set; }
Gets or sets a value indicating whether the UI Automation functionality is enabled.
[Browsable(true)]
public virtual bool EnableUIAutomation { get; set; }
Gets or sets the default value for EnableUIAutomation property.
[Browsable(true)]
public static bool EnableUIAutomationDefaultValue { get; set; }
Gets or sets whether the control may receive focus on behalf of an element-level focus request.
public virtual bool Focusable { get; set; }
Gets or sets the element tracked as focused by this control's element-tree behavior.
[Browsable(false)]
public RadElement FocusedElement { get; set; }
Setting a non-null element requests focus for it; setting null clears the currently focused element.
Gets or sets the Font of the control. This is actually the Font property of the root element.
public override Font Font { get; set; }
Overrides:
Gets or sets the ForeColor of the control. This is actually the ForeColor property of the root element.
public override Color ForeColor { get; set; }
Overrides:
Gets or sets the ImageList that contains the images displayed by this control.
[Browsable(true)]
public virtual ImageList ImageList { get; set; }
Implements:
Gets or sets the image scaling size.
[Browsable(false)]
public Size ImageScalingSize { get; set; }
Implements:
Gets whether WinForms reports this control as being in design mode.
[Browsable(false)]
public bool IsDesignMode { get; }
Determines whether the control is currently displayed on the screen.
[Browsable(false)]
public bool IsDisplayed { get; }
Determines whether the control is properly loaded.
[Browsable(false)]
public bool IsLoaded { get; }
Gets or sets the size that is the upper limit that GetPreferredSize can specify.
public override Size MaximumSize { get; set; }
Overrides:
Gets or sets the size that is the lower limit that GetPreferredSize can specify
public override Size MinimumSize { get; set; }
Overrides:
Gets or sets padding within the control.
public Padding Padding { get; set; }
A Padding representing the control's internal spacing characteristics.
Gets the RootElement of the control.
[Browsable(true)]
[TypeConverter(typeof(ExpandableObjectConverter))]
public RootRadElement RootElement { get; }
Implements:
Gets or sets a value indicating whether ToolTips are shown for the RadItem objects contained in the RadControl.
public virtual bool ShowItemToolTips { get; set; }
Gets or sets the design-time site assigned to this control.
public override ISite Site { get; set; }
Overrides:
Setting the site also updates the root element's design-mode state from DesignMode.
Gets or sets the SmallImageList that contains the small images which are displayed when there's not enough space.
[Browsable(true)]
public virtual ImageList SmallImageList { get; set; }
Implements:
Gets or sets the small image scaling size.
[Browsable(false)]
public Size SmallImageScalingSize { get; set; }
Implements:
[Browsable(true)]
[Bindable(true)]
[SettingsBindable(true)]
public override string Text { get; set; }
Overrides:
Gets or sets the class name string that ThemeResolutionService will use to find the themes registered for the control.
public virtual string ThemeClassName { get; set; }
By default the return value is RadControl's type FullName; Some controls like drop down menu has different ThemeClassName depending on the runtime usage of the control.
Gets or sets control's preferred theme name. Themes are stored and retrieved using APIs of ThemeResolutionService.
[Browsable(true)]
public virtual string ThemeName { get; set; }
Implements:
If ThemeResolutionService.ApplicatonThemeName refers to a non-empty string, the theme of a RadControl can differ from the one set using RadControls.ThemeName property. If the themes differ, the RadControls.ThemeName property will be overridden by ThemeResolutionService.ApplicatonThemeName. If no theme is registered with a name as ThemeResolutionService.ApplicatonThemeName, then control will revert to the theme specified by its ThemeName property. If ThemeName is assigned to a non-existing theme name, the control may have no visual properties assigned, which will cause it look and behave in unexpected manner. If ThemeName equals empty string, control's theme is set to a theme that is registered within ThemeResolutionService with the name "ControlDefault".
Determines whether to use compatible text rendering engine (GDI+) or not (GDI).
public virtual bool UseCompatibleTextRendering { get; set; }
Set or get the default value for UseCompatibleTextRendering property.
public static bool UseCompatibleTextRenderingDefaultValue { get; set; }
Gets whether WinForms canceled validation for this control.
protected bool ValidationCancel { get; }
When validation is canceled during a qualifying mouse-button press or double-click and CausesValidation is enabled, the window procedure dispatches the message through
DefWndProcand returns. After base message processing, a canceled state also causes a capture-release request when this control still holds capture.
Methods
Suspends layout during initialization.
public virtual void BeginInit()
Implements:
Determines whether an element may be edited via the EditUIElements dialog at design-time.
protected virtual bool CanEditElementAtDesignTime(RadElement element)
Creates the control's layout manager, input behavior, and element tree.
protected virtual void Construct()
Called during base-class construction. Overrides must call
base.Construct()to initialize this infrastructure.
Creates the input behavior instance. Allows inheritors to provide custom input implementations.
Creates the control's child elements under the specified parent.
protected virtual void CreateChildItems(RadElement parent)
The element that will contain the child elements.
The base implementation sets the root element's name to the control's name.
Creates the root element that hosts the control's element hierarchy.
protected virtual RootRadElement CreateRootElement()
The root element to use for this control.
Disable firing gesture events of the specified type.
public void DisableGesture(GestureType type)
The type of gesture events to disable.
Releases control resources and tears down the element tree and related services.
protected override void Dispose(bool disposing)
Whether managed resources should be released.
Overrides:
Calls the base implementation before disposing the element tree so the designer can serialize the control's properties. Managed cleanup also unregisters key-tip handling and disposes the layout manager, region, and input behavior.
Enable firing gesture events of the specified type.
public void EnableGesture(GestureType type)
The type of gesture events to enable.
Resumes layout.
public virtual void EndInit()
Implements:
Reads a public property from an accessible child control or item in response to a Coded UI request.
protected virtual bool FindPropertyInChildren(RadControl radControl, IPCMessage request)
The control whose accessible children are searched.
requestIPCMessageThe request; Data identifies the child by its accessible name and Message names the property to read.
true if a matching child property is found and its value is stored in request.Data;
otherwise, false.
Gets the element whose input-key classification is consulted before the control's base implementation.
protected virtual RadElement GetInputElement()
The currently focused element, or another element supplied by an override.
Gets the DPI scale factor for the monitor where the specified control is currently displayed.
protected virtual SizeF GetMonitorDpiScaleFactor(Control control)
The control used to determine which monitor to query for DPI information.
Returns:A SizeF representing the DPI scale factor where both Width and Height contain the same scaling value (e.g., 1.25 for 125% scaling, 1.5 for 150% scaling).
This method is used by the RadAutoScale system to determine the target DPI scaling that should be applied to the control. It queries the Windows DPI awareness system to get the effective DPI for the window handle and converts it to a scale factor relative to the standard 96 DPI.
The method is virtual to allow derived controls to customize DPI detection behavior if needed, such as for specialized hosting scenarios or custom DPI handling requirements.
This method requires Windows 10 Anniversary Update (1607) or later for per-monitor DPI awareness support. On earlier versions, the system falls back to other DPI detection methods.
Strips all html tags of the text set to the control and returns only the plain text.
Gets the preferred size, recalculating it from the element tree when its measurement is stale or the tree contains stretchable elements.
Performs inner layout for the requested bounds and returns the element tree's desired size.
Provides an initialization hook for the newly created root element.
protected virtual void InitializeRootElement(RootRadElement rootElement)
The root element to configure.
This hook runs before the root is attached to the element tree; its stretch settings are saved as defaults immediately afterward, before child elements are created.
Queues a layout callback on the control's UI thread.
public void InvokeLayoutCallback(LayoutCallback callback)
The callback to run with this control's layout manager.
Implements:
The callback is not scheduled unless the control has a handle and is not disposing or disposed.
Lets the focused element classify an input key before using the base control's classification.
Loads the element tree. While not loaded, no layout operations are allowed upon the tree. By default, the tree will be loaded when the control is displayed for the first time.
public virtual void LoadElementTree()
Implements:
Loads the element tree using the specified desired size.
Invalidates the cached preferred size and notifies the element tree when auto-size changes.
Resets the root element's inherited background color so it picks up the control's updated color.
Copies the control's current binding context to its root element.
Called when the control receives a capture-change message before it is passed to the base window procedure.
protected virtual void OnCaptureLosing()
The base implementation does nothing; override this method to respond to capture loss.
Gives the element-tree behavior first chance to handle the click before standard control processing.
protected override void OnClick(EventArgs e)
The click event data.
Overrides:
Loads the element tree with the control's current size after the WinForms control is created.
protected override void OnCreateControl()
Overrides:
Gives the element-tree behavior first chance to handle the double-click before standard control processing.
protected override void OnDoubleClick(EventArgs e)
The double-click event data.
Overrides:
Synchronizes the root element's enabled state, updating it before the event when enabling and after when disabling.
Resets the root element's inherited font value so it picks up the control's updated font.
Resets the root element's inherited foreground color so it picks up the control's updated color.
Forwards the gesture to element behavior and raises the event associated with its gesture type.
protected virtual void OnGesture(GestureEventArgs args)
The gesture data, including its type, location, and handled state.
An unhandled pan gesture is translated into mouse down, move, or up input according to its begin/end state.
Lets the element-tree behavior restore its previously focused element before standard focus processing.
protected override void OnGotFocus(EventArgs e)
The focus event data.
Overrides:
Unloads the element tree unless its disposal flag is set or the handle is being recreated.
Raises ElementInvalidated with the invalidated element as the event sender.
protected virtual void OnInvalidated(RadElement element)
The element whose bounds need to be repainted.
Gives the element-tree behavior first chance to handle key-down before standard control processing.
protected override void OnKeyDown(KeyEventArgs e)
The key-down event data.
Overrides:
Gives the element-tree behavior first chance to handle key-press input before standard control processing.
protected override void OnKeyPress(KeyPressEventArgs e)
The key-press event data.
Overrides:
Gives the element-tree behavior first chance to handle key-up before standard control processing.
protected override void OnKeyUp(KeyEventArgs e)
The key-up event data.
Overrides:
Outside design mode, remeasures and updates the root element when the control is loaded, not disposing or resizing, the layout manager is idle, and the root layout is not suspended.
Notifies that the control is about to be visualized.
Synchronizes the root element's location with the control after the element tree has loaded.
Lets the element-tree behavior preserve its focused element before standard focus-loss processing.
protected override void OnLostFocus(EventArgs e)
The focus event data.
Overrides:
Forwards the control's capture-changed notification to the element-tree behavior.
protected override void OnMouseCaptureChanged(EventArgs e)
The mouse-capture event data.
Overrides:
Gives the element-tree behavior first chance to handle mouse-down before standard control processing.
protected override void OnMouseDown(MouseEventArgs e)
The mouse-down event data.
Overrides:
Gives the element-tree behavior first chance to handle mouse-enter before standard control processing.
protected override void OnMouseEnter(EventArgs e)
The mouse-enter event data.
Overrides:
Gives the element-tree behavior first chance to handle mouse-hover before standard control processing.
protected override void OnMouseHover(EventArgs e)
The mouse-hover event data.
Overrides:
Gives the element-tree behavior first chance to handle mouse-leave before standard control processing.
protected override void OnMouseLeave(EventArgs e)
The mouse-leave event data.
Overrides:
Gives the element-tree behavior first chance to handle mouse-move before standard control processing.
protected override void OnMouseMove(MouseEventArgs e)
The mouse-move event data.
Overrides:
Gives the element-tree behavior first chance to handle mouse-up before standard control processing.
protected override void OnMouseUp(MouseEventArgs e)
The mouse-up event data.
Overrides:
Gives the element-tree behavior first chance to handle mouse-wheel input before standard control processing.
protected override void OnMouseWheel(MouseEventArgs e)
The mouse-wheel event data.
Overrides:
Raises PropertyChanged with the supplied change data.
protected virtual void OnNotifyPropertyChanged(PropertyChangedEventArgs e)
The property-change event data to pass to subscribers.
Raises the PropertyChanged event
protected virtual void OnNotifyPropertyChanged(string propertyName)
The name of the property
Converts the control's padding to the root element's DPI-unscaled coordinates and applies it to the root and its first child.
Paints the root element in the clip rectangle before raising the control's standard paint event.
Fires the PanGesture event.
protected virtual void OnPanGesture(PanGestureEventArgs args)
The arguments for the PanGesture event.
Refreshes inherited root-element colors and font, then attempts Telerik auto-scaling after the parent changes.
Fires the PressAndTapGesture event.
protected virtual void OnPressAndTapGesture(PressAndTapGestureEventArgs args)
The arguments for the PressAndTapGesture event.
Gives the element-tree behavior first chance to classify a key before standard preview-key processing.
protected override void OnPreviewKeyDown(PreviewKeyDownEventArgs e)
The preview-key event data.
Overrides:
Recomputes the root element's effective right-to-left setting after the control's setting changes.
Fires the RotateGesture event.
protected virtual void OnRotateGesture(RotateGestureEventArgs args)
The arguments for the RotateGesture event.
Raises the screen-tip event so handlers can adjust the display delay and offset.
protected virtual void OnScreenTipNeeded(object sender, ScreenTipNeededEventArgs e)
The component behavior requesting screen-tip data.
eScreenTipNeededEventArgsThe screen-tip target, display delay, and offset.
Reapplies background and foreground theme overrides for colors that are explicitly set on the control.
protected virtual void OnThemeChanged()
Raises ThemeNameChanged when the element tree's theme name changes.
protected virtual void OnThemeNameChanged(ThemeNameChangedEventArgs e)
The previous and current theme names.
Raises the tooltip-text event so handlers can adjust the text and cursor offset before display.
protected virtual void OnToolTipTextNeeded(object sender, ToolTipTextNeededEventArgs e)
The element requesting tooltip text.
eToolTipTextNeededEventArgsThe current tooltip text and cursor offset, which handlers can modify.
Fires the TwoFingerTapGesture event.
protected virtual void OnTwoFingerTapGesture(GestureEventArgs args)
The arguments for the TwoFingerTapGesture event.
Attempts Telerik auto-scaling and repaints the root-element shadow after visibility changes.
Fires the ZoomGesture event.
protected virtual void OnZoomGesture(ZoomGestureEventArgs args)
The arguments for the ZoomGesture event.
Performs auto scaling of the control.
protected virtual void PerformRadAutoScale(BoundsSpecified? specified = null)
Updates the root element's default stretch modes when the control's AutoSize value changes.
Processes a capture request from the specified element.
protected virtual bool ProcessCaptureChangeRequested(RadElement element, bool capture)
The element which requested the capture.
captureboolReturns:True if the capture request is approved, otherwise false.
Processes supported Coded UI property requests for this control and its accessible children.
protected virtual void ProcessCodedUIMessage(ref IPCMessage request)
The property request. Message names the property; Data supplies a set value or, for a get, may identify a child before receiving the result.
The base implementation uses public properties on the control or accessible child; it does not handle
ExecuteMethodrequests.
Processes a focus request from the specified element.
protected virtual bool ProcessFocusRequested(RadElement element)
The element that requested the focus.
Returns:True if focus is approved, false otherwise.
Reads gesture data from a window message and dispatches supported gestures through OnGesture(GestureEventArgs).
protected bool ProcessGesture(Message m)
The window message containing gesture information.
Returns:true when the message is consumed; false when gestures are unavailable or disabled, gesture information cannot be read, or the message is a gesture-sequence begin/end marker.
Other unrecognized gesture identifiers are consumed without raising a gesture event.
Processes a mnemonic through the element-tree behavior when mnemonic processing is allowed and the control or one of its elements has focus.
Refreshes the control unless an update suspension is active.
public override void Refresh()
Overrides:
Adds the WinForms control hosted by a RadHostItem to this control's child controls.
public virtual void RegisterHostedControl(RadHostItem hostElement)
The element whose hosted control should be added.
Implements:
A null element or one whose hosted control is already parented to this control is ignored. Layout is suspended during the addition; the host element is responsible for positioning its hosted control.
Reset the property to its default value.
protected virtual void ResetProperty(RadProperty property, RadObject element)
The RadProperty to be reset.
elementRadObjectThe RadObject owner of the property.
Replaces the default style group for specific element.
public virtual StyleGroup ResolveStyleGroupForElement(StyleGroup styleGroup, RadObject element)
The style group to replace.
elementRadObjectThe element on which this style should apply.
Returns:An instance of StyleGroup is successfull.
Ends one update suspension and invalidates the control and its child controls when the outermost suspension ends.
public void ResumeUpdate()
Implements:
Ends one update suspension and optionally invalidates the control when the outermost suspension ends.
Applies Telerik auto-scaling when enabled; otherwise scales the root element for size changes and delegates to WinForms.
protected override void ScaleControl(SizeF factor, BoundsSpecified specified)
The horizontal and vertical scale factors.
specifiedBoundsSpecifiedThe bounds components to scale.
Overrides:
Outside Telerik auto-scaling, an unchanged factor or disabled DPI scaling returns without calling the base implementation. When Telerik auto-scaling is enabled, this method delegates to that path, which may re-enter with a calculated factor. During WinForms scaling, bottom and right anchors are temporarily cleared and then restored.
Lets derived controls propagate an explicit BackColor to theme values for their child elements.
protected virtual void SetBackColorThemeOverrides()
Called after a non-empty color is assigned and again after a theme change while the color remains explicit.
Applies the requested bounds, using the element tree's desired size for a loaded control whose bounds are changing.
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
The requested left coordinate.
yintThe requested top coordinate.
widthintThe requested width.
heightintThe requested height.
specifiedBoundsSpecifiedThe bounds components to apply.
Overrides:
Lets derived controls propagate an explicit ForeColor to theme values for their child elements.
protected virtual void SetForeColorThemeOverrides()
Called after a non-empty color is assigned and again after a theme change while the color remains explicit.
Enables/disables RadAutoScale. If you want to disable RadAutoScale for this control, call this method immediately after creating the control.
Determines whether the specified RadProperty should be serialized. Prevents theme and default values serialization.
protected virtual bool ShouldSerializeProperty(RadProperty property, RadObject element)
The RadProperty that is about to be serialized.
elementRadObjectThe element that owns the property.
Returns:A value indicating whether to serialize the property value.
Determines whether the specified RadProperty should be serialized.
protected virtual bool ShouldSerializeProperty(RadProperty property)
The RadProperty that is about to be serialized.
Returns:A value indicating whether to serialize the property value.
Suspends automatic invalidation and refresh work for this control's element tree.
public void SuspendUpdate()
Implements:
Suspensions are nested; pair each call with ResumeUpdate(). This does not suspend layout; it suppresses element invalidation and Refresh() calls.
Updates the parent-layout state for a hosted control and optionally removes it from this control.
public virtual void UnregisterHostedControl(RadHostItem hostElement, bool removeControl)
The element whose hosted control is being unregistered.
removeControlbooltrue to remove the hosted control from this control when it is currently parented here; false to leave it in the child-controls collection.
Implements:
If the hosted control is parented here and the element tree's layout is suspended, its layout is resumed regardless of whether it is removed. This control's layout is suspended during the operation and resumed without forcing a layout pass.
Processes window messages, routing Telerik-specific input and IPC handling before delegating unhandled messages.
protected override void WndProc(ref Message m)
The window message to process.
Overrides:
This path includes gesture dispatch and validation-aware focus handling. Messages not consumed by a Telerik-specific path are passed to the base window procedure.
Events
Occurs when an element requests invalidation while the control is visible and updates are not suspended; bounds-specific requests are also suppressed during painting.
public event EventHandler ElementInvalidated
Handlers receive the invalidated RadElement as
sender; the event arguments are null.
Fires when the control is initialized.
public event EventHandler Initialized
Implements:
Occurs when a pan gesture was sent by a touch input device.
[Browsable(true)]
public event PanGestureEventHandler PanGesture
Occurs when a press-and-tap gesture was sent by a touch input device.
[Browsable(true)]
public event PressAndTapGestureEventHandler PressAndTapGesture
Occurs when a property of an object changes change. Calling the event is developer's responsibility.
[Browsable(false)]
public event PropertyChangedEventHandler PropertyChanged
Implements:
Occurs when a rotate gesture was sent by a touch input device.
[Browsable(true)]
public event RotateGestureEventHandler RotateGesture
Occurs prior the ScreenTip of a RadItem instance inside the RadControl is displayed.
public virtual event ScreenTipNeededEventHandler ScreenTipNeeded
Fires when the theme name is changed.
public event ThemeNameChangedEventHandler ThemeNameChanged
Implements:
Occurs when a RadItem instance inside the RadControl requires ToolTip text.
public virtual event ToolTipTextNeededEventHandler ToolTipTextNeeded
Implements:
Occurs when a two-finger-tap gesture was sent by a touch input device.
[Browsable(true)]
public event GestureEventHandler TwoFingerTapGesture
Occurs when a zoom gesture was sent by a touch input device.
[Browsable(true)]
public event ZoomGestureEventHandler ZoomGesture