Class TCastleButton
Unit
Declaration
type TCastleButton = class(TCastleUserInterfaceFont)
Description
Clickable button.
This is TCastleUserInterface descendant, so to use it just add it to the TCastleWindow.Controls or TCastleControl.Controls list. You will also usually want to adjust position (TCastleButton.Left, TCastleButton.Bottom), TCastleButton.Caption, and assign TCastleButton.OnClick (or ovevrride TCastleButton.DoClick).
Hierarchy
- TObject
- TPersistent
- TComponent
- TCastleComponent
- TCastleUserInterface
- TCastleUserInterfaceFont
- TCastleButton
Overview
Fields
nested const DefaultImageMargin = 10; |
|
nested const DefaultPaddingHorizontal = 10; |
|
nested const DefaultPaddingVertical = 10; |
|
nested const DefaultLineSpacing = 2; |
|
nested const DefaultTextAlignment = hpMiddle; |
Methods
procedure SetPressed(const Value: boolean); virtual; |
|
procedure UIScaleChanged; override; |
|
procedure PreferredSize(var PreferredWidth, PreferredHeight: Single); override; |
|
function GetInternalText: String; override; |
|
procedure SetInternalText(const Value: String); override; |
|
procedure TranslateProperties(const TranslatePropertyEvent: TTranslatePropertyEvent); override; |
|
constructor Create(AOwner: TComponent); override; |
|
destructor Destroy; override; |
|
procedure Render; override; |
|
function Press(const Event: TInputPressRelease): boolean; override; |
|
function Release(const Event: TInputPressRelease): boolean; override; |
|
function Motion(const Event: TInputMotion): boolean; override; |
|
procedure FontChanged; override; |
|
procedure Update(const SecondsPassed: Single; var HandleInput: boolean); override; |
|
procedure VisibleChange(const Changes: TCastleUserInterfaceChanges; const ChangeInitiatedByChildren: boolean = false); override; |
|
procedure EditorAllowResize(out ResizeWidth, ResizeHeight: Boolean; out Reason: String); override; |
|
function PropertySections(const PropertyName: String): TPropertySections; override; |
|
procedure DoClick; virtual; |
|
procedure SetFocused(const Value: boolean); override; |
Properties
property TintPressed : TCastleColor read FTintPressed write FTintPressed; |
|
property TintDisabled: TCastleColor read FTintDisabled write FTintDisabled; |
|
property TintFocused : TCastleColor read FTintFocused write FTintFocused; |
|
property TintNormal : TCastleColor read FTintNormal write FTintNormal; |
|
property CustomTextColor: TCastleColor read FCustomTextColor write FCustomTextColor; |
|
property CustomColorPressed: TCastleColor read FCustomColorPressed write SetCustomColorPressed; |
|
property CustomColorDisabled: TCastleColor read FCustomColorDisabled write SetCustomColorDisabled; |
|
property CustomColorFocused: TCastleColor read FCustomColorFocused write SetCustomColorFocused; |
|
property CustomColorNormal: TCastleColor read FCustomColorNormal write SetCustomColorNormal; |
|
property MinImageWidth: Single read FMinImageWidth write FMinImageWidth default 0; |
|
property MinImageHeight: Single read FMinImageHeight write FMinImageHeight default 0; |
|
property TextAlignment: THorizontalPosition
read FTextAlignment write SetTextAlignment default DefaultTextAlignment; |
|
property Alignment: THorizontalPosition
read FAlignment write SetAlignment default hpMiddle; |
|
property VerticalAlignment: TVerticalPosition
read FVerticalAlignment write SetVerticalAlignment default vpMiddle; |
|
property LineSpacing: Single read FLineSpacing write SetLineSpacing
default DefaultLineSpacing; |
|
property Html: boolean read FHtml write SetHtml default false; |
|
property CustomBackground: boolean read FCustomBackground write FCustomBackground default false; |
|
property Image: TCastleImagePersistent read FImage; |
|
property ImageScale: Single read FImageScale write SetImageScale default 1.0; |
|
property CustomBackgroundPressed: TCastleImagePersistent read FCustomBackgroundPressed; |
|
property CustomBackgroundDisabled: TCastleImagePersistent read FCustomBackgroundDisabled; |
|
property CustomBackgroundFocused: TCastleImagePersistent read FCustomBackgroundFocused; |
|
property CustomBackgroundNormal: TCastleImagePersistent read FCustomBackgroundNormal; |
|
property CustomTextColorUse: boolean read FCustomTextColorUse write FCustomTextColorUse default false; |
|
property PaddingHorizontal: Single
read FPaddingHorizontal write SetPaddingHorizontal default DefaultPaddingHorizontal; |
|
property PaddingVertical: Single
read FPaddingVertical write SetPaddingVertical default DefaultPaddingVertical; |
|
property AutoSize: boolean read FAutoSize write SetAutoSize default true; |
|
property AutoSizeWidth: boolean read FAutoSizeWidth write SetAutoSizeWidth default true; |
|
property AutoSizeHeight: boolean read FAutoSizeHeight write SetAutoSizeHeight default true; |
|
property MinWidth: Single read FMinWidth write SetMinWidth default 0; |
|
property MinHeight: Single read FMinHeight write SetMinHeight default 0; |
|
property OnClick: TNotifyEvent read FOnClick write FOnClick; |
|
property Caption: String read FCaption write SetCaption; |
|
property CaptionTranslate: Boolean read FCaptionTranslate write FCaptionTranslate default true; |
|
property Toggle: boolean read FToggle write FToggle default false; |
|
property Pressed: boolean read FPressed write SetPressed default false; |
|
property ImageLayout: TCastleButtonImageLayout
read FImageLayout write SetImageLayout default ilLeft; |
|
property ImageMargin: Single read FImageMargin write SetImageMargin
default DefaultImageMargin; |
|
property Enabled: boolean read FEnabled write SetEnabled default true; |
|
property EnableParentDragging: boolean
read FEnableParentDragging write FEnableParentDragging default false; |
|
property TintPressedPersistent: TCastleColorPersistent read FTintPressedPersistent ; |
|
property TintDisabledPersistent: TCastleColorPersistent read FTintDisabledPersistent ; |
|
property TintFocusedPersistent: TCastleColorPersistent read FTintFocusedPersistent ; |
|
property TintNormalPersistent: TCastleColorPersistent read FTintNormalPersistent ; |
|
property CustomTextColorPersistent: TCastleColorPersistent read FCustomTextColorPersistent ; |
|
property CustomColorPressedPersistent: TCastleColorPersistent read FCustomColorPressedPersistent ; |
|
property CustomColorDisabledPersistent: TCastleColorPersistent read FCustomColorDisabledPersistent ; |
|
property CustomColorFocusedPersistent: TCastleColorPersistent read FCustomColorFocusedPersistent ; |
|
property CustomColorNormalPersistent: TCastleColorPersistent read FCustomColorNormalPersistent ; |
Description
Fields
nested const DefaultImageMargin = 10; |
|
This item has no description. |
nested const DefaultPaddingHorizontal = 10; |
|
This item has no description. |
nested const DefaultPaddingVertical = 10; |
|
This item has no description. |
nested const DefaultLineSpacing = 2; |
|
This item has no description. |
nested const DefaultTextAlignment = hpMiddle; |
|
This item has no description. |
Methods
procedure SetPressed(const Value: boolean); virtual; |
|
This item has no description. |
procedure UIScaleChanged; override; |
|
This item has no description. |
procedure PreferredSize(var PreferredWidth, PreferredHeight: Single); override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.PreferredSize. Controls that have a preferred size should override this. By default this contains values derived from Width, WidthFraction, Height, HeightFraction, with Border subtracted. Note that the arguments should be already scaled, i.e. multiplied by UIScale, i.e. expressed in final device pixels. Note that the returned PreferredWidth and PreferredHeight must not include the space for Border. Border size will be added later. |
function GetInternalText: String; override; |
|
This item has no description. |
procedure SetInternalText(const Value: String); override; |
|
This item has no description. |
procedure TranslateProperties(const TranslatePropertyEvent: TTranslatePropertyEvent); override; |
|
This item has no description. Showing description inherited from TCastleComponent.TranslateProperties. Enumerate all properties that are possible to translate in this component. E.g. in TCastleLabel it will return TCastleLabel.Caption, in TCastleEdit it will return TCastleEdit.Text and TCastleEdit.Placeholder. Returns only non-empty properties, thus assuming that if current (by convention, English) text is empty, then there is no point in translating it. Moreover descendants may define boolean properties to exclude particular text from translating, e.g. TCastleLabel.CaptionTranslate, TCastleEdit.TextTranslate, TCastleEdit.PlaceholderTranslate. It is not recursive (it doesn't enumerate children properties). Use global TranslateProperties procedure to call this on a hierarchy of TComponent. You usually don't want to call this method (it is called by other engine routines). But you may find it useful to override this, if you define new component. |
constructor Create(AOwner: TComponent); override; |
|
This item has no description. |
destructor Destroy; override; |
|
This item has no description. |
procedure Render; override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.Render. Render a control. Called only when Exists and render context is initialized. Do not call this method. It will be automatically called by the engine when needed. It will be called when UI is part of TCastleContainer.Controls list or rendered (e.g. for off-screen rendering) by TCastleContainer.RenderControl. You should only override this method. See https://castle-engine.io/manual_2d_ui_custom_drawn.php for examples what you can put here. You can depend on some OpenGL state being set before calling this method. You can depend on it being set, and you can carelessly change it. This state we set:
Beware that GLSL RenderContext.CurrentProgram has undefined value when this is called. You should always set it, before making direct OpenGL drawing calls (all the engine drawing routines do it already, this is only a concern if you make direct OpenGL / OpenGLES calls). |
function Press(const Event: TInputPressRelease): boolean; override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.Press.
Override this method to react to user pressing a key, mouse button or mouse wheel. Return When implementing in descendants it is best to override it like this: function TMyControl.Press(const Event: TInputPressRelease): boolean; begin Result := inherited; if Result then Exit; // exit if ancestor already handled this event if Event.IsKey(keyEnter) then begin // do something in reaction to Enter key ... // let engine know that this input event was handled Exit(true); end; if Event.IsMouseButton(buttonLeft) then begin // do something in reaction to left mouse button press ... // let engine know that this input event was handled Exit(true); end; end;
These events are generated for all UI controls, whether they are considered "interactive" or not. These events are generated for non-interactive controls like TCastleRectangleControl or TCastleLabel as well. For example, these events ignore the TCastleButton.Enabled state, they are generated always (see https://github.com/castle-engine/castle-engine/issues/413 ). Use instead TCastleButton.OnClick to detect clicks on a button in a way that honors the TCastleButton.Enabled state. When a control returns The events Press and Release are passed to the parent only after the children had a chance to process this event. Overriding them makes sense if you draw something that "looks clickable" in TCastleUserInterface.Render, which is the standard place you should draw stuff. For example our TCastleButton draws there. In contrast, the events PreviewPress and PreviewRelease are passed first to the parent control, before children have a chance to process this event. In partcular, overriding them makes sense if you draw something that "looks clickable" in TCastleUserInterface.RenderOverChildren. |
function Release(const Event: TInputPressRelease): boolean; override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.Release.
Override this method to react to user releasing a key, mouse button. Return This is counterpart to Press method. See Press for more details. Note: We'd like this method to also be called when user releases a mouse wheel. But currently releasing of the mouse wheel is not reported now by any backend. Only releasing of keys and mouse buttons is reported. |
function Motion(const Event: TInputMotion): boolean; override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.Motion.
|
procedure FontChanged; override; |
|
This item has no description. Showing description inherited from TCastleUserInterfaceFont.FontChanged. Force considering font changed (font instance, or glyphs, or sizes changed). Usually, you don't need to call this explicitly from the outside. Changing font, like CustomFont or TCastleContainer.DefaultFont or UIFont, or any property that may affect the font is automatically applied. But there are exceptions: right now, if you call Load on a font, it's measurements will change but some controls using it will not recalculate sizes automatically. In this case, call this method. |
procedure Update(const SecondsPassed: Single; var HandleInput: boolean); override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.Update. Control may do here anything that must be continuously repeated. E.g. camera handles here falling down due to gravity, rotating model in Examine mode, and many more.
This method may be used, among many other things, to continuously react to the fact that user pressed some key (or mouse button). For example, if holding some key should move some 3D object, you should do something like: if HandleInput then begin if Container.Pressed[keyArrowRight] then begin Transform.Position := Transform.Position + Vector3(SecondsPassed * 10, 0, 0); HandleInput := false; end; end;
Instead of directly using a key code, consider also using TInputShortcut that makes the input key nicely configurable. See engine tutorial about handling inputs. Multiplying movement by SecondsPassed makes your operation frame-rate independent. Object will move by 10 units in a second, regardless of how many FPS your game has. The code related to HandleInput is important if you write a generally-useful control that should nicely cooperate with all other controls, even when placed on top of them or under them. The correct approach is to only look at pressed keys/mouse buttons if HandleInput is Note that to handle a single press / release (like "switch light on when pressing a key") you should rather use Press and Release methods. Use this method only for continuous handling (like "holding this key makes the light brighter and brighter"). To understand why such HandleInput approach is needed, realize that the "Update" events are called differently than simple mouse and key events like "Press" and "Release". "Press" and "Release" events return whether the event was somehow "handled", and the container passes them only to the controls under the mouse (decided by TCastleUserInterface.CapturesEventsAtPosition). And as soon as some control says it "handled" the event, other controls (even if under the mouse) will not receive the event. This approach is not suitable for Update events. Some controls need to do the Update job all the time, regardless of whether the control is under the mouse and regardless of what other controls already did. So all controls (well, all controls that exist, in case of TCastleUserInterface, see TCastleUserInterface.Exists) receive Update calls. So the "handled" status is passed through HandleInput. If a control is not under the mouse, it will receive HandleInput = |
procedure VisibleChange(const Changes: TCastleUserInterfaceChanges; const ChangeInitiatedByChildren: boolean = false); override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.VisibleChange. Called always when something important inside this control (or it's children) changed. To be more precise, this is called when something mentioned among the TCastleUserInterfaceChange enumerated items changed. This is always called with Changes <> [] (non-empty set). |
procedure EditorAllowResize(out ResizeWidth, ResizeHeight: Boolean; out Reason: String); override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.EditorAllowResize. Override this to prevent resizing some dimension in CGE editor. |
function PropertySections(const PropertyName: String): TPropertySections; override; |
|
This item has no description. Showing description inherited from TCastleComponent.PropertySections. Section where to show property in the editor. |
procedure DoClick; virtual; |
|
Called when user clicks the button. In this class, simply calls OnClick callback. |
procedure SetFocused(const Value: boolean); override; |
|
This item has no description. Showing description inherited from TCastleUserInterface.SetFocused. Called when this control becomes or stops being focused, that is: under the mouse cursor and will receive events. This updates Focused property. This also calls OnInternalMouseEnter / OnInternalMouseLeave. |
Properties
property TintPressed : TCastleColor read FTintPressed write FTintPressed; |
|
Color tint when button is pressed (regardless if enabled or disabled). Opaque white by default. |
property TintDisabled: TCastleColor read FTintDisabled write FTintDisabled; |
|
Color tint when button is disabled (and not pressed). Opaque white by default. |
property TintFocused : TCastleColor read FTintFocused write FTintFocused; |
|
Color tint when button is focused. Opaque white by default. |
property TintNormal : TCastleColor read FTintNormal write FTintNormal; |
|
Color tint when button is enabled, but neither pressed nor focused. Opaque white by default. |
property CustomTextColor: TCastleColor read FCustomTextColor write FCustomTextColor; |
|
Text color to use if CustomTextColorUse is |
property CustomColorPressed: TCastleColor read FCustomColorPressed write SetCustomColorPressed; |
|
Button colors used when CustomBackground is By default they are all transparent black, so actually the button is completely transparent in this case. They are affected by tint (see TintPressed, TintDisabled, TintFocused, TintNormal). The tint color is simply multiplied component-wise with these colors. By default all tint colors are opaque white, so the multiplication by tint actually doesn't change anything. |
property CustomColorDisabled: TCastleColor read FCustomColorDisabled write SetCustomColorDisabled; |
|
This item has no description. |
property CustomColorFocused: TCastleColor read FCustomColorFocused write SetCustomColorFocused; |
|
This item has no description. |
property CustomColorNormal: TCastleColor read FCustomColorNormal write SetCustomColorNormal; |
|
This item has no description. |
property MinImageWidth: Single read FMinImageWidth write FMinImageWidth default 0; |
|
Auto-size routines (see AutoSize) may treat the image like always having at least these minimal sizes. Even if the Image is empty ( |
property MinImageHeight: Single read FMinImageHeight write FMinImageHeight default 0; |
|
This item has no description. |
property TextAlignment: THorizontalPosition
read FTextAlignment write SetTextAlignment default DefaultTextAlignment; |
|
For multi-line Caption, the horizontal alignment of the lines. |
property Alignment: THorizontalPosition
read FAlignment write SetAlignment default hpMiddle; |
|
Horizontal alignment of the text+image within button area, useful in case you don't use AutoSize. We align text+image within the available area inside the button (which is determined by button size, without paddings determined by PaddingHorizontal, PaddingVertical). |
property VerticalAlignment: TVerticalPosition
read FVerticalAlignment write SetVerticalAlignment default vpMiddle; |
|
Vertical alignment of the text+image within button area, useful in case you don't use AutoSize. We align text+image within the available area inside the button (which is determined by button size, without paddings determined by PaddingHorizontal, PaddingVertical). |
property LineSpacing: Single read FLineSpacing write SetLineSpacing
default DefaultLineSpacing; |
|
For multi-line Caption, the extra spacing between lines. May also be negative to squeeze lines tighter. |
property Html: boolean read FHtml write SetHtml default false; |
|
Enable HTML tags in the Caption. This allows to easily change colors or use bold, italic text. See the example examples/fonts/html_text.lpr and examples/fonts/html_text_demo.html for a demo of what HTML tags can do. See TCastleAbstractFont.PrintStrings documentation for a list of support HTML markup. Note that to see the bold/italic font variants in the HTML markup, you need to set the font to be TCastleFontFamily with bold/italic variants. See the example mentioned above, examples/fonts/html_text.lpr, for a code how to do it. |
property CustomBackground: boolean read FCustomBackground write FCustomBackground default false; |
|
Use custom background images. If
They are affected by tint (see TintPressed, TintDisabled, TintFocused, TintNormal). |
property Image: TCastleImagePersistent read FImage; |
|
Optional image displayed on the button. |
property ImageScale: Single read FImageScale write SetImageScale default 1.0; |
|
Scaling of Image. |
property CustomBackgroundPressed: TCastleImagePersistent read FCustomBackgroundPressed; |
|
Background image on the pressed button. See CustomBackground for details. |
property CustomBackgroundDisabled: TCastleImagePersistent read FCustomBackgroundDisabled; |
|
Background image on the disabled button. See CustomBackground for details. |
property CustomBackgroundFocused: TCastleImagePersistent read FCustomBackgroundFocused; |
|
Background image on the focused button. See CustomBackground for details. |
property CustomBackgroundNormal: TCastleImagePersistent read FCustomBackgroundNormal; |
|
Background image on the normal button. See CustomBackground for details. |
property CustomTextColorUse: boolean read FCustomTextColorUse write FCustomTextColorUse default false; |
|
Should we use custom text color in CustomTextColor instead of |
property PaddingHorizontal: Single
read FPaddingHorizontal write SetPaddingHorizontal default DefaultPaddingHorizontal; |
|
Horizontal distance between text or Image and the button border. |
property PaddingVertical: Single
read FPaddingVertical write SetPaddingVertical default DefaultPaddingVertical; |
|
Vertical distance between text or Image and the button border. |
property AutoSize: boolean read FAutoSize write SetAutoSize default true; |
|
When Width is auto-calculated only when If needed, you can query the resulting button size with the standard TCastleUserInterface methods like TCastleUserInterface.EffectiveWidth and TCastleUserInterface.EffectiveHeight. Note that they may not be available before the button is actually added to the container, and the container size is initialized (we need to know the size of container, for UI scaling to determine the font size). |
property AutoSizeWidth: boolean read FAutoSizeWidth write SetAutoSizeWidth default true; |
|
This item has no description. |
property AutoSizeHeight: boolean read FAutoSizeHeight write SetAutoSizeHeight default true; |
|
This item has no description. |
property MinHeight: Single read FMinHeight write SetMinHeight default 0; |
|
This item has no description. |
property OnClick: TNotifyEvent read FOnClick write FOnClick; |
|
This item has no description. |
property Caption: String read FCaption write SetCaption; |
|
Caption to display on the button. The text may be multiline (use the LineEnding or NL constants to mark newlines). |
property CaptionTranslate: Boolean read FCaptionTranslate write FCaptionTranslate default true; |
|
Should the Caption be localized (translated into other languages). Determines if the property is enumerated by TCastleComponent.TranslateProperties, which affects the rest of localization routines. |
property Toggle: boolean read FToggle write FToggle default false; |
|
Can the button be permanently pressed. Good for making a button behave like a checkbox, that is indicate a boolean state. When Toggle is |
property Pressed: boolean read FPressed write SetPressed default false; |
|
Is the button pressed down. If Toggle is When not Toggle, this property isn't really useful to you. The pressed state is automatically managed then to visualize user clicks. In this case, you can read this property, but you cannot reliably set it. |
property ImageLayout: TCastleButtonImageLayout
read FImageLayout write SetImageLayout default ilLeft; |
|
Where the Image is drawn on a button. |
property ImageMargin: Single read FImageMargin write SetImageMargin
default DefaultImageMargin; |
|
property Enabled: boolean read FEnabled write SetEnabled default true; |
|
Enabled button can be focused and clicked, is not grayed-out. |
property EnableParentDragging: boolean
read FEnableParentDragging write FEnableParentDragging default false; |
|
Enable to drag a parent control, for example to drag a TCastleScrollView that contains this button. To do this, you need to turn on TCastleScrollView.EnableDragging, and set |
property TintPressedPersistent: TCastleColorPersistent read FTintPressedPersistent ; |
|
TintPressed that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write TintPressed directly. See also
|
property TintDisabledPersistent: TCastleColorPersistent read FTintDisabledPersistent ; |
|
TintDisabled that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write TintDisabled directly. See also
|
property TintFocusedPersistent: TCastleColorPersistent read FTintFocusedPersistent ; |
|
TintFocused that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write TintFocused directly. See also
|
property TintNormalPersistent: TCastleColorPersistent read FTintNormalPersistent ; |
|
TintNormal that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write TintNormal directly. See also
|
property CustomTextColorPersistent: TCastleColorPersistent read FCustomTextColorPersistent ; |
|
CustomTextColor that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write CustomTextColor directly. See also
|
property CustomColorPressedPersistent: TCastleColorPersistent read FCustomColorPressedPersistent ; |
|
CustomColorPressed that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write CustomColorPressed directly. See also
|
property CustomColorDisabledPersistent: TCastleColorPersistent read FCustomColorDisabledPersistent ; |
|
CustomColorDisabled that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write CustomColorDisabled directly. See also |
property CustomColorFocusedPersistent: TCastleColorPersistent read FCustomColorFocusedPersistent ; |
|
CustomColorFocused that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write CustomColorFocused directly. See also |
property CustomColorNormalPersistent: TCastleColorPersistent read FCustomColorNormalPersistent ; |
|
CustomColorNormal that can be visually edited in Castle Game Engine Editor, Lazarus and Delphi. Normal user code does not need to deal with this, instead read or write CustomColorNormal directly. See also |
Generated by PasDoc 0.16.0-snapshot.