Package limn.components

Class SearchField

java.lang.Object
limn.scene.Widget<TextField>
limn.components.TextField
limn.components.SearchField
public final class SearchField extends TextField
A TextField preset for search: a leading magnifier icon inside the field and a trailing coupled clear button (the ComboBox-caret idiom). Enter fires onSubmit(java.util.function.Consumer<java.lang.String>); the clear button empties the field.

  • Constructor Details

    • SearchField

      public SearchField()
      A field with a search icon, a clear button and a localized placeholder.

  • Method Details

    • onSubmit

      public SearchField onSubmit(@Nullable Consumer<String> listener)
      The application's response to the user pressing Enter, or an assistive technology's press: called with the current query. TextField.onSubmit, under this class's type; unlike a plain field, a search field takes Enter whether or not a handler is registered.
      Overrides:
      onSubmit in class TextField
      Parameters:
      listener - the handler, or null to clear the slot
      Returns:
      this field
      Throws:
      IllegalStateException - if a handler is already registered

    • clear

      public void clear()
      Empties the field: a caller's write, announced as one TEXT edit at CODE and reaching no handler. The trailing button empties it as the user's, through the same seam, so onChange hears the button and not this. UI thread only.

    • onKeyEvent

      protected void onKeyEvent(KeyEvent event)
      Description copied from class: Widget
      Key events (focused widget first, then ancestors).
      Overrides:
      onKeyEvent in class TextField

    • onAccessibility

      protected void onAccessibility(Accessibility a)
      The same node TextField publishes, said to be a search field and offering the one verb this class adds to it.

      The role is written after the super call and cannot move before it. A role is a plain write to the node's slot, so the last one wins, and the field's own hook writes TEXT_FIELD into it; a subclass that declared its role first would publish a search field as a plain one. That it lands on this widget's node rather than on the trailing button's is the other half of the same ordering, and rests on the super hook closing every synthetic child it opened.

      Everything else a reader hears here is inherited and is deliberately not restated: the contents with the caret and the selection, EDITABLE, the context menu, and the trailing button as a child node. What this class contributes to that button is its name, given in the constructor, and not a node of its own — the button is the field's generic trailing region and declaring a second one would publish it twice.

      The name needs no line at all: it is the placeholder the constructor installs, which makes this the one widget in the toolkit that arrives already named with no application involvement. It is the placeholder whether or not there is anything typed in the field — conditioning it on emptiness would rename the node on the first keystroke and rename it back on the last backspace — and because the node always has a name, a tooltip on a search field becomes its description instead.

      Nothing is derived here and nothing may be: both statements are constants, so a field whose caret is blinking spends no memory concluding that nothing about it has moved.

      Overrides:
      onAccessibility in class TextField
      Parameters:
      a - the node being described; write into it, and never keep it

    • onAccessibilityAction

      protected boolean onAccessibilityAction(Accessible.Action action, Accessible.Argument arg)
      Runs the search, through the same body Enter reaches.

      Everything else goes to super, and that clause is the one this class cannot do without. A search field is still a text field: the whole-value set an assistive technology is promised on every text control, the caret and selection verbs and the context menu are all the base class's, and a subclass that swallowed them to answer one verb of its own would be the single text widget in the toolkit a reader cannot write into.

      The enabled check is here and not in submit(). The key path is gated by the scene's own dispatch and never travels this way, and the dispatcher has already walked this widget and its ancestors; this is the same restatement the other action hooks in the toolkit carry, and it belongs to the door rather than to the room.

      Overrides:
      onAccessibilityAction in class TextField
      Parameters:
      action - what is being asked
      arg - the argument, which this verb does not take
      Returns:
      whether this widget did it