# Selector

> Registered options over one point, as keys or a list, showing which one the plant is actually in.

**Selector** offers the operator a closed set of registered choices — an operating
mode, a recipe, a speed step — over one writable point. Picking one writes that
option's value; the same point read back is what lights the active option. That
read-back is the whole reason the kind exists: a row of [Buttons](component-button)
each writing a fixed value writes just as well and shows nothing. It is a *Control*
component; a new one occupies 5 × 1 cells.

## Data {#data}

| Field | What it does | Values | Default |
|---|---|---|---|
| Address | The rooted Logic address the choice is written to and read back from: a memory variable or a writable tag. The list is narrowed to points that can actually be written. | Free text; writable-point suggestions | empty |

## Options {#options}

| Field | What it does | Values | Default |
|---|---|---|---|
| Shows | How the options are offered: one key per option, side by side, every choice readable at once — or a list that opens on demand, for a cell with no room for a row of keys. | `A key per option` · `A list that opens` | `A key per option` |

Each option is one card holding the two things an option *is*:

| Field | What it does | Values | Default |
|---|---|---|---|
| text | The word the operator reads on the key or in the list. Blank falls back to the value itself, because a key with nothing on it says nothing. | Free text | empty |
| value | The value written when this option is picked, and the reading that shows it active. It is a code, matched exactly: what lies between two codes is not a choice. | Any number | empty (declares nothing until typed) |

The order of the cards is the order of the keys under the operator's hand — the move
up / move down arrows reorder; nothing here sorts itself. Two options naming the same
value cannot both draw a key (the point could report only one of them, and the control
could not say which); the panel says so and the duplicate draws nothing.

All keys share one type size, reserved from the widest registered word, so the row
reads as one control rather than a row of unrelated keys. A Selector with no options
says "No options registered." instead of drawing an empty row that looks like a screen
still loading.

## What lights, and when {#what-lights-and-when}

The lit key (or the list's selection) is the point's own reading, never the click:

| Situation | The control shows |
|---|---|
| The point reports a registered value | That option lit, or selected in the list |
| The point reports a value no option registers | Nothing lit — the nearest key lighting up would be the screen inventing the plant's mode |
| The point is not reading | Nothing lit, and the component wears the shared bad-reading mark |

A pick asks for no reading first — the option carries an absolute value — so bad
quality leaves the control *usable* while taking the indication away.

## Write semantics {#write-semantics}

Picking an option writes its value through the station's single logic funnel, under the
same authorization every command passes. A point that cannot hold a number refuses the
write with the reason on the control's answer line ("This point holds text, so 2 is not
a value it takes."); a successful pick answers with the option's word ("Auto written").
The answer line expires after a few seconds, and authorization is re-checked at every
pick.

## Permissions and the lock {#permissions-and-the-lock}

Operating the Selector needs the role permission to operate dashboards. A blocked
press disables the keys and draws the shared lock mark with the reason in the
component's tooltip (see the [dashboards page](home)).

The shared Appearance, Identification, Position and layer and Actions sections are
described on the [components page](components#the-shared-property-sections).