Text

The Text category is the Self node set of the nl.text widget: the string it shows, the typeface and metrics it shows it in, and the static effects layered on top. These nodes appear only in the palette of an nl.text element's own widgetMain blueprint, and every one of them acts on that element. To reach a different text element, use the blueprint.element.text.* node of the same name from the Element category — the same properties, plus an element:nl.text input to aim it.

Conventions

• No target pin. A Self node has no Element input; it resolves its target from the blueprint's execution owner. There is nothing to wire, and nothing to aim at the wrong element.
• Reads are Pure, writes are Latent. Every getter is side-effect free and legal in event, function and macro graphs. Every setter suspends the graph while the host applies the patch, which bars it from function graphs — a function returns synchronously to its caller and has nowhere to hold a pending write.
• Not available in a Blueprint Value. A Blueprint Value is owned by widgetValue and these nodes are scoped to widgetMain, so the getters never appear in that palette even though they are pure. To read text properties from a Blueprint Value, use the Element-targeted getters with an Element literal.
• Writes need a running game. The host API exists only under a blueprint runtime. On the editor canvas a setter fails with Host API unavailable (use Dev Mode), and a getter produces nothing at all.
• A write that changes nothing does nothing. Each setter normalizes its patch, compares it against the element's current properties, and returns early when they match — no repaint and no On Flush for that element. Getters never queue a flush either, so a graph can poll properties without driving itself in a loop.
• An unwired or unrecognised input is not "leave it alone". With no edge, nothing typed on the card, or a value outside the allowed set, most setters write a fixed fallback instead of keeping the current value: Set Text writes an empty string, Set Font clears the font, Set Font Size writes 16, Set Line Height writes 1.4, and each enum setter writes the first value of its list. Nothing is rejected and nothing throws. Only Set Text Color, Set Effects, and every pin of Set All Properties fall back to what the element already has.

Get Text

blueprint.text.getText · Pure

Reads the string the element is currently carrying.

Set Text

blueprint.text.setText · Latent

Replaces the whole string.

Append Text

blueprint.text.appendText · Latent

Reads the current string and writes it back with text on the end. Appending an empty string resolves to the same string and is therefore a no-op.

Clear Text

blueprint.text.clearText · Latent

Writes an empty string. Identical to Set Text with nothing wired, but says so on the card.

Get Font

blueprint.text.getFont · Pure

Reads the id of the project font asset the element uses.

Set Font

blueprint.text.setFont · Latent

Points the element at a project font asset.

Get Font Size

blueprint.text.getFontSize · Pure

Set Font Size

blueprint.text.setFontSize · Latent

Get Font Weight

blueprint.text.getFontWeight · Pure

Set Font Weight

blueprint.text.setFontWeight · Latent

The weight is a three-value enum, not a numeric CSS weight. 700 is not a synonym for bold here — it is outside the set, so it falls back to normal.

Get Text Color

blueprint.text.getTextColor · Pure

Set Text Color

blueprint.text.setTextColor · Latent

The element stores its colour as a CSS colour string; these pins convert in both directions, so the pin type is RGBAColor and not string.

Get Text Align

blueprint.text.getTextAlign · Pure

Set Text Align

blueprint.text.setTextAlign · Latent

Aligns the lines horizontally inside the element's box. It does not move or resize the box.

Get Text Vertical Align

blueprint.text.getTextVerticalAlign · Pure

Set Text Vertical Align

blueprint.text.setTextVerticalAlign · Latent

Distributes the lines inside the element's box. It moves the text within the box; it does not resize the box.

Get Line Height

blueprint.text.getLineHeight · Pure

Set Line Height

blueprint.text.setLineHeight · Latent

Get Wrap Mode

blueprint.text.getWrapMode · Pure

Set Wrap Mode

blueprint.text.setWrapMode · Latent

Get Effects

blueprint.text.getEffects · Pure

Reads the element's static effect block as one JSON object, always with every field present:

{
    "effectBlur": 0,
    "effectBackgroundBlur": 0,
    "effectShadow": null,
    "effectTextShadow": null,
    "effectInnerShadow": null,
    "effectBlend": "",
    "effectGlow": null,
    "effectFilter": null
}

A text element honours only effectBlur, effectTextShadow, effectBlend and effectFilter — it draws its shadow with CSS text-shadow, and the box-shadow fields belong to chrome widgets. effectShadow, effectInnerShadow and effectGlow therefore always read back as null on a text element.

Set Effects

blueprint.text.setEffects · Latent

Replaces the whole effect block — this is not a merge, so read with Get Effects and edit the object if you only mean to change one field.

Writing a box-shadow field is not silently dropped: on the next read, effectShadow (or, failing that, effectGlow) is promoted into effectTextShadow when no text shadow is set, and the box-shadow field itself comes back null. The shadow does appear, but not under the key you wrote it to.

Get All Properties

blueprint.text.getAllProperties · Pure

Every text property from one card. Each output carries exactly what its dedicated getter would return.

Set All Properties

blueprint.text.setAllProperties · Latent

Writes every text property in one patch, so the element repaints once instead of ten times. It reads the current properties first and uses them as the fallback for every pin, which makes it the one setter where leaving a pin unwired keeps the current value — the opposite of the single-property setters.

Get Visible

blueprint.text.getVisible · Pure

Set Visible

blueprint.text.setVisible · Latent

Sets the element's visible property. This is not the same switch as Set Display in the Displayable category: display is the runtime render switch that hides the element and its subtree with CSS while keeping them mounted, whereas visible is the layout visibility property the inspector exposes.

Get Enabled

blueprint.text.getEnabled · Pure

Set Enabled

blueprint.text.setEnabled · Latent

false maps onto the underlying interaction-disable mechanism; the raw interactionDisabled property is not exposed to authors, so this pair is the whole interface.