Class TCastleImageControl

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 310).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 311).

This item has no description.

Source: base/castleclassutils.pas (line 604).

Override this method to call various methods of SerializationProcess, which in turn allows to serialize/deserialize things that are not published. This allows to serialize/deserialize with more freedom, e.g. to serialize/deserialize some private field.

Source: base/castleclassutils.pas (line 610).

Section where to show property in the editor.

Source: base/castleclassutils.pas (line 631).

Ignore this component when serializing parent's TCastleUserInterface.Controls list or TCastleTransform.List, and do not show this component in CGE editor. This simply sets csTransient flag in ComponentStyle.

This is useful for children that are automatically managed by the parent, and should not be modified by user code. For example, TCastleCheckbox is internally composed from TCastleImageControl and TCastleLabel children, but we don't want to serialize or even show these children to user.

Note that if you want to prevent this component from serializing as part of TCastleUserInterface.Controls list or TCastleTransform.List, but you still want it to be visible in CGE editor, then make it a "subcomponent" instead, by SetSubComponent(true).

Note that both csSubComponent and csTransient only disable the component serialization as part of parent's lists enumerated by CustomSerialization (see internal TCastleUserInterface.SerializeChildrenEnumerate , TCastleTransform.SerializeChildrenEnumerate, TCastleTransform.SerializeBehaviorsEnumerate).

If you will make the component published in its own property (which is normal for "subcomponents") then it will be serialized anyway, just as part of it's own property (like TCastleScrollView.ScrollArea). So to really avoid serializing a children component make it csSubComponent and/or csTransient, and do not publish it.

Source: base/castleclassutils.pas (line 663).

Add non-visual component to this component. This is used to organize non-visual components in a tree hierarchy, in CGE designs and editor.

See also

NonVisualComponentsCount

Count of components added by AddNonVisualComponent.

NonVisualComponents

Components added by AddNonVisualComponent.

NonVisualComponentsEnumerate

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do ....

Source: base/castleclassutils.pas (line 672).

Insert non-visual component to this component. This is used to organize non-visual components in a tree hierarchy, in CGE designs and editor.

See also

NonVisualComponentsCount

Count of components added by AddNonVisualComponent.

NonVisualComponents

Components added by AddNonVisualComponent.

NonVisualComponentsEnumerate

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do ....

Source: base/castleclassutils.pas (line 681).

Removes the component previously added by AddNonVisualComponent.

Source: base/castleclassutils.pas (line 684).

Index of the previously added non-visual component. Returns -1 if the component was not found.

Source: base/castleclassutils.pas (line 688).

Count of components added by AddNonVisualComponent.

See also

AddNonVisualComponent

Add non-visual component to this component.

NonVisualComponents

Components added by AddNonVisualComponent.

NonVisualComponentsEnumerate

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do ....

Source: base/castleclassutils.pas (line 695).

You can enumerate current non-visual components using loop like for C in MyComponent.NonVisualComponentsEnumerate do .... Do not call this method in other contexts, it is only useful for "for..in" construction.

See also

AddNonVisualComponent

Add non-visual component to this component.

Source: base/castleclassutils.pas (line 705).

Whether the current value of this object should be written to the stream. This should be True if anything inside this object should be serialized (which means it has non-default value or "stored" specifier indicates that it should be serialized).

This is used by CastleComponentSerialize, which is used in Castle Game Engine for all serialization.

In simple cases, this just says whether the current value of this object equals to some default value.

The default implementation of this class returns True (so always write).

Descendants that override this to sometimes return False (so no need to write) must be very careful: any addition of a new field requires extending this method, otherwise new field may not be saved sometimes (when all other fields are default). Descentants of such classes must also be aware of it. This check must include everything that is inside this object in JSON, including subcomponents and children objects (as done e.g. by TSerializationProcess.ReadWriteList). In practice, overriding this method is only reasonable for simple classes that will not change much in the future, like TCastleVector3Persistent.

The name of this method is consistent with TPropertyEditor.ValueIsStreamed in LCL.

Source: base/castleclassutils.pas (line 739).

Override to add information that should be visible at design-time. Call SList.Add for each new line of information.

Source: base/castleclassutils.pas (line 743).

Override to add warnings that should be visible at design-time. Call SList.Add for each new warning.

Source: base/castleclassutils.pas (line 747).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 313).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 314).

This item has no description. Showing description inherited from TCastleComponent.CustomSerialization.

Override this method to call various methods of SerializationProcess, which in turn allows to serialize/deserialize things that are not published. This allows to serialize/deserialize with more freedom, e.g. to serialize/deserialize some private field.

Source: ui/castleuicontrols_userinterface.inc (line 315).

This item has no description. Showing description inherited from TCastleComponent.PropertySections.

Section where to show property in the editor.

Source: ui/castleuicontrols_userinterface.inc (line 316).

This item has no description. Showing description inherited from TCastleComponent.DesignerInfo.

Override to add information that should be visible at design-time. Call SList.Add for each new line of information.

Source: ui/castleuicontrols_userinterface.inc (line 317).

This item has no description. Showing description inherited from TCastleComponent.DesignerWarnings.

Override to add warnings that should be visible at design-time. Call SList.Add for each new warning.

Source: ui/castleuicontrols_userinterface.inc (line 318).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 319).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 320).

Override this method to react to user pressing a key, mouse button or mouse wheel. Return True if the event was handled, which prevents from passing this event to other UI controls.

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 True from Press, it means it starts to "capture" subsequent mouse events: subsequent mouse moves and release will be send to this control even if mouse will move outside of this control.

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.

Source: ui/castleuicontrols_userinterface.inc (line 376).

Override this method to react to user releasing a key, mouse button. Return True if the event was handled, which prevents from passing this event to other UI controls.

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.

See also

Press

Override this method to react to user pressing a key, mouse button or mouse wheel.

Source: ui/castleuicontrols_userinterface.inc (line 391).

Similar to Press but allows the parent control to preview the event before it is passed to children UI controls.

See also

Press

Override this method to react to user pressing a key, mouse button or mouse wheel.

Source: ui/castleuicontrols_userinterface.inc (line 397).

Similar to Release but allows the parent control to preview the event before it is passed to children UI controls.

See also

Press

Override this method to react to user pressing a key, mouse button or mouse wheel.

Source: ui/castleuicontrols_userinterface.inc (line 403).

Motion of mouse or touch.

Source: ui/castleuicontrols_userinterface.inc (line 406).

Rotation detected by 3D sensor. Used for example by 3Dconnexion devices.

Parameters

X

X axis (tilt forward/backwards)

Y

Y axis (rotate)

Z

Z axis (tilt sidewards)

Angle

Angle of rotation (in radians)

SecondsPassed

The time passed since last SensorRotation call. This is necessary because some sensors, e.g. 3Dconnexion, may *not* reported as often as normal Update calls.

Source: ui/castleuicontrols_userinterface.inc (line 418).

Translation detected by 3D sensor. Used for example by 3Dconnexion devices.

Parameters

X

X axis (move left/right)

Y

Y axis (move up/down)

Z

Z axis (move forward/backwards)

Length

Length of the vector consisting of the above

SecondsPassed

The time passed since last SensorRotation call. This is necessary because some sensors, e.g. 3Dconnexion, may *not* reported as often as normal Update calls.

Source: ui/castleuicontrols_userinterface.inc (line 430).

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 True. Moreover, if you did check that HandleInput is True, and you did actually handle some keys, then you have to set HandleInput := false. This will prevent the other controls (behind the current control) from handling the keys (they will get HandleInput = False). And this is important to avoid doubly-processing the same key press, e.g. if two controls react to the same key, only the one on top should process it.

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 = False. If a control is under the mouse, it will receive HandleInput = True as long as no other control on top of it didn't already change it to False.

Parameters

SecondsPassed

Should be calculated like TFramesPerSecond.SecondsPassed, and usually it's in fact just taken from TCastleWindow.Fps.SecondsPassed.

Source: ui/castleuicontrols_userinterface.inc (line 504).

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).

Source: ui/castleuicontrols_userinterface.inc (line 512).

Allow window containing this control to suspend waiting for user input. Typically you want to override this to return False when you do something in the overridden Update method.

In this class, this simply returns always True.

See also

TCastleWindow.AllowSuspendForInput

Is it allowed to suspend (for an indefinite amount of time) waiting for user input.

Source: ui/castleuicontrols_userinterface.inc (line 534).

Event called when the container (component or window with OpenGL context) size changes.

You can resize/reposition your component here to react to parent size changes. This is called only when the rendering context of the container is initialized, so you can be sure that this is called only between GLContextOpen and GLContextClose.

We also call this once when inserting into the controls list (like TCastleWindow.Controls or TCastleControl.Controls or inside parent TCastleUserInterface), if inserting into the container/parent with already initialized OpenGL context. If inserting into the container/parent without OpenGL context initialized, it will be called later, when OpenGL context will get initialized, right after GLContextOpen.

In other words, this is always called to let the control know the size of the container, if and only if the OpenGL context is initialized.

Source: ui/castleuicontrols_userinterface.inc (line 556).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 587).

Add child control, at the front of other children.

Source: ui/castleuicontrols_userinterface.inc (line 590).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 591).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 592).

Add child control, at the back of other children.

Source: ui/castleuicontrols_userinterface.inc (line 595).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 596).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 597).

Add child control at specified position. It is usually easier to use InsertFront or InsertBack, if possible.

Source: ui/castleuicontrols_userinterface.inc (line 602).

Remove control added by InsertFront or InsertBack.

Note that this method does not free the Item instance. This method merely removes Item from our controls, so that Item is no longer rendered as part of this parent. It is still the caller's responsibility to make sure the Item is freed at some point.

See https://castle-engine.io/modern_pascal#_freeing_classes for description how to free instances in Pascal. As TCastleUserInterface descends from TComponent, a simple and proper solution is often just to create it with some "owner" (like TCastleView.FreeAtStop or Application) that will take care of freeing it.

Source: ui/castleuicontrols_userinterface.inc (line 617).

Index of child control, or -1 if not present.

Source: ui/castleuicontrols_userinterface.inc (line 620).

Remove all child controls added by InsertFront or InsertBack.

Note that, just like RemoveControl, this method does not free the children controls. This method merely removes children controls, so they are no longer rendered as part of the parent. It is still the caller's responsibility to make sure the children controls are freed at some point.

See https://castle-engine.io/modern_pascal#_freeing_classes for description how to free instances in Pascal. As TCastleUserInterface descends from TComponent, a simple and proper solution is often just to create it with some "owner" (like TCastleView.FreeAtStop or Application) that will take care of freeing it.

Source: ui/castleuicontrols_userinterface.inc (line 635).

Move to become the front-most control within the parent.

This works when this control is a child of another control (has Parent assigned) or when it's a direct child of the container (in which case Parent is not assigned by Container is, which means the control is directly on TCastleContainer.Controls list).

This is ignored if this control is not within any container (so, also not within any parent).

Source: ui/castleuicontrols_userinterface.inc (line 646).

Does this control capture events under this container position. The default implementation simply checks whether Position is inside RenderRect. It also checks whether CapturesEvents is True.

Always treated like False when Exists returns False, so the implementation of this method only needs to make checks assuming that Exists = True.

Source: ui/castleuicontrols_userinterface.inc (line 660).

Prepare your resources, right before drawing. Called only when Exists and GLInitialized.

Do not explicitly call this method. Instead, render controls by adding them to the TCastleContainer.Controls list, or render them explicitly (for off-screen rendering) by TCastleContainer.RenderControl.

Source: ui/castleuicontrols_userinterface.inc (line 670).

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:

• Viewport is set to include whole container.

• Depth test is off.

• For ancient fixed-function pipeline (see TGLFeatures.RequestCapabilities):

  • The 2D orthographic projection is always set at the beginning. Useful for 2D controls.

  • The modelview matrix is set to identity. The matrix mode is always modelview.

  • The raster position is set to (0,0). The (deprecated) WindowPos is also set to (0,0).

  • Texturing, lighting, fog is off.

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).

Source: ui/castleuicontrols_userinterface.inc (line 714).

Render a control contents over the children controls. This is analogous to Render, but it executes after children are drawn. You should usually prefer to override Render instead of this method, as the convention is that the parent is underneath children.

You should only override this method (do not call it, it will be called by the engine).

See https://castle-engine.io/manual_2d_ui_custom_drawn.php for examples what you can put here.

Source: ui/castleuicontrols_userinterface.inc (line 725).

Warning: this symbol is deprecated: use TooltipControl to customize tooltip look

Render a tooltip of this control. If you want to have tooltip for this control detected, you have to override TooltipExists. Then the TooltipRender will be called.

TooltipRender is called in the same way as Render. TooltipRender is always called as a last (front-most) control. Argument TooltipPosition is the left-bottom (in screen space, regardless of UIScaling) suggested position of the tooltip.

It is simplest to descend from TCastleUserInterfaceFont, that implements simple TCastleUserInterfaceFont.Tooltip property and overrides these two methods as necessary.

Source: ui/castleuicontrols_userinterface.inc (line 741).

Warning: this symbol is deprecated: use TooltipControl to customize tooltip look

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 742).

Initialize your OpenGL resources.

This is called when OpenGL context of the container is created, or when the control is added to the already existing context. In other words, this is the moment when you can initialize OpenGL resources, like display lists, VBOs, OpenGL texture names, etc.

As an exception, this is called regardless of the Exists value. This way a control can prepare it's resources, regardless if it exists now.

Source: ui/castleuicontrols_userinterface.inc (line 754).

Destroy your OpenGL resources.

Called when OpenGL context of the container is destroyed. Also called when controls is removed from the container Controls list. Also called from the destructor.

You should release here any resources that are tied to the OpenGL context. In particular, the ones created in GLContextOpen.

As an exception, this is called regardless of the Exists value. This way a control can release it's resources, regardless if it exists now.

Source: ui/castleuicontrols_userinterface.inc (line 767).

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.

Source: ui/castleuicontrols_userinterface.inc (line 813).

Control position and size. Use this to base other controls size/position on this control's calculated size/position.

The algorithm that determines control position and size is like this:

• When AutoSizeToChildren is True:

  The control size is adjusted to children, to surround them. Left and Bottom and our anchors still matter, but our Width and Height do not matter. See the AutoSizeToChildren documentation for details.

• Otherwise, when FullSize is True:

  The control always fills the whole parent. If the control is added directly to the container, it will fill the whole container (TCastleWindow or TCastleControl).

• Otherwise (when FullSize and AutoSizeToChildren are both False):

  The position and size of the control is determined by the Left, Bottom, Width, Height properties.

  Moreover, WidthFraction, if non-zero, specifies the control width as a fraction of the parent width. E.g. WidthFraction = 1.0 means that width equals parent, 0.5 means it's half the width of the parent etc. In this case the explicit Width is ignored.

  Similarly you can use HeightFraction to express height as a fraction of parent. When HeightFraction is not zero, then the explicit Height is ignored.

  If at least one of the resulting sizes is zero, the rectangle is empty (it is TFloatRectangle.Empty).

The above describes the size of the content and border, summed. The content itself may be a little smaller, when the Border is used. The size of the "content itself" is returned only by RenderRect (in already-scaled coordinates, i.e. using final device pixels).

The anchors (see Anchor) also affect the final position of the control.

Note that some descendants do auto-sizing by default. This means that some of these properties may be ignored, and instead the calculated size (EffectiveWidth, EffectiveHeight) depends on some core values of the control.

For example:

• TCastleImageControl adjusts to image (unless you set TCastleImageControl.Stretch to True),

• TCastleLabel adjusts to caption (unless you set TCastleLabel.AutoSize to False),

• TCastleButton adjusts to caption and icon (unless you set TCastleButton.AutoSize to False),

• TCastleVerticalGroup adjusts to children sizes,

• ... and so on.

Consult the documentation of each descendant for the exact specification of the size behavior.

This method returns the rectangle in local coordinates (relative to the parent 2D control). The returned rectangle size includes the border size. The returned rectangle size uses "unscaled" coordinates, which means that they correspond to the sizes you set e.g. in TCastleUserInterface.Width, TCastleUserInterface.Height, and translation units you use with e.g. TCastleUserInterface.Anchor.

If you're looking for a way to query the size of the control in final scaled coordinates (in real device pixels), and not relative to the parent position, use RenderRect or RenderRectWithBorder instead.

This method ignores the current value of the Exists method and Exists property, that is: the result of this function assumes that control does exist.

See also

TCastleUserInterface.EffectiveWidth

Calculated width of the control, without UI scaling.

TCastleUserInterface.EffectiveHeight

Calculated height of the control, without UI scaling.

Source: ui/castleuicontrols_userinterface.inc (line 927).

Calculated width of the control, without UI scaling. Useful if you want to base other controls size/position on this control calculated size.

Unlike the Width property, this is the effective size, not the desired size. So this is already processed by any auto-sizing mechanism (e.g. TCastleImageControl may adjust it's own size to the underlying image, depending on settings), it is changed by FullSize and so on.

It is always equal to just EffectiveRect.Width. It is 0 when EffectiveRect is empty.

See also

EffectiveRect

Control position and size.

Source: ui/castleuicontrols_userinterface.inc (line 943).

Calculated height of the control, without UI scaling. Useful if you want to base other controls size/position on this control calculated size.

Unlike the Height property, this is the effective size, not the desired size. So this is already processed by any auto-sizing mechanism (e.g. TCastleImageControl may adjust it's own size to the underlying image, depending on settings), it is changed by FullSize and so on.

It is always equal to just EffectiveRect.Height. It is 0 when EffectiveRect is empty.

See also

EffectiveRect

Control position and size.

Source: ui/castleuicontrols_userinterface.inc (line 959).

EffectiveWidth without Border size.

Source: ui/castleuicontrols_userinterface.inc (line 962).

EffectiveHeight without Border size.

Source: ui/castleuicontrols_userinterface.inc (line 964).

Warning: this symbol is deprecated: use EffectiveWidth

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 966).

Warning: this symbol is deprecated: use EffectiveHeight

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 967).

Warning: this symbol is deprecated: use EffectiveRect

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 968).

Position and size of this control, assuming it exists, in container coordinates (in final device pixels). The primary use of this is inside Render. A proper UI control should adjust to draw precisely in this rectangle.

Source: ui/castleuicontrols_userinterface.inc (line 974).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 975).

Warning: this symbol is deprecated: use RenderRect

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 977).

Convert position relative to container (in final device coordinates, without UI scaling, by default) into position relative to this UI control (in coordinates with UI scaling). Useful e.g. to convert mouse/touch position from TInputPressRelease.Position into position useful for children of this UI control.

The exact definition is that using the result of this to set our child Translation, assuming the child is anchored to the left-bottom (the default state) and child has Left = Bottom = 0, sets child position exactly to the indicated point on the container.

Parameters

ContainerPositionScaled

If True (default) then the container position (the ContainerPosition parameter) is assumed to be in final device pixels, i.e. the window area in X is from 0 to TCastleContainer.Width, in Y from 0 and TCastleContainer.Height. This is useful when the parameter comes e.g. from TInputPressRelease.Position.

If False then the container position (the ContainerPosition parameter) is assumed to be in unscaled device pixels, i.e. the window area in X is from 0 to TCastleContainer.UnscaledWidth, in Y from 0 and TCastleContainer.UnscaledHeight.

Source: ui/castleuicontrols_userinterface.inc (line 1003).

Convert position relative to this UI control (in coordinates with UI scaling) into relative to container (in final device coordinates, without UI scaling, by default). Reverses ContainerToLocalPosition.

Parameters

ContainerPositionScaled

If True (default) then the container position (the result of this method) is assumed to be in final device pixels, i.e. the window area in X is from 0 to TCastleContainer.Width, in Y from 0 and TCastleContainer.Height.

If False then the container position (the result of this method) is assumed to be in unscaled device pixels, i.e. the window area in X is from 0 to TCastleContainer.UnscaledWidth, in Y from 0 and TCastleContainer.UnscaledHeight.

Source: ui/castleuicontrols_userinterface.inc (line 1022).

Rectangle filling the parent control (or container), in local coordinates. Since this is in local coordinates, the returned rectangle Left and Bottom are always zero, unless parent has Border (the returned rectangle is shrunk by Parent.Border). This is already scaled by UI scaling.

Source: ui/castleuicontrols_userinterface.inc (line 1030).

Adjust position to align us with the parent horizontally. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets HorizontalAnchorSelf, HorizontalAnchorParent, Translation.X.

Source: ui/castleuicontrols_userinterface.inc (line 1042).

Adjust position to align us with the parent horizontally. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets HorizontalAnchorSelf, HorizontalAnchorParent, Translation.X.

Source: ui/castleuicontrols_userinterface.inc (line 1055).

Adjust position to align us to the parent vertically. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets VerticalAnchorSelf, VerticalAnchorParent, Translation.Y.

Source: ui/castleuicontrols_userinterface.inc (line 1069).

Adjust position to align us to the parent vertically. The resulting EffectiveRect and RenderRect and RenderRectWithBorder will immediately reflect the new position.

Note that position set here (anchors, Translation) are ignored when FullSize is set to true. In case of FullSize, the control fills the parent perfectly.

This utility method sets VerticalAnchorSelf, VerticalAnchorParent, Translation.Y.

Source: ui/castleuicontrols_userinterface.inc (line 1082).

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Left. Deprecated, use Align with THorizontalPosition.

Source: ui/castleuicontrols_userinterface.inc (line 1091).

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Left.

Note that using Anchor is often more comfortable than this method, since you only need to set anchor once (for example, right after creating the control). In contrast, adjusting position using this method will typically need to be repeated at each window on resize, like in TCastleUserInterface.Resize.

Source: ui/castleuicontrols_userinterface.inc (line 1104).

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Bottom. Deprecated, use Align with TVerticalPosition.

Source: ui/castleuicontrols_userinterface.inc (line 1112).

Warning: this symbol is deprecated: use Anchor

Immediately position the control with respect to the parent by adjusting Bottom.

Note that using Anchor is often more comfortable than this method, since you only need to set anchor once (for example, right after creating the control). In contrast, adjusting position using this method will typically need to be repeated at each window on resize, like in TCastleUserInterface.Resize.

Source: ui/castleuicontrols_userinterface.inc (line 1125).

Warning: this symbol is deprecated: use Anchor(hpMiddle); Anchor(vpMiddle); to reliably center the control

Immediately center the control within the parent, both horizontally and vertically.

Note that using Anchor is often more comfortable than this method, since you only need to set anchor once. For example, right after creating the control call Anchor(hpMiddle); Anchor(vpMiddle);. In contrast, adjusting position using this method will typically need to be repeated at each window on resize, like in TCastleUserInterface.Resize.

Source: ui/castleuicontrols_userinterface.inc (line 1141).

UI scale of this control, derived from container (see TCastleContainer.UIScaling and EnableUIScaling).

Source: ui/castleuicontrols_userinterface.inc (line 1145).

Override this to prevent resizing some dimension in CGE editor.

Source: ui/castleuicontrols_userinterface.inc (line 1148).

Is the FullSize actually active. Checks FullSize and not AutoSizeToChildren, i.e. it accounts that AutoSizeToChildren overrides FullSize (since they cannot both work at the same time).

Source: ui/castleuicontrols_userinterface.inc (line 1254).

Components added by AddNonVisualComponent.

Source: base/castleclassutils.pas (line 698).

Is the component during deserialization now.

Note: We can't use csLoading in ComponentState because in Delphi it is not possible to control it from CastleComponentSerialize.

Source: base/castleclassutils.pas (line 711).

Called always when something important inside this control (or it's children) changed. See VisibleChange for details about when and how this is called.

Be careful when handling this event. Various changes may cause this, so be prepared to handle it at any moment, even in the middle when UI control is changing. It may also occur very often. It's usually safest to only set a boolean flag like "something should be recalculated" when this event happens, and do the actual recalculation later.

Source: ui/castleuicontrols_userinterface.inc (line 524).

Container of this control. When adding control to container's Controls list (like TCastleWindow.Controls) container will automatically set itself here, and when removing from container this will be changed back to Nil.

May be Nil if this control is not yet inserted into any container.

Source: ui/castleuicontrols_userinterface.inc (line 564).

Warning: this symbol is deprecated: use OnVisibleChange (or override VisibleChange) and watch for Changes that include chCursor

Event called when the Cursor property changes. This event is, in normal circumstances, used by the Container, so you should not use it in your own programs.

Source: ui/castleuicontrols_userinterface.inc (line 570).

Warning: this symbol is deprecated: do not use this; supporting this property was complicated and had no real benefit; everything now works as if ExclusiveEvents=true, always

Should we disable further mouse / keys handling for events that we already handled in this control. If True, then our events will return True for mouse and key events handled.

This means that events will not be simultaneously handled by both this control and some other (or camera or normal window callbacks), which is usually more sensible, but sometimes somewhat limiting.

Source: ui/castleuicontrols_userinterface.inc (line 582).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 586).

Warning: this symbol is deprecated: use Exists

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 649).

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 769).

See SetFocused.

Source: ui/castleuicontrols_userinterface.inc (line 816).

Visual parent control. This control is rendered within the parent, and it's anchors and coordinates are relative to the parent. Parent may be Nil, which means that the Container (if set) is our direct parent.

Note that this property doesn't have a setter, as it could be confusing: the order in which children are inserted into parent sometimes matters, for back-and-front order. If you want to change the parent, you can use code like this:

if Control.Parent <> nil then
  Control.Parent.RemoveControl(Control);
if NewParent <> nil then
  NewParent.InsertFront(Control); // or InsertBack, as InsertControl...

Source: ui/castleuicontrols_userinterface.inc (line 834).

Warning: this symbol is deprecated: use Width

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1152).

Warning: this symbol is deprecated: use Height

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1154).

Warning: this symbol is deprecated: use Translation

Position of the control, relative to the anchor at parent (by default, relative to left-bottom corner of the parent).

Source: ui/castleuicontrols_userinterface.inc (line 1160).

Position of the control, relative to the anchor at parent (by default, relative to left-bottom corner of the parent).

Source: ui/castleuicontrols_userinterface.inc (line 1165).

Keep the control in front of other controls (with KeepInFront=False) when inserting.

TODO: Do not change this property while the control is already a child of something.

Source: ui/castleuicontrols_userinterface.inc (line 1172).

Color of the Border, by default completely transparent black.

Source: ui/castleuicontrols_userinterface.inc (line 1176).

Warning: this symbol is deprecated: this property does not do anything anymore, anchors are always active

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1179).

Warning: this symbol is deprecated: this property does not do anything anymore, anchors are always active

This item has no description.

Source: ui/castleuicontrols_userinterface.inc (line 1182).

Warning: this symbol is deprecated: use Translation.X

Delta between our border and parent.

See also

Anchor

Adjust position to align us to the parent vertically.

Source: ui/castleuicontrols_userinterface.inc (line 1189).

Warning: this symbol is deprecated: use Translation.Y

Delta between our border and parent.

See also

Anchor

Adjust position to align us to the parent vertically.

Source: ui/castleuicontrols_userinterface.inc (line 1194).

Is the control possibly visible. This is always True when Culling is False (the default).

Source: ui/castleuicontrols_userinterface.inc (line 1200).

Enable or disable UI scaling for this particular control. See more about UI scaling on TCastleContainer.UIScaling and TCastleUserInterface.UIScale. Setting this to False forces TCastleUserInterface.UIScale to always return 1.0.

Note that this does not work recursively, i.e. it does not affect the children of this control. Setting this to False does not prevent UI scaling on children (you have to turn it off explicitly for children too, if you need to disable UI scaling recursively).

The use-cases for changing this property to "false" are very rare. Usually you should use UI scaling for 100% of your UI.

Source: ui/castleuicontrols_userinterface.inc (line 1214).

Capture input events (keyboard, mouse, joystick). If False, then the methods like Press and Release will never be called, and Update will always be called with HandleInput = False. The control will never behave like focused.

The only exception is when this control is set as TCastleContainer.ForceCaptureInput. In this case, the control will receive inputs. In other words, TCastleContainer.ForceCaptureInput overrides the intent of this property.

This property may be replaced by something like "CaptureInput" or just universal "Enabled" in the future.

Source: ui/castleuicontrols_userinterface.inc (line 1229).

Called when control starts being under the mouse cursor and will receive events. See SetFocused, this is called when Focused changes from False to True.

This is called "Internal" now, because we do not guarantee it's 100% always paired with OnInternalMouseLeave. A different approach to this may be done in the future releases.

Source: ui/castleuicontrols_userinterface.inc (line 1238).

Called when control stops being under the mouse cursor and will receive events. See SetFocused, this is called when Focused changes from True to False.

This is called "Internal" now, because we do not guarantee it's 100% always paired with OnInternalMouseEnter. A different approach to this may be done in the future releases.

Source: ui/castleuicontrols_userinterface.inc (line 1247).