Class Component

java.lang.Object
vaadinx.awt.Component
All Implemented Interfaces:
ImageObserver, MenuContainer, Serializable
Direct Known Subclasses:
Button, Checkbox, Choice, Container, Label, List, Scrollbar
public abstract class Component extends Object implements ImageObserver, MenuContainer, Serializable
Emulator for Component.
See Also:

  • Field Details

  • Constructor Details

    • Component

      protected Component()

    • Component

      protected Component(com.vaadin.flow.component.Component peer)
      Peers on peer, built by the caller: the eager form, which every emulator not yet made lazy uses.

    • Component

      protected <P extends com.vaadin.flow.component.Component> Component(Class<P> peerType, Supplier<? extends P> peerFactory)
      Peers on a peerType that peerFactory builds only once a UI is current — at the first write that has one, or at the attach that drains the writes made before it (D_lazy_peers). So an emulator constructed and configured on a worker runs no Vaadin code there at all.
      Parameters:
      peerType - what peerFactory returns, which answers the type checks made before the peer exists

  • Method Details

    • getPeer

      public final com.vaadin.flow.component.Component getPeer()
      The Vaadin component backing this emulator — the only way to reach it, from inside SB-Emulators and out. The peer concept is already a public architectural seam (per CLAUDE.md / architecture.md): Karibu reaches it, tests assert on it, and a migrator drops an emulator into a vanilla Vaadin layout through it.

      It is also the emulator→peer chokepoint EHelper.checkUIThread() hangs off: every route through this accessor reports, once per JVM, if it is running off the Vaadin UI thread. Behaviour is unchanged — the check only logs — but it is why peer is private rather than protected, which is what makes the chokepoint hold for emulator methods not yet written.

      With a UI current, a lazy emulator's peer is built if it does not exist yet, and writes withPeer(Consumer) queued while the peer had no UI are drained first, so the peer handed back carries them — which is also what makes a parent's parentPeer.add(child.getPeer()) the write that builds and drains the child.

      toString() deliberately reads the field instead, since logging a component must never itself warn or build anything.

    • withPeer

      public final void withPeer(Consumer<com.vaadin.flow.component.Component> body)
      Runs body against this component's peer, under its session's lock and with a UI current — the seam every emulator peer write goes through, since any of them may arrive from a background thread (R_tolerate_off_ui_thread). Inline or through a synchronous hop when a UI is reachable; otherwise queued, and run in order once one is — see PeerWriteQueue. A queued body must be a pure sink.

      Public because code outside the component hierarchy needs it too — a layout manager, the drag-and-drop wiring, and a migrator's own worker that wants to touch the peer safely.

      Why this and not getPeer(). A thread hop has to wrap the mutation, and an accessor returns before the mutation happens: a hopping getPeer() would take the lock, hand back the peer, release, and let the caller mutate off-thread anyway. So getPeer() can never carry a threading strategy and this can — which is the whole reason the two exist side by side. Reads stay on getPeer(), where a hop would buy nothing.

      Wrap one Swing method's worth of peer work per call, not one DOM write: each call is its own trip through the seam, so a body setting three styles belongs in one withPeer rather than three. Nested calls are free.

    • withPeerOnLiveUI

      protected final void withPeerOnLiveUI(boolean callerPlansToBlockAfterwards, Consumer<com.vaadin.flow.component.Component> body)
      withPeer(Consumer), which now gives every body a current UI, a body needing one while the peer is detached included. Every caller passes false; a window show goes through EHelper.runInUIThread(boolean, Runnable) itself.

    • awtListeners

      protected final <T extends EventListener> T[] awtListeners(Class<T> type)
      The stored listeners of type in AWT dispatch order — first-registered-first, which is the reverse of what EventListenerList yields.
      Type Parameters:
      T - an AWT listener type. Swing listener types must not come through here: AWTEventMulticaster dispatches first-registered-first while Swing's list is last-first, and each convention is correct for its own half of the JDK.
      Returns:
      a fresh array, reversed in place; iterate it rather than re-reading the list, so in-dispatch listener mutation stays safe

    • peerIs

      protected final boolean peerIs(Class<?> type)
      Whether the peer is, or will be, a type: answers without building it, so an emulator can branch on its peer's kind outside a write.

    • getName

      public String getName()

    • remove

      public void remove(MenuComponent popup)
      Specified by:
      remove in interface MenuContainer

    • size

      public Dimension size()

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • update

      public void update(Graphics g)

    • add

      public void add(PopupMenu popup)

    • contains

      public boolean contains(Point p)

    • contains

      public boolean contains(int x, int y)

    • list

      public void list()

    • list

      public void list(PrintStream out)

    • list

      public void list(PrintStream out, int indent)

    • list

      public void list(PrintWriter out)

    • list

      public void list(PrintWriter out, int indent)

    • getBounds

      public Rectangle getBounds(Rectangle rv)

    • getBounds

      public Rectangle getBounds()

    • validate

      public void validate()

    • bounds

      public Rectangle bounds()

    • location

      public Point location()

    • getLocation

      public Point getLocation(Point rv)

    • getLocation

      public Point getLocation()

    • getParent

      public Container getParent()

    • isEnabled

      public boolean isEnabled()

    • setName

      public void setName(String name)

    • print

      public void print(Graphics g)

    • action

      @Deprecated public boolean action(Event evt, Object what)
      Deprecated.

    • getSize

      public Dimension getSize()

    • getSize

      public Dimension getSize(Dimension rv)

    • paramString

      protected String paramString()

    • isOpaque

      public boolean isOpaque()

    • resize

      public void resize(Dimension d)

    • resize

      public void resize(int width, int height)

    • enable

      public void enable()

    • enable

      public void enable(boolean b)

    • invalidate

      public void invalidate()

    • isValid

      public boolean isValid()

    • move

      public void move(int x, int y)

    • getLocale

      public Locale getLocale()

    • setLocale

      public void setLocale(Locale l)

    • setSize

      public void setSize(Dimension d)

    • setSize

      public void setSize(int width, int height)

    • getTreeLock

      public final Object getTreeLock()

    • firePropertyChange

      protected void firePropertyChange(String propertyName, int oldValue, int newValue)

    • firePropertyChange

      protected void firePropertyChange(String propertyName, boolean oldValue, boolean newValue)

    • firePropertyChange

      protected void firePropertyChange(String propertyName, Object oldValue, Object newValue)

    • firePropertyChange

      public void firePropertyChange(String propertyName, float oldValue, float newValue)

    • firePropertyChange

      public void firePropertyChange(String propertyName, long oldValue, long newValue)

    • firePropertyChange

      public void firePropertyChange(String propertyName, char oldValue, char newValue)

    • firePropertyChange

      public void firePropertyChange(String propertyName, double oldValue, double newValue)

    • firePropertyChange

      public void firePropertyChange(String propertyName, byte oldValue, byte newValue)

    • firePropertyChange

      public void firePropertyChange(String propertyName, short oldValue, short newValue)

    • removeNotify

      public void removeNotify()

    • addNotify

      public void addNotify()

    • getToolkit

      public Toolkit getToolkit()

    • setLocation

      public void setLocation(int x, int y)

    • setLocation

      public void setLocation(Point p)

    • getLocationOnScreen

      public Point getLocationOnScreen()

    • isShowing

      public boolean isShowing()

    • setEnabled

      public void setEnabled(boolean b)

    • disable

      public void disable()

    • isFocusOwner

      public boolean isFocusOwner()

    • isLightweight

      public boolean isLightweight()

    • transferFocus

      public void transferFocus()
      Moves focus to the next focusable component, exactly as AWT does: by asking the current KeyboardFocusManager. The traversal order and its divergences are documented on KeyboardFocusManager.focusNextComponent(Component).

    • getInputContext

      public InputContext getInputContext()

    • dispatchEvent

      public final void dispatchEvent(AWTEvent e)

    • setVisible

      public void setVisible(boolean b)

    • show

      public void show(boolean b)

    • show

      public void show()

    • applyVisibleToPeer

      protected void applyVisibleToPeer(boolean b)
      Where the JDK calls peer.setVisible(...) from show() / hide(). Split out because a Window's peer is not simply shown and hidden — it is attached to a route or opened as an overlay — so Window substitutes its own peer work here rather than duplicating the surrounding state machine.

      Every Vaadin Component has setVisible, so no HasVisible check is needed (unlike setEnabled), and Vaadin's false removes the element from the DOM — which is Swing's "invisible component takes no space" contract.

    • repaint

      public void repaint(int x, int y, int width, int height)

    • repaint

      public void repaint()

    • repaint

      public void repaint(long tm)

    • repaint

      public void repaint(long tm, int x, int y, int width, int height)

    • postEvent

      @Deprecated public boolean postEvent(Event e)
      Deprecated.
      Specified by:
      postEvent in interface MenuContainer

    • hide

      public void hide()

    • getForeground

      public Color getForeground()

    • setForeground

      public void setForeground(Color c)

    • isThemeDefault

      protected static boolean isThemeDefault(Color c)
      Whether c is a colour the theme owns rather than one the app asked for — the discriminator of D_theme_is_lookandfeel.

      Two kinds qualify, and both are the JDK's own vocabulary for "this is a default":

      • UIResource — what a L&F installs, and what LookAndFeel.installColorsAndFont is willing to overwrite.
      • SystemColor — the AWT-era spelling of the same idea. It needs naming separately because it is final and cannot implement the marker, so javac rejects an instanceof UIResource test against it outright.

      Deliberately not value-equality against the table: a ColorUIResource equals a plain Color of the same RGB, so comparing values cannot tell a default from a migrator who really did ask for #EEEEEE. The marker can.

    • getBackground

      public Color getBackground()

    • setBackground

      public void setBackground(Color c)

    • applyBackgroundToPeer

      protected void applyBackgroundToPeer()
      Push the current background to the peer, per D_theme_is_lookandfeel's three-way rule. Split out of setBackground(Color) because setOpaque has to re-run exactly this decision: the gate is two-directional, so neither setter can be the only one that evaluates it.

      An app-set colour is written inline, which is what makes it outrank the theme — the CSS cascade is the priority mechanism, so no precedence machinery of our own is needed. A theme default writes nothing here; the class-based default fill is a separate concern.

    • defaultFillCssClass

      protected String defaultFillCssClass()
      Which SB-Emulators-supplied fill this component takes when its background is an L&F default, or null when it needs none.

      The answer is a property of the peer, not a list of class names, so a new emulator inherits the right behaviour from the element it peers on with nobody having to remember to add it: HtmlContainer is Flow's base for plain HTML elements that paint nothing of their own, so those fill; a themed vaadin-* widget paints its own surface and needs no default.

      Two peers escape the predicate and are named here rather than left to be rediscovered. Scroller is not an HtmlContainer but is a transparent overflow container, and both JScrollPane and java.awt.ScrollPane are opaque under Metal. MenuBar the predicate would exempt, but its host computes to fully transparent — so a Swing menu bar would lose its chrome entirely — and it reads as a raised strip rather than as page surface, hence the chrome tint.

      Filling an inert peer — a JViewport, a JScrollBar, a menu item's bookkeeping Span — needs no exemption: the element is never rendered, so the fill is a no-op.

    • getFont

      public Font getFont()
      Specified by:
      getFont in interface MenuContainer

    • setFont

      public void setFont(Font f)

    • getColorModel

      public ColorModel getColorModel()

    • setBounds

      public void setBounds(Rectangle r)

    • setBounds

      public void setBounds(int x, int y, int width, int height)

    • reshape

      public void reshape(int x, int y, int width, int height)

    • getX

      public int getX()

    • getY

      public int getY()

    • getWidth

      public int getWidth()

    • getHeight

      public int getHeight()

    • preferredSize

      public Dimension preferredSize()

    • isPreferredSizeSet

      public boolean isPreferredSizeSet()

    • getPreferredSize

      public Dimension getPreferredSize()

    • getMinimumSize

      public Dimension getMinimumSize()

    • minimumSize

      public Dimension minimumSize()

    • isMinimumSizeSet

      public boolean isMinimumSizeSet()

    • isMaximumSizeSet

      public boolean isMaximumSizeSet()

    • layout

      public void layout()

    • getGraphics

      public Graphics getGraphics()

    • paint

      public void paint(Graphics g)

    • isVisible

      public boolean isVisible()

    • createImage

      public Image createImage(int width, int height)

    • createImage

      public Image createImage(ImageProducer producer)

    • createVolatileImage

      public VolatileImage createVolatileImage(int width, int height, ImageCapabilities caps) throws AWTException
      Throws:
      AWTException

    • createVolatileImage

      public VolatileImage createVolatileImage(int width, int height)

    • prepareImage

      public boolean prepareImage(Image image, ImageObserver observer)

    • prepareImage

      public boolean prepareImage(Image image, int width, int height, ImageObserver observer)

    • checkImage

      public int checkImage(Image image, ImageObserver observer)

    • checkImage

      public int checkImage(Image image, int width, int height, ImageObserver observer)

    • inside

      public boolean inside(int x, int y)

    • locate

      public Component locate(int x, int y)

    • getComponentAt

      public Component getComponentAt(Point p)

    • getComponentAt

      public Component getComponentAt(int x, int y)

    • processEvent

      protected void processEvent(AWTEvent e)

    • handleEvent

      @Deprecated public boolean handleEvent(Event evt)
      Deprecated.

    • getListeners

      public <T extends EventListener> T[] getListeners(Class<T> listenerType)

    • getPropertyChangeListeners

      public PropertyChangeListener[] getPropertyChangeListeners(String propertyName)

    • getPropertyChangeListeners

      public PropertyChangeListener[] getPropertyChangeListeners()

    • coalesceEvents

      protected AWTEvent coalesceEvents(AWTEvent existingEvent, AWTEvent newEvent)

    • fireComponentEvent

      protected void fireComponentEvent(int id)

    • fireHierarchyEvent

      protected void fireHierarchyEvent(int id, Component changed, Container changedParent, long flags)
      Fires a HierarchyEvent on this component. Container overrides to also recurse into descendants — AWT semantics for PARENT_CHANGED / DISPLAYABILITY_CHANGED / SHOWING_CHANGED, where the entire reparented subtree observes the change.

    • processComponentEvent

      protected void processComponentEvent(ComponentEvent e)

    • processFocusEvent

      protected void processFocusEvent(FocusEvent e)

    • processKeyEvent

      protected void processKeyEvent(KeyEvent e)

    • processMouseEvent

      protected void processMouseEvent(MouseEvent e)

    • processMouseMotionEvent

      protected void processMouseMotionEvent(MouseEvent e)

    • processMouseWheelEvent

      protected void processMouseWheelEvent(MouseWheelEvent e)

    • processInputMethodEvent

      protected void processInputMethodEvent(InputMethodEvent e)

    • processHierarchyEvent

      protected void processHierarchyEvent(HierarchyEvent e)

    • processHierarchyBoundsEvent

      protected void processHierarchyBoundsEvent(HierarchyEvent e)

    • mouseEnter

      @Deprecated public boolean mouseEnter(Event evt, int x, int y)
      Deprecated.

    • mouseExit

      @Deprecated public boolean mouseExit(Event evt, int x, int y)
      Deprecated.

    • mouseMove

      @Deprecated public boolean mouseMove(Event evt, int x, int y)
      Deprecated.

    • mouseDown

      @Deprecated public boolean mouseDown(Event evt, int x, int y)
      Deprecated.

    • mouseDrag

      @Deprecated public boolean mouseDrag(Event evt, int x, int y)
      Deprecated.

    • mouseUp

      @Deprecated public boolean mouseUp(Event evt, int x, int y)
      Deprecated.

    • keyDown

      @Deprecated public boolean keyDown(Event evt, int key)
      Deprecated.

    • keyUp

      @Deprecated public boolean keyUp(Event evt, int key)
      Deprecated.

    • gotFocus

      @Deprecated public boolean gotFocus(Event evt, Object what)
      Deprecated.

    • lostFocus

      @Deprecated public boolean lostFocus(Event evt, Object what)
      Deprecated.

    • isFocusTraversable

      @Deprecated public boolean isFocusTraversable()
      Deprecated.
      Deprecated AWT 1.1 predecessor of isFocusable(); same answer.

    • getFocusTraversalKeys

      public Set<AWTKeyStroke> getFocusTraversalKeys(int id)

    • requestFocus

      public void requestFocus()

    • requestFocus

      protected boolean requestFocus(boolean temporary)
      The legacy "temporary focus" overload. Our peers can't distinguish temporary from permanent focus (the browser has no such concept), so this is the no-arg variant.
      Returns:
      whether the request reached the peer, not whether the browser accepted it

    • isFocusable

      public boolean isFocusable()

    • isFocusCycleRoot

      public boolean isFocusCycleRoot(Container container)

    • getFocusCycleRootAncestor

      public Container getFocusCycleRootAncestor()

    • nextFocus

      @Deprecated public void nextFocus()
      Deprecated.
      Deprecated AWT 1.1 alias for transferFocus().

    • requestFocusInWindow

      public boolean requestFocusInWindow()

    • requestFocusInWindow

      protected boolean requestFocusInWindow(boolean temporary)

    • transferFocusBackward

      public void transferFocusBackward()

    • hasFocus

      public boolean hasFocus()
      Same answer as isFocusOwner(). AWT's split is about temporary focus loss, which the browser does not model — so a component either owns focus or does not.

    • addPropertyChangeListener

      public void addPropertyChangeListener(PropertyChangeListener listener)

    • addPropertyChangeListener

      public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener)

    • removePropertyChangeListener

      public void removePropertyChangeListener(PropertyChangeListener listener)

    • removePropertyChangeListener

      public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener)

    • addComponentListener

      public void addComponentListener(ComponentListener l)

    • addFocusListener

      public void addFocusListener(FocusListener l)
      Registers the listener and, on the first one, subscribes to the peer's focus/blur events so FOCUS_GAINED / FOCUS_LOST actually arrive (installFocusBridge()).

    • suppressMouseBridge

      protected final void suppressMouseBridge()
      Declares that this subclass sources its own MOUSE_* events, so installMouseBridge() must stay out of the way.

      Call from the constructor, before any listener can be registered.

      For JList / JTable / JTree, which re-source their surrogate's Grid item-click wire. Those wires are not redundant with this bridge — each reports the clicked row/index, held so rowAtPoint / locationToIndex can answer during the dispatch (D_jlist, D_jtree) — so they stay, and the generic bridge yields rather than delivering every click twice.

    • addKeyListener

      public void addKeyListener(KeyListener l)

    • addMouseListener

      public void addMouseListener(MouseListener l)
      Registers the listener and, on the first one, subscribes to the peer's DOM mouse events so all five callbacks actually arrive (installMouseBridge()).

    • addMouseMotionListener

      public void addMouseMotionListener(MouseMotionListener l)
      Stores the listener; mouseMoved / mouseDragged never fire.

      Tracking the pointer needs a mousemove subscription, i.e. a server round trip per pixel of travel. Declined as a capability (R_match_swing_errors sub-bucket (b)), and WARNed here at *registration* rather than silently — addMouseListener(MouseListener)'s five callbacks are fully wired, so the honest split falls exactly on the listener-interface boundary. The listener is still stored, so getMouseMotionListeners() answers truthfully (R_decline_effect_only drops the effect, not the state).

    • addInputMethodListener

      public void addInputMethodListener(InputMethodListener l)

    • addHierarchyListener

      public void addHierarchyListener(HierarchyListener l)

    • addHierarchyBoundsListener

      public void addHierarchyBoundsListener(HierarchyBoundsListener l)

    • addMouseWheelListener

      public void addMouseWheelListener(MouseWheelListener l)
      Stores the listener; mouseWheelMoved never fires.

      Same reasoning and same registration-time WARN as addMouseMotionListener(MouseMotionListener): a wheel subscription is a round trip per notch, and the browser owns scrolling anyway.

    • setComponentOrientation

      public void setComponentOrientation(ComponentOrientation o)

    • isDisplayable

      public boolean isDisplayable()

    • getAccessibleContext

      public AccessibleContext getAccessibleContext()

    • setDropTarget

      public void setDropTarget(DropTarget dt)
      The low-level java.awt.dnd path is declined whole (D_dnd_transferhandler_only) — SB-Emulators' drag-and-drop runs through vaadinx.swing.TransferHandler — so what a stored target buys is its own getter, and nothing more. AWT's registration limb is not merely declined but impossible: dt.setComponent(this) wants a java.awt.Component and this is not one.

    • getDropTarget

      public DropTarget getDropTarget()

    • getGraphicsConfiguration

      public GraphicsConfiguration getGraphicsConfiguration()
      Returns:
      the browser viewport's configuration — never null, unlike AWT's, which answers null until the component has a peer

    • getMousePosition

      public Point getMousePosition() throws HeadlessException
      Throws:
      HeadlessException

    • isDoubleBuffered

      public boolean isDoubleBuffered()

    • enableInputMethods

      public void enableInputMethods(boolean enable)

    • isForegroundSet

      public boolean isForegroundSet()

    • isBackgroundSet

      public boolean isBackgroundSet()

    • isFontSet

      public boolean isFontSet()

    • setPreferredSize

      public void setPreferredSize(Dimension preferredSize)

    • setMinimumSize

      public void setMinimumSize(Dimension minimumSize)

    • setMaximumSize

      public void setMaximumSize(Dimension maximumSize)

    • getMaximumSize

      public Dimension getMaximumSize()

    • getAlignmentX

      public float getAlignmentX()

    • getAlignmentY

      public float getAlignmentY()

    • getBaseline

      public int getBaseline(int width, int height)

    • doLayout

      public void doLayout()

    • revalidate

      public void revalidate()

    • getFontMetrics

      public FontMetrics getFontMetrics(Font font)

    • setCursor

      public void setCursor(Cursor cursor)

    • getCursor

      public Cursor getCursor()

    • isCursorSet

      public boolean isCursorSet()

    • paintAll

      public void paintAll(Graphics g)

    • printAll

      public void printAll(Graphics g)

    • imageUpdate

      public boolean imageUpdate(Image img, int infoflags, int x, int y, int w, int h)
      Specified by:
      imageUpdate in interface ImageObserver

    • setIgnoreRepaint

      public void setIgnoreRepaint(boolean ignoreRepaint)

    • getIgnoreRepaint

      public boolean getIgnoreRepaint()

    • deliverEvent

      @Deprecated public void deliverEvent(Event e)
      Deprecated.

    • removeComponentListener

      public void removeComponentListener(ComponentListener l)

    • getComponentListeners

      public ComponentListener[] getComponentListeners()

    • removeFocusListener

      public void removeFocusListener(FocusListener l)

    • getFocusListeners

      public FocusListener[] getFocusListeners()

    • removeHierarchyListener

      public void removeHierarchyListener(HierarchyListener l)

    • getHierarchyListeners

      public HierarchyListener[] getHierarchyListeners()

    • removeHierarchyBoundsListener

      public void removeHierarchyBoundsListener(HierarchyBoundsListener l)

    • getHierarchyBoundsListeners

      public HierarchyBoundsListener[] getHierarchyBoundsListeners()

    • removeKeyListener

      public void removeKeyListener(KeyListener l)

    • getKeyListeners

      public KeyListener[] getKeyListeners()

    • removeMouseListener

      public void removeMouseListener(MouseListener l)

    • getMouseListeners

      public MouseListener[] getMouseListeners()

    • removeMouseMotionListener

      public void removeMouseMotionListener(MouseMotionListener l)

    • getMouseMotionListeners

      public MouseMotionListener[] getMouseMotionListeners()

    • removeMouseWheelListener

      public void removeMouseWheelListener(MouseWheelListener l)

    • getMouseWheelListeners

      public MouseWheelListener[] getMouseWheelListeners()

    • removeInputMethodListener

      public void removeInputMethodListener(InputMethodListener l)

    • getInputMethodListeners

      public InputMethodListener[] getInputMethodListeners()

    • getInputMethodRequests

      public InputMethodRequests getInputMethodRequests()

    • enableEvents

      protected final void enableEvents(long eventsToEnable)
      Deliberate no-op: every mask this could enable is already enabled.

      Not a gap, so not a WARN. AWT's eventMask exists to let processEvent *skip* a category no one asked for; Window.processEvent(AWTEvent) dispatches unconditionally, which satisfies any request this method could carry. Called from JFrame.frameInit / JDialog.dialogInit to keep the JDK's call graph (R_no_vaadin_in_api limb 2) — though the edge buys shape rather than reachability, final being unoverridable here as in the JDK. Contrast disableEvents(long).

    • disableEvents

      protected final void disableEvents(long eventsToDisable)
      WARNs where enableEvents(long) no-ops, and the asymmetry is the point: unconditional dispatch grants every *enable* request and honours no *disable* one. A migrator muting a category here keeps receiving it.

    • setFocusable

      public void setFocusable(boolean focusable)
      Stores the flag, fires AWT's "focusable" PCE, and thereby takes this component out of (or back into) focus traversal.

      Deliberately not pushed to the peer as a tabindex rewrite — the browser's Tab order stays the browser's, per the traversal-order divergence on KeyboardFocusManager.focusNextComponent(Component). So a non-focusable component is still Tab-reachable in the browser.

    • setFocusTraversalKeys

      public void setFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes)

    • areFocusTraversalKeysSet

      public boolean areFocusTraversalKeysSet(int id)

    • setFocusTraversalKeysEnabled

      public void setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled)
      Stores the flag and fires "focusTraversalKeysEnabled"; Tab is not intercepted either way. AWT's traversal keys are consumed inside its key dispatch pipeline, which is permanently out of scope (D_focus_managers) — the browser moves focus on Tab and there is no seam at which to suppress that from the server. State and notification are owed regardless (R_decline_effect_only, D_owed_events).

    • getFocusTraversalKeysEnabled

      public boolean getFocusTraversalKeysEnabled()
      Returns:
      what setFocusTraversalKeysEnabled(boolean) stored; AWT's default is true

    • transferFocusUpCycle

      public void transferFocusUpCycle()

    • getComponentOrientation

      public ComponentOrientation getComponentOrientation()

    • applyComponentOrientation

      public void applyComponentOrientation(ComponentOrientation orientation)

    • setMixingCutoutShape

      public void setMixingCutoutShape(Shape shape)