About

As any object-oriented engine DUI2 supposed that any GUI control is a different instance.
GUI elements declaring in the engine by using the components derived from certain classes supported with embedding into backstage engine logic.

The engine by itself is a framework so allows you to create a control as from a scratch using the most basic classes that handling only the control integration into the engine, or by using more advanced solutions created from specific tasks.

During development it's important to understand that a single object can has only a single component derived from AGUIElement class.
But if you need to make a control more extendable and flexible you always my use Content Inspectors features

Core classes

When you are working with core extension you have a several base classes those implementation allows you to create an instance that will be fully integrated into internal logic.

AGUIElement

It a ground level abstract class that must be derived by any element of Doloro UI 2. The element encapsulates object integration to the engine. Implements a wide collection of message handler that occurs along with engine internal events.

Explore API: Doloro.UIEngine2.AGUIElement

To implement a new GUI element, you enough to create a new script derived from the AGUIElement.

Warning: In case of overriding of base Unity's messages handlers like always call base method in body before any extra action.
public class CustomGUIElement : AGUIElement

{

protected override void Awake()

{

// Calling base awake implementation.

base.Awake();

// Your awake instructions here.

}

}

When you are overriding the base message handlers you no need to care about base method call. Entire handlers’ calls are fully encapsulated so can be implemented safely without consideration of the backstage operations.

Message Handler	Purpose
`OnMoved`	Should be called when element position is modified.
`OnSizeChanged`	Should be called when element size is modified.
`OnFocus`	Occurs when element requested on focus.
`OnLostFocus`	Occurs when UI losing focus.
`OnHoverBegin`	Occurs when pointer starts hovering the element.
`OnHover`	Occurs when the pointer is over the element.
`OnHoverEnd`	Occurs when pointer ending hovering the element.
`OnDragBegin`	Occurs when pointer is start drag process.
`OnDrag`	Occurs each frame when you drag the element.
`OnDragEnd`	Occurs when dragging element from `ElementOnAction` is released.
`OnPointerDown`	Occurs when LBM pressed above hovering element.
`OnPointerUp`	Occurs when LBM released above hovering element.
`OnContextMenu`	Occurs when you are calling context menu with focused element.

AGUIField

Light weighted class derived from AGUIElement extends its logic with value property according with events and messages related to its changes.

Warning: Allows only operations by values, not by type.

Message Handler	Purpose
`OnValueChanged`	Occurs when `value` changed.

Content Inspectors

AContentInspectorGUIElement is advanced control that follows similar task that the AGUIField follows but more suitable for times when value supposed to be a complex object. Implemented handlers suitable for managing a complex GUI rather than single value GUI.

Message Handler	Purpose
`OnContentChanged`	Occurs when `content` property has been changed.
`ApplyGUIContent`	Occurs when content is not `null`. Use to load new values to following GUI.
`DropGUIContent`	Occurs when content is `null`. Use to release following GUI from previous values.

AExtandableInspectorGUIElement is the AContentInspectorGUIElement derived component that allows to create a complex extendable ecosystem of controls that affects GUI along with backstage content update.
The control attaches AContentInspectorExtension components located over the same game object and relays internal messages to destination handlers.

Such controls are fully supports ddm merging features that makes it possible to extend controller with new GUI features at runtime with custom modifications shared with asset bundles without affecting the main layout and core solutions.

Explore API:

Doloro.UIEngine2.Controls.AContentInspectorGUIElement{ContentType}
Doloro.UIEngine2.Controls.AExtandableInspectorGUIElement{ContentType, GUIExtensionType}
Doloro.UIEngine2.Controls.AContentInspectorExtension{ContentType}

Implemented controls

Following category highlights only main controls supplied only with dui2 package and not mentions controls implemented by other modules.
Provided controls implement a very diverse logic with different complexity that should be useful as example for your custom implementations.

Control	Complexity	Description
Rect GUI Element	Primitive	A GUI element that represents GUI space. Using in case you need to integrate some unity featured controller in dui2 engine logic, by adding the component over the same object.
Grid collection	Medium	Control implemented with the Elements Collection module. Provides you with a flexible solution for `AGUIElement` collections explorer fully integrated with core engine features.
Window UI Controller	Medium	Control that implements Window features into in-game GUI.
Window Drag controller	Simple	Control that works along with parental `Window` and handles its move over the screen during self-drag.
Window Resize controller	Simple	Control that works along with parental `Window` and handles it resize during self-drag. Defines drag behavior suitable to control position to layout.
Runtime Workspace Layout	Advanced	Complex control implemented with the Runtime Workspace module.

Defines logic of dynamic layout that can be assembled into a complex multi-layout’ solution. | | Runtime Workspace Splitter| Simple | Part of Runtime Workspace logic. The control initializes resize of runtime layouts divided with it. | | Measured slider | Simple | Control over the Unity's Slider that allows to make it measures visible to player making the experience more comfort. |