DoMouseWheelLeft is a Boolean function used to perform actions when a horizontal mouse wheel movement towards the left has occurred in the control. It is called, via DoMouseWheelHorz, when a LM_MOUSEHWHEEL message is received and handled in the WMMouseHWheel method.

DoMouseWheelLeft signals the OnMouseWheelLeft event handler when it has been assigned in the control. Shift and MousePos contain the shift modifier and the coordinates where the mouse event occurred. They are passed as arguments to the event handler.

The return value indicates whether the event handler accepted and processed the mouse wheel event at the specified position. The default value is False, but it can be updated in the handler routine. The return value is False if OnMouseWheelLeft has not been assigned.

DoMouseWheelRight is a Boolean function used to perform actions when a horizontal mouse wheel movement towards the right has occurred in the control. It is called, via DoMouseWheelHorz, when a LM_MOUSEHWHEEL message is received and handled in the WMMouseHWheel method.

DoMouseWheelRight signals the OnMouseWheelRight event handler when it has been assigned in the control. Shift and MousePos contain the shift modifier and the coordinates where the mouse event occurred. They are passed as arguments to the event handler.

The return value indicates whether the event handler accepted and processed the mouse wheel event at the specified position. The default value is False, but it can be updated in the handler routine. The return value is False if OnMouseWheelRight has not been assigned.

VisibleChanging is called when a new value is assigned to the Visible property. It occurs before the new property value is stored to its member in the class instance. It allows all of the TNotifyEvent routines registered for the chtOnVisibleChanging control handler type to be signalled prior to the change in the property value.

VisibleChanging calls the DoCallNotifyHandler method to signal each of the handler routines using the chtOnVisibleChanging control handler type. The class instance is used as the Sender argument for the event notification.

Use AddHandlerOnVisibleChanging and RemoveHandlerOnVisibleChanging to manage the TNotifyEvent handler routines for the chtOnVisibleChanging handler type used in the control.

See VisibleChanged for the actions performed after the value in Visible has been updated.

VisibleChanged is called when a new value has been assigned to the Visible property. It occurs after the new property value is stored to its member in the class instance. It allows all of the TNotifyEvent routines registered for the chtOnVisibleChanged control handler type to be signalled for the new property value.

VisibleChanged calls the DoCallNotifyHandler method to signal each of the handler routines using the chtOnVisibleChanged control handler type. The class instance is used as the Sender argument for the event notification.

Use AddHandlerOnVisibleChanged and RemoveHandlerOnVisibleChanged to manage the TNotifyEvent handler routines for the chtOnVisibleChanged handler type used in the control.

See VisibleChanging for the actions performed before the value in Visible is updated.

EnabledChanging is called when a new value has been assigned to the Enabled property. It occurs after the new property value is stored to its member, and before a CM_ENABLEDCHANGED control message is posted for the control. It allows all of the TNotifyEvent routines registered for the chtOnEnabledChanging control handler type to be signalled for the new property value.

EnabledChanging calls the DoCallNotifyHandler method to signal each of the handler routines using the chtOnEnabledChanging control handler type. The class instance is used as the Sender argument for the event notification.

Use RemoveHandlerOnEnabledChanging to manage the TNotifyEvent handler routines for the handler type used in the control. AddHandler and RemoveHandler can be used if the control handler type is passed as an argument.

See EnabledChanged for the actions performed after the value in Enabled is updated.

EnabledChanged is called when a new value has been assigned to the Enabled property. It occurs after the EnabledChanging method has been called, and the CM_ENABLEDCHANGED control message has been sent for the control. It allows all of the TNotifyEvent routines registered for the chtOnEnabledChanged control handler type to be signalled for the new property value.

EnabledChanged calls the DoCallNotifyHandler method to signal each of the handler routines using the chtOnEnabledChanged control handler type. The class instance is used as the Sender argument for the event notification.

Use AddHandlerOnEnabledChanged and RemoveHandlerOnEnabledChanged to manage the TNotifyEvent handler routines for the handler type used in the control. AddHandler and RemoveHandler can be used if the control handler type is passed as an argument.

See EnabledChanging for the actions performed before the value in Enabled is updated in its widgetset class instance.

AddHandler is a method used to include the handler routine specified in AMethod in the list of notification handlers for the type in HandlerType.

HandlerType is a TControlHandlerType enumeration value, and indicates both the subject for the notification and the method list where the handler routine is stored.

AMethod is the TMethod instance with the handler routine signalled when a notification is needed. It is an object procedure which implements the TNotifyEvent signature and cast to the TMethod type.

AddHandler ensures that a TMethodList instance has been allocated for handler routines using the specified type; if it does not exist, it is created and stored in the internal array of handler types.

AddHandler calls the Add method in the method list to store the routine in AMethod.

AsFirst indicates whether the routine is inserted as the first item in the list. When set to False, the routine is appended as the last entry in the method list.

Use RemoveHandler to remove a handler routine from the method list for a specific handler type.

Convenience methods which act upon a specific control handler type using TNotifyEvent arguments are also available. For example:

• AddHandlerOnResize
• AddHandlerOnChangeBounds
• AddHandlerOnVisibleChanged
• and others

RemoveHandler is a method used to remove the specified handler routine from the method list for a given control handler type. It removes an entry in the method list created using the AddHandler method.

HandlerType is a value from the TControlHandlerType enumeration that identifies the method list updated in the method. It is an index into the internal array of TMethodList instances used to store handler routines.

AMethod is the TMethod instance to locate and remove from the method list for the handler type. It is a reference to a TNotifyEvent implementation cast to the TMethod type used in the method list.

RemoveHandler calls the Remove method in the TMethodList instance using AMethod as an argument.

Convenience methods are provided that manage a method list for a single control type handler. For example:

• RemoveHandlerOnResize
• RemoveHandlerOnChangeBounds
• RemoveHandlerOnVisibleChanging
• and others

DoCallNotifyHandler is a method used to signal control handler routines which were added for the specified HandlerType.

HandlerType is a value form the TControlHandlerType enumeration which identifies the list with the routines signalled in the method.

A control handler routine is a reference to a TNotifyEvent implementation. In TControl, multiple handler routines can be added for a given handler type. DoCallNotifyHandler ensures that each of the routines is signalled using the control instance as the Sender or origin for the notification.

DoCallNotifyHandler uses the value in HandlerType to select the TMethodList with the handler routines. The CallNotifyEvents method in the TMethodList instance is called to perform the event notification.

DoCallNotifyHandler is called from methods which perform event notifications using both a published event handler property and a list of control handlers. For example: DoOnResize and DoOnChangeBounds. These methods signal the event handlers represented by the OnResize and OnChangeBounds properties. They also use DoCallNotifyHandler for their control handler types (chtOnResize and chtOnChangeBounds) to signal the additional handlers added to the control.

DoCallNotifyHandler is also called from methods which do not have a published event handler property, but may have control handlers added at run-time. For example: VisibleChanging and EnabledChanged.

DoCallKeyEventHandler iterates over the handler routines using the type specified in HandlerType. The routines are cast to the TKeyEvent type used to implement the handler and receives the arguments specified in Key and Shift. The current class instance is used as the Sender for the event notification.

DoCallKeyEventHandler is called from the KeyDown method in descendent classes like TWinControl.

DoCallMouseWheelEventHandler iterates over the handler routines using the type specified in HandlerType. The routines are cast to the TMouseWheelEvent type used to implement the handler and receives the arguments specified in Shift, WheelDelta, MousePos, and Handled. Iteration is halted when an event handler returns True in the Handled argument, or when all handlers for the type have been signalled.

The current class instance is used as the Sender for each of the event notifications.

DoCallMouseWheelEventHandler is called from methods like DoMouseWheel and DoMouseWheelHorz.

DoContextPopup is a method used to signal the OnContextPopup event handler (when assigned). The control instance is used as the Sender argument. Values in MousePos and Handled are also passed as parameters to the event handler. Handled should be set to True in the handler routine if the context pop-up was displayed and a menu item was executed.

SetZOrder calls the SetChildZPosition method in the Parent control to change the Z-Order for the control instance. TopMost indicates whether the control is moved to the top or bottom of the Z-Order.

No actions are performed in the method when Parent has not been assigned.

SetZOrder is used to implement the BringToFront and SendToBack methods. It may be overridden is descendent classes to perform actions needed for the derived controls. See TCustomForm.SetZOrder.

The CX member is set to 75 (pixels). The CY member is set to 50 (pixels).

DoAutoAdjustLayout is a method which implements changes to control sizes for the AutoAdjustLayout method. These methods are called when High-DPI and scaling have been enabled in the project options for an application.

AMode indicates the automatic layout policy applied in the method. It is a value from the TLayoutAdjustmentPolicy enumeration, and determines whether horizontal / vertical / or both sizes are adjusted in the method. It generally reflects the constraints for the device type where the application is running.

AXProportion and AYProportion contain the scaling factors applied to the horizontal and/or vertical sizes.

DoAutoAdjustLayout ensures that new values for Height and Width in the control are calculated (when allowed and needed) using the scaling factors, Constraints, BorderSpacing and Anchors for the control. The SetBoundsKeepBase method is called to apply the newly calculated values to the control.

Font scaling is performed in AutoAdjustLayout (when needed) and occurs prior to calling DoAutoAdjustLayout.

DoAutoAdjustLayout, ScaleFontsPPI, and FixDesignFontsPPI are often overridden in descendent classes to perform additional actions needed for a control or its children.

Implements the FixDesignFontsPPI method for the control.

Performs actions needed to restore the design-time PPI (Pixels Per Inch) for controls when they are loaded using the LCL component streaming mechanism. The design-time PPI for fonts is not stored in .LFM files, and could result in invalid scaling operations when loaded on a machine with a different display density. DoFixDesignFontPPI ensures that the font is resized to the specified design-time PPI.

Adjusts the height for a given Font to the specified pixels per inch (PPI).

DesktopFont is a Boolean property which indicates whether the default desktop (or system) font is used to display the text on the control. The default value for the property is set to True in the Create constructor, and indicates that an explicit assignment has not been made to the Font property. When set to True, the System font in Screen is loaded into the Font property.

Changing the property value causes a CM_SYSFONTCHANGED message to be performed for the control. DesktopFont is set to False when an explicit TFont value is assigned to the Font property.

The default value is crDrag. If the control cannot be dropped on a target, the cursor changes temporarily to crNoDrop.

Set to dkDrag for a drag-drop operation, or to dkDock for a drag-dock operation.

DragMode is a TDragMode property which determines how a drag operation is started for the control.

dmManual is the default value, and indicates that drag operation must be started in code by calling the BeginDrag method.

dmAutomatic allows a drag operation to start when the mouse pointer is dragged over the control.

Use DragKind to specify whether the drag operation is a drag-and-drop or a drag-and-dock operation.

In normal operation, all mouse messages are sent to the control under the mouse pointer. Mouse messages also can be sent to a capturing control, e.g. when a control is dragged.

Applications should capture mouse events only for special purposes, and release the capture as soon as a the target position has been determined. Limited user feedback is possible while the mouse is captured, not all application controls will work properly so long.

ParentBackground is a Boolean property which indicates if the background color from the Parent control is used as the background color for the current control instance.

ParentBackground is True when csParentBackground is included in the ControlStyle property. Setting the value in ParentBackground causes ControlStyle to be updated to include or exclude the csParentBackground enumeration value; it is included when the property is set to True.

ParentBackground and ParentColor are updated when a new value is assigned to the Color property. The properties are set to False when an explicit color is assigned to the Color property.

ParentColor determines if the control should use the Color from the Parent control, when enabled. The default value is True.

When this property is True, all changes to the Color of the parent will also be applied to the Color of the control, ensuring that they both contain same value. If the Color of the control is changed by the application, then ParentColor will be automatically set to False.

Using ParentColor when the Color value is clDefault can cause problems in resolving the actual color value. To obtain the Color property of a control while taking into account clDefault and ParentColor, use the GetColorResolvingParent method. This method might return a non-RGB color, but will never return clDefault. To obtain a purely RGB result use the GetRGBColorResolvingParent method.

While ParentFont is True, changes to the font in the Parent are also applied to the Font for the control. This synchronizes them, keeping them set to the same value. If the value in Font is changed by the application, then ParentFont will automatically be set to False.

The default value for ParentFont is True.

While ParentShowHint is True, all changes to the ShowHint property of the parent will also be applied to the ShowHint property for the control. This synchronizes them, keeping them with the same value. If the ShowHint property for the control is changed by the application, then ParentShowHint will automatically be set to False.

SessionProperties is a String property with the names of properties, in the class instance or its child Components. SessionProperties allows published property values to be saved to and restored from an external storage mechanism like: TIniPropStorage, TXMLPropStorage, or TJSONPropStorage.

Values in the property are delimited using the ';' (SemiColon) character. Component properties require both the component and property names using dotted notation like 'Image1.Visible'. In the TForm descendent class, the values can be assigned at design-time using a dialog in the Lazarus IDE, or by setting the property value at run-time.

In TControl, SessionProperties has protected visibility; it is elevated to published visibility in the TForm descendant.

This is the character string, shown in controls with visible text content (TEdit...).

The Delphi VCL implementation stores Text mostly in the widgets, using the virtual Get/SetTextBuf methods to exchange text between widgets and VCL. This means a lot of text copies and message handling in WM_GETTEXT and WM_SETTEXT.

The LCL instead (typically) stores Text in a field of the control, and transfers it from/to the widgets only when required.

To maintain VCL compatibility, the virtual RealGet/SetText methods have been introduced, which read or write the Caption string directly.

The default Get/SetTextBuf implementation calls the RealGet/SetText methods, resulting in a string-to-PCHAR and another PCHAR-to-string conversion. But as long as Get/SetTextBuf is not overridden, Get/SetText can (and does) safely call RealGet/SetText immediately, to avoid the mentioned conversions.

To keep things optimal, LCL components should always override RealGet/SetText; Get/SetTextBuf is only kept for compatibility.

The handler can show and handle the menu selection itself. If so, it should set Handled to True. Otherwise the installed PopupMenu is shown.

OnDblClick is a TNotifyEvent property with the event handler signalled when the mouse is double-clicked on the control. OnDblClick is signalled from the DblClick method, and occurs when the LM_LBUTTONDBLCLK message is handled in the WMLButtonDBLCLK method.

Double-clicking is much more common in a Windows environment than in Unix or Linux, where single-clicking is the default method for selecting an object. However, in all environments there could be valid use for a double-click, and a method should be supplied if appropriate.

Use OnClick to perform actions needed when a single mouse click occurs in the control.

OnTripleClick is a TNotifyEvent property with the event handler signalled when the mouse is triple-clicked on the control. OnTripleClick is signalled (when assigned) from the TripleClick method, and occurs when the LM_LBUTTONTRIPLECLK message is handled in the WMLButtonTRIPLECLK method.

Use OnClick or OnDblClick to perform actions needed when a single or double mouse click occurs in the control.

OnQuadClick is a TNotifyEvent property with the event handler signalled when the mouse is quadruple-clicked on the control. OnQuadClick is signalled (when assigned) from the QuadClick method, and occurs when the LM_LBUTTONQUADCLK message is handled in the WMLButtonQUADCLK method.

Use OnClick, OnDblClick, or OnTripleClick to perform actions needed when a single, double, or triple mouse click occurs in the control.

OnDragDrop is a TDragDropEvent property with the event handler signalled when another control is dropped onto the control instance. Unlike with drag-dock, a default action is not associated with the drag-drop operation. The OnDragDrop handler is the only way to do something meaningful for the drag-drop operation.

The Sender argument contains the current control instance (Self) for for the event.

The Source argument is the object (TControl) which is droppped onto the current control instance.

X and Y contains the control-relative coordinates for the mouse pointer when the event occurred.

OnDragDrop is signalled from the DragDrop method, and occurs when dmDragDrop messages (TDragMessage) are handled for the control.

OnDragOver is a TDragOverEvent property with the event handler signalled when another control is dragged over the current control. It is signalled from the DragOver method, and occurs when drag messages are handled for the control.

The Sender argument is the current TControl instance.

The Source argument contains the control instance which is being dragged over the control.

The X and Y arguments contain the control-relative coordinates for the mouse pointer when the event was triggered.

State indicates whether the event has occurred when the mouse pointer entered the control, was repositioned, or exited the control.

The Accept argument indicates whether the drag operation is handled in the routine or rejected. Set Accept to False to reject a drop on the control.

OnEndDock is a TEndDragEvent property with the event handler signalled when a drag-dock operation is ended. It occurs when the EndDrag method is called for the active drag object in the DragManager.

Use OnEndDrag to perform actions needed when a drag-drop operation is ended.

OnEndDrag is a TEndDragEvent property with the event handler signalled when a drag-drop operation is ended. It occurs when the EndDrag method is called for the active drag object in the DragManager.

Use OnEndDrag to perform actions needed when a drag-drop operation is ended.

OnMouseDown is signalled (when assigned) from the MouseDown method. It occurs after the parent form has been focused, and an active edit control has been cancelled. If the DragManager is active, it has already been updated with the mouse position prior to the event.

An application must implement and assign a TMouseEvent handler routine to the property which responds to the event notification.

Use OnMouseUp to perform actions needed when a mouse up event is handled for the control.

Use OnMouseMove to perform actions needed when the mouse pointer position has changed for the control.

Use OnMouseWheel, OnMouseWheelDown, and OnMouseWheelUp to preforms actions needed when mouse scroll wheel messages are handled for the control.

OnMouseMove is a TMouseMoveEvent property with the event handler signalled when the LM_MOUSEMOVE message is handled for the control. It is signalled (when assigned) from the MouseMove method, and occurs after the mouse position has been updated and the DragManager has been notified of the new pointer position.

An application can implement and assign an object procedure to the event handler to perform actions needed when the mouse position is changed within the control. The control for the notification event is passed as the Sender argument.

Use OnMouseDown and OnMouseUp to respond to mouse button events in the control.

Use OnMouseEnter and OnMouseLeave to respond to mouse movements where the pointer enters or exits the control.

Use OnMouseWheel to perform actions needed when a mouse wheel event occurs in the control.

OnMouseUp is signalled (when assigned) from the MouseUp method. It is signalled when standard mouse events are enabled using the ControlStyle property. The event is signalled after the mouse position has been updated and the event is applied to an active DragManager.

An application must implement and assign a TMouseEvent handler routine to the property which responds to the event notification.

Use OnMouseDown to perform actions needed when a mouse down event is handled for the control.

Use OnMouseMove to perform actions needed when the mouse pointer position has changed for the control.

Use OnMouseWheel, OnMouseWheelDown, and OnMouseWheelUp to preforms actions needed when mouse scroll wheel messages are handled for the control.

OnMouseEnter is a TNotifyEvent property with the event handler signalled when the mouse pointer has entered the bounds for the control. OnMouseEnter is signalled from the MouseEnter method (when assigned), and occurs after the Parent control has been notified of the event. The Sender argument contains the control for the notification, and must be cast to a TControl type to access the properties or values specific to the class type.

Use OnMouseLeave to perform actions needed when the mouse pointer has left the bounds for the control.

OnMouseLeave is a TNotifyEvent property with the event handler signalled when the mouse pointer has left the bounds for the control. OnMouseLeave is signalled from the MouseLeave method (when assigned), and occurs after the Parent control has been notified of the event. The Sender argument contains the control for the notification, and must be cast to a TControl type to access the properties or values specific to the class type.

Use OnMouseEnter to perform actions needed when the mouse pointer has entered the bounds for the control.

OnMouseWheel is a TMouseWheelEvent property with the event handler signalled when a mouse wheel movement occurs in for the control. By default all mouse wheel actions are translated into scroll events. Write an OnMouseWheel handler to react when the mouse wheel is rotated.

Arguments for the event handler routine include:

Sender

The control for the event notification.

Shift

The shift modifier in effect when the action occurred.

WheelDelta

The relative number of units and direction the mouse wheel was rotated.

MousePos

The location for the mouse pointer when the event occurred.

Handled

A variable argument which indicates if the mouse wheel movement is handled in the event handler.

OnMouseWheel is signalled (when assigned) from the DoMouseWheel method, and occurs when the LM_MOUSEWHEEL message is handled in the WMMouseWheel method. If the event handler does not set the Handled argument to True, other assigned handler routines are signalled. These include control handlers added using the AddHandler method, as well as OnMouseWheelDown and OnMouseWheelUp.

The value in WheelDelta argument is used to determine the handler signalled. OnMouseWheelUp is used when the delta value (or the relative number of units of movement) is 0 (zero) or a positive number. OnMouseWheelDown is used when the delta value is a negative number.

Neither OnMouseWheelUp nor OnMouseWheelDown include the wheel delta value; they are simple notifications that the event has occurred at a given position.

OnMouseWheelDown is a TMouseWheelUpDownEvent property with the event handler signalled when a downward movement of the mouse wheel has occurred in the control.

OnMouseWheelDown is signalled (when assigned) from the DoMouseWheelDown method using the control instance as the Sender for the event notification. It occurs when the OnMouseWheel event handler has not been assigned, or does not handle the mouse wheel event.

Use OnMouseWheelUp to perform actions needed when an upward movement of the mouse wheel has occurred.

Use OnMouseWheel when a delta value with the direction for the mouse wheel movement is needed.

OnMouseWheelUp is a TMouseWheelUpDownEvent property with the event handler signalled when the mouse wheel has been rotated in the upward direction. It is signalled (when assigned) in the DoMouseWheelUp method.

OnMouseWheelUp occurs when a mouse wheel event is handled in the WMMouseWheel method, and an OnMouseWheel event handler has not been assigned or does not handle the mouse wheel event in the DoMouseWheel method.

The arguments for the TMouseWheelUpDownEvent event handler include:

Sender

The control for the event notification.

Shift

The Ctrl, Alt, or Shift modifier in effect when the wheel event occurred.

MousePos

The location of the mouse pointer when the event occurred.

Handled

An variable Boolean argument which indicates if the event is handled in the routine.

OnMouseWheelUp is used when the delta value (or the relative number of units of movement) is 0 (zero) or a positive number.

OnMouseWheelDown is used when the delta value is a negative number.

Neither OnMouseWheelUp nor OnMouseWheelDown include the delta value; they are simple notifications that the event has occurred at a given position.

Use OnMouseWheel when the delta value (or the relative number of units of movement) are important.

OnMouseWheelHorz is a TMouseWheelEvent property with the event handler signalled when a mouse wheel tilt event occurs in the control. It is signalled (when assigned) from the DoMouseWheelHorz method, and occurs when the LM_MOUSEHWHEEL message is handled in the WMMouseHWheel method.

An application can implement and assign a TMouseWheelEvent routine to the event handler to perform actions needed when the event occurs in the control. Other control handlers, created using AddHandler and the chtOnMouseWheelHorz handler type, may be signalled if OnMouseWheelHorz has not been assigned or does not handle the mouse wheel event.

OnMouseWheelLeft or OnMouseWheelRight may be signalled (when assigned) if OnMouseWheelHorz or other control handlers have not been assigned or do not handle the mouse wheel event. The value in the WheelDelta argument determines which handler is used; OnMouseWheelLeft when the delta is a negative number and OnMouseWheelRight when the delta is 0 or a positive number.

OnMouseWheelHorz, and the other horizontal mouse wheel event handlers, require a mouse with a tilting scroll wheel to generate the event notification.

OnMouseWheelLeft is a TMouseWheelUpDownEvent property with the event handler signalled when the mouse wheel is "tilted" towards the left. It is signalled (when assigned) from the DoMouseWheelLeft method, and occurs when the LM_MOUSEHWHEEL message is handled in the WMMouseHWheel method.

Applications can implement and assign a TMouseWheelUpDownEvent to perform actions needed when the event has occurred in the control. The arguments to the event handler include:

Sender

The control for the event notification.

Shift

The shift modifier in effect when the event occurred.

MousePos

The coordinates for the mouse pointer when the event occurred.

Handled

A variable argument which indicates if the wheel event is handled in the routine.

There are several horizontal mouse wheel event handlers, and they are signalled in order until a handler is found that responds to the event notification. These include:

• OnMouseWheelHorz
• Controls handlers added using AddHandler and the chtOnMouseWheelHorz handler type.
• OnMouseWheelLeft or OnMouseWheelRight depending on the WheelDelta - or relative units of movement for the mouse wheel.

OnMouseWheelLeft, and the other horizontal mouse wheel event handlers, require a mouse with a tilting scroll wheel to generate the event notification.

OnMouseWheelRight is a TMouseWheelUpDownEvent property with the event handler signalled when the mouse wheel is "tilted" towards the right. It is signalled (when assigned) from the DoMouseWheelRight method, and occurs when the LM_MOUSEHWHEEL message is handled in the WMMouseHWheel method.

Applications can implement and assign a TMouseWheelUpDownEvent to perform actions needed when the event has occurred in the control. The arguments to the event handler include:

Sender

The control for the event notification.

Shift

The shift modifier in effect when the event occurred.

MousePos

The coordinates for the mouse pointer when the event occurred.

Handled

A variable argument which indicates if the wheel event is handled in the routine.

There are several horizontal mouse wheel event handlers, and they are signalled in order until a handler is found that responds to the event notification. These include:

• OnMouseWheelHorz
• Controls handlers added using AddHandler and the chtOnMouseWheelHorz handler type.
• OnMouseWheelLeft or OnMouseWheelRight depending on the WheelDelta - or relative units of movement for the mouse wheel.

OnMouseWheelRight, and the other horizontal mouse wheel event handlers, require a mouse with a tilting scroll wheel to generate the event notification.

The handler can provide a special DragDock object, otherwise a default object is created.

OnStartDrag is a TStartDragEvent property with the event handler signalled when a drag operation is started for the control. Use the event handler to perform actions needed when the drag operation is started, such customizing the drag cursor or initializing related drag event handlers.

The Sender argument is the TControl instance for the event notification.

The DragObject argument returns the TDragControlObject allocated by the drag manager when the drag operation was started.

The user has finished editing the value for the control, and the resulting text can be validated. It is called (when assigned) from the EditingDone method, which occurs when focus changes to another control.

Calls DoDock to prepare for the new position of the control, when docked into an unmanaged or floating docksite.

When the old and new docksites are different, the control is removed from the DockClients of the old docksite, and added to the DockClients of the new docksite; afterwards the docksites are notified by calling their DoAddDockClient and DoRemoveDockClient methods, to adjust the control's Parent.

Docks this control into NewDockSite, relative to DropControl. When NewDockSite is Nil, the control becomes floating.

When the new docksite uses an DockManager, and DropControl is not Nil, the control will be docked relative to DropControl, as specified by ControlSide.

The interpretation of ControlSide depends on the DockManager of NewDockSite, or on the OnDockDrop handler in an unmanaged docksite.

A tree docking manager (TDockTree) should interpret alCustom as NoteBook docking, i.e. a tabbed notebook is created in place of DropControl, and both DropControl and this control are docked into pages of this notebook.

ManualFloat is a Boolean function used to undock the control. It undocks the control from the HostDockSite (when assigned) found in the control or in its Parent.

For TControl, which does not have a handle, a floating host dock site where the control can be docked is created. TWinControl has a handle and can float without any assistance.

The Dock method is called to dock the control to the new floating dock site.

The return value is True if the control was successfully undocked and re-docked to a floating dock site.

This method exists for use by the DockManager for NoteBook docking. It should not be used in application code.

Delphi introduced a different method, DockReplaceDockClient, which is used when the replaced Control is in an unmanaged docksite.

Docked is a Boolean function which indicates if the control instance is docked to a host docking site. The return value is True when all of the following conditions are met:

• Parent is assigned (not Nil).
• Parent has the same value as the HostDockSite property.
• Parent has a parent form with a value different than the one in Parent.

CreateAccessibleObject should just create and return the object instance. It is useful for classes derived from a descendant of TLazAccessibleObject (instead of the base class).

GetSelectedChildAccessibleObject is provided for controls which wish to override this behavior without sub-classing TLazAccessibleObject.

GetChildAccessibleObjectAtPos returns the accessibility object at the position expressed in client coordinates. This method is provided for controls which wish to override this behavior without sub-classing TLazAccessibleObject.

AdjustSize is the same as Delphi the TWinControl.DoAutoSize method. But since DoAutoSize is commonly overridden in descendent components, it is not useful to perform all tests, which can result in too much overhead. To reduce this the LCL calls AdjustSize instead.

During loading and handle creation the calls are delayed.

AutoSizePhases is a TControlAutoSizePhases function used to get the Autosizing phases enabled for the control. In general, the values in AutoSizePhases depend on the TWinControlFlag values enabled for the control.

For TControl, the values from the Parent control are used. If the Parent control is unassigned, the value is an empty set ([]).

For TWinControl, the value from the Parent control are used (when a Parent has been assigned). Otherwise, the windows control flags are used to get the return value. For example:

wcfCreatingHandle,wcfCreatingChildHandles

Includes caspCreatingHandles in the set

wcfRealizingBounds

Includes caspRealizingBounds in the set

wcfUpdateShowing

Includes caspShowing in the set

In addition, AutoSizingAll forces caspComputingBounds to be included in the set. caspChangingProperties is included when the internal auto-sizing lock count has a value greater than zero (0).

A TControl instance does not have a handle, so it needs a parent control.

Setup AnchorSide to anchor a side to a neighboring sibling control. For example: Right side to Left side, or Top side to Bottom.

Table or tree style anchoring, into a neighbor cell of Sibling. Obtain the row height (or column width) from Sibling.

The anchor control used in the TAnchorSide instances is always the Parent control.

AnchoredControls is a read-only indexed TControl property which allows access to controls which which are anchored to the control instance. Anchored controls are indexed by their ordinal position in the list used to store the values.

SetBounds can be used to change the Left, Top, Width, and Height properties as a single action. This reduces the overhead required for the common operation. Use DisableAutoSize and EnableAutoSize to reduce the overhead for recomputing/moving/resizing even further.

SetBounds is also called when any one of these properties, or the BoundsRect property is set. SetBounds updates BaseBounds and BaseParentClientSize, which are used by the anchoring mechanism to keep the spacing between controls. For example loading a Form with TMemo and the .lfm contains TMemo's Left and Width, then SetBounds is called two times for the memo.

When the user maximizes a window, SetBounds is called for the form, but not for the Memo, keeping the BaseBounds of the Memo. If the Memo is anchored to the right, the Width of the Memo is changed based on the BaseBounds and BaseParentClientSize.

Keep in mind that the given aLeft, aTop, aWidth, aHeight might not be valid and will be changed by the LCL before applied.

Delphi calls SetBounds more often. SetBounds calls ChangeBounds with the KeepBase argument set to False.

SetBoundsKeepBase is a procedure used to set the bounds for a Control to the specified values without affecting the bounds in a Parent control.

SetBoundsKeepBase calls the ChangeBounds method to update the sized and position for the control to the specified values. If you use this in a custom control, disable LCL auto-sizing for this control prior to calling the method.

SetBoundsKeepBase is used in the implementation for several methods, including:

• WMSize
• WMMove
• WMWindowPosChanged
• DoAutoSize
• DoAutoAdjustLayout
• DoUndock
• Loaded

Called during AutoSize calculations. Only positive values are valid. Negative or 0 are treated as undefined and the LCL uses other sizes instead.

WithThemeSpace: If True, adds space for stacking.

For example: TRadioButton has a minimum size. But for stacking multiple TRadioButtons there should be some space around. This space is theme dependent, so the parameter is passed to the widgetset

TWinControl overrides this and asks the interface for theme dependent values. See for more information.

GetCanvasScaleFactor is a Double function used to get the scaling factor for the Canvas in the control.

GetCanvasScaleFactor calls the corresponding method in the widgetset class to get the return value. For TControl and TWSControl, the return value is always 1.0. It may be overridden in descendent classes to use a value appropriate to the implementation.

GetCanvasScaleFactor is used in descendent classes when selecting a scalable image resolution for images and glyphs associated with a control.

GetDefaultColor is a TColor function used to resolve the default color (clDefault) to a TColor value for the control. GetDefaultColor can return a color value for either the control background or its text. The DefaultColorType argument identifies which value is needed in the return value. In TControl, the following color types and values are used:

dctBrush

Background or fill color for the control (Color). Returns the clWindow system color.

dctFont

Text color for the control (Font.Color). Returns the clWindowText system color.

GetDefaultColor uses the value provided by the corresponding method in the widgetset class instance when a value other than clDefault is returned. When not resolved in the widgetset class, the return value is retrieved using the Parent color or the local values in the class instance. If ParentColor is True (and Parent is assigned), the GetDefaultColor method in the Parent control is called to get the specified color type. Otherwise, one of the values from the preceding list is used for the color type.

GetDefaultColor is a virtual method and can be overridden in descendent classes to use the colors needed for a specific control.

GetDefaultColor is used in the implementation of the GetColorResolvingParent and GetRGBColorResolvingParent methods. It is also called from the SetColor and CreateBrush methods in the TWinControl descendant.

GetColorResolvingParent is a convenience routine used to obtain the Color for the control while resolving clDefault. It will never return clDefault, but it might return a non-RGB color. To obtain a purely RGB result use GetRGBColorResolvingParent.

GetRGBColorResolvingParent is a convenience routine used to get an RGB color value for the background on the control. It calls GetColorResolvingParent to translate the clDefault color value to the Brush color in a Parent control. It calls ColorToRGB to convert a color constant to its numeric equivalent and to remove any alpha channel information in the color value.

The return value contains the coordinate for the anchor side indicated in the Side argument. For example:

akLeft

Returns the value in the Left property.

akTop

Returns the value in the Top property.

akRight

Returns the value in the Right property.

akBottom

Returns the value in the Bottom property.

Called by the LCL interface, when something changed that effects the interface values for GetPreferredSize.

EnableAutoSizing is used along with DisableAutoSizing to suspend and restore auto-sizing when the Parent, alignment, layout, visibility, or state for the control is updated. An exception is raised if EnableAutoSizing is called when DisableAutoSizing has not been called.

EnableAutoSizing decrements the internal counter used to track auto-sizing locks. When the counter reaches 0 (zero), the EnableAutoSizing method in the Parent control is called (when assigned). Otherwise, the DoAllAutoSize method is called to trigger the OnResize event handlers for the control.

It is not generally used in application code, but is needed by component developers.

The current Bounds can change, due to scaling, anchoring or auto-sizing.

ReadBounds is a read-only TRect property used when the values for the Top, Left, Height and Width properties are set during LCL component streaming. When ComponentState contains csLoading, changes to these properties cause the new values to be applied to ReadBounds prior to calling the SetBounds method. The internal ControlFlags are also updated to indicate that the property value has been loaded using LCL component streaming.

BaseBounds and BaseParentClientSize determine the distance to keep from Parent's sides, when a side is anchored to the Parent (akLeft...), and the Parent is resized.

Formats and outputs bounds, alignment, and anchor information for the debugger.

AutoAdjustLayout can be used to alter PPI settings, scale the control, or apply changes to height or width without scaling.

AMode indicates the layout policy applied in the method, and the actions performed to achieve the task.

Scaling factors are calculated (when needed) for both horizontal (X-axis) and vertical (Y-axis ) adjustments. The factors may represent changes to the PPI settings, or changes in the width for the control.

AutoAdjustLayout temporarily disables auto-sizing, and calls DoAutoAdjustLayout to apply the scaling factors or size changes.

In TControl, both AWidth and AHeight are set to True when the AutoSize property has not been enabled.

FixDesignFontsPPI is a method used to adjust the font size when the design-time PPI (Pixels per Inch) setting differs from the run-time PPI setting for the font in the control. It calls DoFixDesignFontPPI to restore the value in ADesignTimePPI to the Font reference passed as an argument to to the method. The font height is scaled using the factor represented by TFont.PixelsPerInch/ADesignTimePPI.

This method does not trigger a CM_PARENTFONTCHANGED message in the Parent control.

In TControl, this action is performed for the Font property. In descendent class, additional properties with a font reference may also be adjusted using the method.

FixDesignFontsPPI is called when scaling is enabled, and the Form which hosts the control calls its Loaded method when LCL streaming is completed.

ScaleFontsPPI is a method used to resize a font in the control to the specified display density (Pixels per Inch) using the scaling factor in AProportion (when needed).

A font may need to be scaled when the run-time PPI setting for the screen differs from the design-time value applied to the font. If the font height is not assigned at run-time, its height is set to the value in TFont.PixelsPerInch / Screen.PixelsPerInch.

When AToPPI has a positive non-zero value, it is stored in the TFont.PixelsPerInch property for the font. Otherwise, the existing TFont.PixelsPerInch value is adjusted using the scaling factor in AProportion.

ScaleFontsPPI may be overridden in descendent controls to call the method for its child controls.

ScaleFontsPPI is called form the AutoAdjustLayout method.

Create is the overridden constructor for the class instance. Create calls the inherited constructor using TheOwner as the owner for the class instance. Resources are allocated in the method for members in the class instance, and the default values are set for the following properties:

• Align
• Anchors
• BaseBounds
• CaptureMouseButtons
• Color
• ControlStyle
• Cursor
• DesktopFont
• DragCursor
• Enabled
• FloatingDockSiteClass
• Font
• HelpType
• IsControl
• ParentBidiMode
• ParentColor
• ParentFont
• ParentShowHint
• Visible
• WindowProc

Detaches the control from Parent, removes graphics, frees memory and Operating System handles, pointers etc.

BeforeDestruction is a method which performs notifications when an object instance is about to be freed. It allows tasks to be performed which maintain a persistent object instance and its observers before it is destroyed.

BeforeDestruction is an overridden method in TControl, and calls the inherited method on entry to ensure that csDestroying is included in the ComponentState property for the control and any of its child components. It extends the inherited method by calling DoCallNotifyHandler for any handler routines using the chtOnBeforeDestruction type.

Called when user has finished editing using the control. This procedure can be used by data links to commit the changes.

For example:

• When focus switches to another control (default).
• When user selected another item.

Each control class can determine which events cause the value(s) to be committed.

ExecuteDefaultAction has an empty implementation in TControl. It can be overridden in descendent classes to perform any actions needed for the class type.

ExecuteCancelAction has an empty implementation in TControl. It can be overridden in descendent classes to perform any actions needed for the class type.

BringToFront is a method used to move the control to the top of the Z-Order for its sibling controls. BringToFront calls SetZOrder to change the display order for controls which share a common Parent. BringToFront has no effect when Parent has not been assigned.

HasParent is called during streaming to decide if a component has to be streamed by its owner or Parent.

GetParentComponent gets the component / control which has the current class instance in its Components property. GetParentComponent is an overridden method in TControl, and re-implements the inherited method. It uses the value in the Parent property as the return value for the method. The inherited method always returns Nil.

IsParentOf is a Boolean function used to determine if the current control instance is ultimately a parent of the control specified in AControl. No actions are performed in the method when AControl has not been assigned (Nil), and the return value is set to False.

IsParentOf visits each control in the Parent control hierarchy, and returns True if the current class instance (Self) is found in the tree. The return value is False if the current control instance is not found in the Parent control tree.