KIDE^x YAML Attributes (RTTI-based property discovery)

Starting with Kitto^x 4.x, the KIDE^x visual editor discovers YAML metadata properties at runtime via Delphi RTTI attributes, replacing the external MetadataTemplates YAML files used in previous versions.

When you right-click a node in the KIDE^x tree editor, the popup menu is built dynamically by reading the RTTI annotations on the Delphi class that represents that node.

Attribute types

Kitto^x defines six custom attribute classes in EF.YAML.Attributes.pas:

YamlNode — Scalar properties

The most common attribute. Marks a property as mapped to a YAML node with an optional default value.

// Without default value
[YamlNode('Expression', 'SQL expression for computed fields')]
property Expression: string read GetExpression;

// With default value (always a string)
[YamlNode('IsVisible', 'True', 'Field visibility in views')]
property IsVisible: Boolean read GetIsVisible;

// Localizable property (generates DisplayLabel + DisplayLabel2)
[YamlNode('DisplayLabel', '', 'Label shown in forms and grids', True)]
property DisplayLabel: string read GetDisplayLabel;

In KIDE^x, scalar properties appear as "Add {NodePath}" or "Add {NodePath}: {Default}" menu items when the node is not yet present.

YamlRequiredNode — Required scalar properties

Inherits from YamlNode. Used for properties that must be present (e.g. ModelName, Model).

[YamlRequiredNode('ModelName', 'Unique model identifier')]
property ModelName: string read GetModelName;

Required nodes appear first in the popup menu.

YamlContainer — Collection of N children

Marks a property as a container of homogeneous children (e.g. Fields, Rules). In KIDE^x, containers are always visible in the menu with "Add {NodePath} child".

[YamlContainer('Fields', TKModelField, 'Data fields of this model')]
property Fields: TKModelFields read GetFields;

[YamlContainer('Rules', TKRule, 'Business rules applied to this field')]
property Rules: TKRules read GetRules;

YamlSubNode — Single config block

Marks a property as a sub-object with a fixed set of properties. KIDE^x navigates into the sub-node class via RTTI to discover its own properties.

[YamlSubNode('HTMLEditor', TKHTMLEditorConfig, 'Rich-text editor toolbar options')]
property HTMLEditor: TKHTMLEditorConfig read GetHTMLEditor;

[YamlSubNode('Controller', TKViewTableControllerConfig, 'List/form controller settings')]
property ControllerConfig: TKViewTableControllerConfig read GetControllerConfig;

SubNode menu items appear only if the node is not already present: "Add {NodePath}".

YamlChildType — Container child types

Applied to container classes (not properties) to list the types of children that can be added. Multiple attributes can be applied to the same class.

[YamlChildType('StringField', 'String(10)', 'String field with max length')]
[YamlChildType('IntegerField', 'Integer', 'Integer numeric field')]
[YamlChildType('DateField', 'Date', 'Date field')]
TKModelFields = class(TKMetadataItem)

In KIDE^x, child type entries always appear in the menu as "Add {Name}: {DefaultValue}" or "Add {Name}".

YamlEnumValue — Enum value mapping

Applied to enumerated types to map ordinal values to YAML strings. Used by KIDE^x to populate combo box drop-downs.

[YamlEnumValue('Top', 'Label above the field')]
[YamlEnumValue('Left', 'Label to the left, left-aligned')]
[YamlEnumValue('Right', 'Label to the left, right-aligned')]
TKLabelAlign = (laTop, laLeft, laRight);

How KIDE^x resolves the class for a node

When you select a node in the KIDE^x tree editor, the function GetNodeMetadataClass in KIDE.Utils.pas determines which Delphi class to query for RTTI:

Node type	Resolution
TKModelField, TKViewField, TKViewTable, TKDataView, TKLayout, TKModel, TKView	Direct class match via is check
TKModelFields, TKRules, TKViewFields, TKViewTables	Direct class match (container classes)
TKTreeView, TKTreeViewFolder, TKTreeViewNode	Direct class match
TEFComponentConfig	Maps to TKConfig
TEFNode with name ending in "Controller"	Resolved via GetControllerClass (controller registry)
Any other TEFNode	Automatic: walks up to the parent, reads its [YamlSubNode] annotations, and returns the matching sub-node class

The automatic parent-based resolution means that adding a [YamlSubNode] annotation to a parent class is sufficient to make KIDE^x discover the sub-node's properties — no hardcoded mapping needed.

KIDE^x popup menu behavior

When you right-click a node, RebuildPopupMenu in KIDE.CommandDataModuleUnit.pas:

1. Calls GetNodeMetadataClass to find the Delphi class
2. Reads TYamlAttributeReader.GetYamlProperties for property annotations
3. Reads TYamlAttributeReader.GetYamlChildTypes for child type annotations
4. If either returns results, builds the menu from RTTI:
   • Required scalars appear first
   • Scalar/SubNode items appear only if not already present
   • Container items always appear (can add multiple children)
   • ChildType items always appear (can add multiple instances)
5. The generic "Add Child" action is hidden when RTTI is active
6. "Delete Node" is always available

Annotated classes overview

Metadata classes

Class	File	Scalars	Containers	SubNodes	ChildTypes
TKModel	Kitto.Metadata.Models.pas	11	1 (Rules)
TKModelField	Kitto.Metadata.Models.pas	27	1 (Rules)	3 (HTMLEditor, Thumbnail, PreviewWindow)
TKModelFields	Kitto.Metadata.Models.pas				14 field types
TKRules	Kitto.Metadata.Models.pas				13 rule types
TKView	Kitto.Metadata.Views.pas	3
TKDataView	Kitto.Metadata.DataView.pas			1 (MainTable)
TKViewTable	Kitto.Metadata.DataView.pas	9	1 (Rules)	1 (Controller)
TKViewField	Kitto.Metadata.DataView.pas	26	1 (Rules)
TKLayout	Kitto.Metadata.Views.pas	9			4 (Field, FieldSet, Row, Pagebreak)
TKConfig	Kitto.Config.pas	8		5 (Server, Auth, AccessControl, UserFormats, LogTextFile)

Controller classes

Class	File	Own scalars	Inherited from
TKXPanelControllerBase	Kitto.Html.Panel.pas	10 (Title, Width, Height, ...)
TKXDataPanelController	Kitto.Html.DataPanel.pas	5 (PreventAdding, ...)	Panel
TKXListPanelController	Kitto.Html.List.pas		DataPanel
TKXFormPanelController	Kitto.Html.Form.pas	1 (Operation)	Panel
TKXTabPanelController	Kitto.Html.TabPanel.pas	2 (TabIconsVisible, TabsVisible)	Panel
TKXTilePanelController	Kitto.Html.TilePanel.pas	6 (TileWidth, ...)	Panel
TKXHtmlPanelController	Kitto.Html.HtmlPanel.pas	2 (Html, FileName)	Panel
TKXLoginPanelController	Kitto.Html.Login.pas	3 (ExtraWidth, ExtraHeight, LabelWidth)
TKXChartPanelController	Kitto.Html.ChartPanel.pas		DataPanel + Chart SubNode

Tool controller classes

Class	File	Own scalars
TKXToolController	Kitto.Html.Tools.pas	1 (DisplayLabel)
TKXDownloadFileController	Kitto.Html.Files.pas	4 (FileName, ClientFileName, ContentType, PersistentFileName)
TKXUploadFileController	Kitto.Html.Files.pas	4 (Path, AcceptedWildcards, ContentType, MaxUploadSize)
TExportTextToolController	Kitto.Tool.Export.pas	5 (IncludeHeader, FixedLength, Delimiter, QuoteChar, UseDisplayLabels)
TExportExcelToolController	Kitto.Tool.ADO.pas	3 (ExcelRangeName, TemplateFileName, UseDisplayLabels)
TFOPToolController	Kitto.Tool.FOP.pas	1 (TransformFileName)
TXSLToolController	Kitto.Tool.XSL.pas	1 (TransformFileName)

Sub-node config classes

Defined in Kitto.Metadata.SubNodes.pas and Kitto.Metadata.SubNodes2.pas:

Class	Purpose	Properties
TKHTMLEditorConfig	Rich-text toolbar options	8 boolean flags
TKThumbnailConfig	Picture thumbnail dimensions	Width, Height
TKPreviewWindowConfig	File preview popup dimensions	Width, Height
TKFilterPanelConfig	Filter panel settings	DisplayLabel, LabelWidth, Connector, Collapsed, ColumnWidth, LabelAlign
TKServerConfig	HTTP server settings	Port, SessionTimeOut, ThreadPoolSize
TKAuthConfig	Authentication	7 scalars + Defaults SubNode
TKViewTableControllerConfig	ViewTable controller	9 scalars + ToolViews, PopupWindow, Grouping, FormController SubNodes
TKToolViewsConfig	Tool views container	13 child types (DownloadCSV, UploadFile, ...)
TKToolViewItem	Single tool view item	DisplayLabel, ImageName, Controller, RequireSelection, AutoRefresh, ConfirmationMessage
TKChartConfig	Chart configuration	5 scalars + Legend, Series, Axes
TKGroupingConfig	Row grouping	5 scalars + ShowCount SubNode

How to annotate a new class

When adding a new controller or metadata class:

1. Add EF.YAML.Attributes to the interface uses clause
2. Add {$RTTI EXPLICIT PROPERTIES([vcPublic])} before the class declaration
3. For each config property, add the appropriate attribute:

{$RTTI EXPLICIT PROPERTIES([vcPublic])}
TMyController = class(TKXPanelControllerBase)
private
  function GetMyOption: Boolean;
public
  [YamlNode('MyOption', 'True', 'Enable custom option')]
  property MyOption: Boolean read GetMyOption;
end;

4. If the class is a container, add [YamlChildType] attributes before the class
5. If the class has sub-node children, add [YamlSubNode] properties pointing to the sub-node class
6. KIDE^x will automatically discover the new properties via RTTI — no template files needed

TIP

All default values in [YamlNode] must be strings, even for Boolean or Integer properties. Use 'True', 'False', '100' — not bare True, False, 100. This is because Delphi RTTI does not support Variant parameters in attribute constructors.