https://openjdk.java.net/ 
/*
 * Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.awt;

import java.awt.AWTException;
import java.awt.Button;
import java.awt.Canvas;
import java.awt.Checkbox;
import java.awt.CheckboxMenuItem;
import java.awt.Choice;
import java.awt.Component;
import java.awt.Desktop;
import java.awt.Dialog;
import java.awt.FileDialog;
import java.awt.Frame;
import java.awt.GraphicsDevice;
import java.awt.HeadlessException;
import java.awt.Label;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.Panel;
import java.awt.PopupMenu;
import java.awt.ScrollPane;
import java.awt.Scrollbar;
import java.awt.Taskbar;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.Window;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.InvalidDnDOperationException;
import java.awt.dnd.peer.DragSourceContextPeer;
import java.awt.peer.ButtonPeer;
import java.awt.peer.CanvasPeer;
import java.awt.peer.CheckboxMenuItemPeer;
import java.awt.peer.CheckboxPeer;
import java.awt.peer.ChoicePeer;
import java.awt.peer.DesktopPeer;
import java.awt.peer.DialogPeer;
import java.awt.peer.FileDialogPeer;
import java.awt.peer.FontPeer;
import java.awt.peer.FramePeer;
import java.awt.peer.LabelPeer;
import java.awt.peer.LightweightPeer;
import java.awt.peer.ListPeer;
import java.awt.peer.MenuBarPeer;
import java.awt.peer.MenuItemPeer;
import java.awt.peer.MenuPeer;
import java.awt.peer.MouseInfoPeer;
import java.awt.peer.PanelPeer;
import java.awt.peer.PopupMenuPeer;
import java.awt.peer.RobotPeer;
import java.awt.peer.ScrollPanePeer;
import java.awt.peer.ScrollbarPeer;
import java.awt.peer.TaskbarPeer;
import java.awt.peer.TextAreaPeer;
import java.awt.peer.TextFieldPeer;
import java.awt.peer.WindowPeer;

import sun.awt.datatransfer.DataTransferer;

final class LightweightPeerHolder {
    static final LightweightPeer lightweightMarker = new NullComponentPeer();

    private LightweightPeerHolder() {
    }
}


Interface for component creation support in toolkits.

/**
 * Interface for component creation support in toolkits.
 */
public interface ComponentFactory {

    
Creates a peer for a component or container. This peer is windowless and
allows the Component and Container classes to be extended directly to
create windowless components that are defined entirely in java.

Params:
  • target – The Component to be created
Returns:the peer for the specified component
/**
     * Creates a peer for a component or container. This peer is windowless and
     * allows the Component and Container classes to be extended directly to
     * create windowless components that are defined entirely in java.
     *
     * @param  target The Component to be created
     * @return the peer for the specified component
     */
    default LightweightPeer createComponent(Component target) {
        return LightweightPeerHolder.lightweightMarker;
    }

    
Creates this toolkit's implementation of the Desktop using the specified peer interface. 
Params:
  • target – the desktop to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of the Desktop
Since:1.6
/**
     * Creates this toolkit's implementation of the {@code Desktop} using the
     * specified peer interface.
     *
     * @param  target the desktop to be implemented
     * @return this toolkit's implementation of the {@code Desktop}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Desktop
     * @see java.awt.peer.DesktopPeer
     * @since 1.6
     */
    default DesktopPeer createDesktopPeer(Desktop target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of the Taskbar using the specified peer interface. 
Params:
  • target – the taskbar to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of the Taskbar
Since:9
/**
     * Creates this toolkit's implementation of the {@code Taskbar} using the
     * specified peer interface.
     *
     * @param  target the taskbar to be implemented
     * @return this toolkit's implementation of the {@code Taskbar}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Taskbar
     * @see java.awt.peer.TaskbarPeer
     * @since 9
     */
    default TaskbarPeer createTaskbarPeer(Taskbar target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Button using the specified peer interface. 
Params:
  • target – the button to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Button
/**
     * Creates this toolkit's implementation of {@code Button} using the
     * specified peer interface.
     *
     * @param  target the button to be implemented
     * @return this toolkit's implementation of {@code Button}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Button
     * @see java.awt.peer.ButtonPeer
     */
    default ButtonPeer createButton(Button target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of TextField using the specified peer interface. 
Params:
  • target – the text field to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of TextField
/**
     * Creates this toolkit's implementation of {@code TextField} using the
     * specified peer interface.
     *
     * @param  target the text field to be implemented
     * @return this toolkit's implementation of {@code TextField}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.TextField
     * @see java.awt.peer.TextFieldPeer
     */
    default TextFieldPeer createTextField(TextField target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Label using the specified peer interface. 
Params:
  • target – the label to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Label
/**
     * Creates this toolkit's implementation of {@code Label} using the
     * specified peer interface.
     *
     * @param  target the label to be implemented
     * @return this toolkit's implementation of {@code Label}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Label
     * @see java.awt.peer.LabelPeer
     */
    default LabelPeer createLabel(Label target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of List using the specified peer interface. 
Params:
  • target – the list to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of List
/**
     * Creates this toolkit's implementation of {@code List} using the specified
     * peer interface.
     *
     * @param  target the list to be implemented
     * @return this toolkit's implementation of {@code List}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.List
     * @see java.awt.peer.ListPeer
     */
    default ListPeer createList(java.awt.List target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Checkbox using the specified peer interface. 
Params:
  • target – the check box to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Checkbox
/**
     * Creates this toolkit's implementation of {@code Checkbox} using the
     * specified peer interface.
     *
     * @param  target the check box to be implemented
     * @return this toolkit's implementation of {@code Checkbox}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Checkbox
     * @see java.awt.peer.CheckboxPeer
     */
    default CheckboxPeer createCheckbox(Checkbox target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Scrollbar using the specified peer interface. 
Params:
  • target – the scroll bar to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Scrollbar
/**
     * Creates this toolkit's implementation of {@code Scrollbar} using the
     * specified peer interface.
     *
     * @param  target the scroll bar to be implemented
     * @return this toolkit's implementation of {@code Scrollbar}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Scrollbar
     * @see java.awt.peer.ScrollbarPeer
     */
    default ScrollbarPeer createScrollbar(Scrollbar target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of ScrollPane using the specified peer interface. 
Params:
  • target – the scroll pane to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of ScrollPane
Since:1.1
/**
     * Creates this toolkit's implementation of {@code ScrollPane} using the
     * specified peer interface.
     *
     * @param  target the scroll pane to be implemented
     * @return this toolkit's implementation of {@code ScrollPane}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.ScrollPane
     * @see java.awt.peer.ScrollPanePeer
     * @since 1.1
     */
    default ScrollPanePeer createScrollPane(ScrollPane target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of TextArea using the specified peer interface. 
Params:
  • target – the text area to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of TextArea
/**
     * Creates this toolkit's implementation of {@code TextArea} using the
     * specified peer interface.
     *
     * @param  target the text area to be implemented
     * @return this toolkit's implementation of {@code TextArea}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.TextArea
     * @see java.awt.peer.TextAreaPeer
     */
    default TextAreaPeer createTextArea(TextArea target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Choice using the specified peer interface. 
Params:
  • target – the choice to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Choice
/**
     * Creates this toolkit's implementation of {@code Choice} using the
     * specified peer interface.
     *
     * @param  target the choice to be implemented
     * @return this toolkit's implementation of {@code Choice}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Choice
     * @see java.awt.peer.ChoicePeer
     */
    default ChoicePeer createChoice(Choice target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Frame using the specified peer interface. 
Params:
  • target – the frame to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Frame
/**
     * Creates this toolkit's implementation of {@code Frame} using the
     * specified peer interface.
     *
     * @param  target the frame to be implemented
     * @return this toolkit's implementation of {@code Frame}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Frame
     * @see java.awt.peer.FramePeer
     */
    default FramePeer createFrame(Frame target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Canvas using the specified peer interface. 
Params:
  • target – the canvas to be implemented
See Also:
Returns:this toolkit's implementation of Canvas
/**
     * Creates this toolkit's implementation of {@code Canvas} using the
     * specified peer interface.
     *
     * @param  target the canvas to be implemented
     * @return this toolkit's implementation of {@code Canvas}
     * @see java.awt.Canvas
     * @see java.awt.peer.CanvasPeer
     */
    default CanvasPeer createCanvas(Canvas target) {
        return (CanvasPeer) createComponent(target);
    }

    
Creates this toolkit's implementation of Panel using the specified peer interface. 
Params:
  • target – the panel to be implemented
See Also:
Returns:this toolkit's implementation of Panel
/**
     * Creates this toolkit's implementation of {@code Panel} using the
     * specified peer interface.
     *
     * @param  target the panel to be implemented
     * @return this toolkit's implementation of {@code Panel}
     * @see java.awt.Panel
     * @see java.awt.peer.PanelPeer
     */
    default PanelPeer createPanel(Panel target) {
        return (PanelPeer) createComponent(target);
    }

    
Creates this toolkit's implementation of Window using the specified peer interface. 
Params:
  • target – the window to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Window
/**
     * Creates this toolkit's implementation of {@code Window} using the
     * specified peer interface.
     *
     * @param  target the window to be implemented
     * @return this toolkit's implementation of {@code Window}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Window
     * @see java.awt.peer.WindowPeer
     */
    default WindowPeer createWindow(Window target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Dialog using the specified peer interface. 
Params:
  • target – the dialog to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Dialog
/**
     * Creates this toolkit's implementation of {@code Dialog} using the
     * specified peer interface.
     *
     * @param  target the dialog to be implemented
     * @return this toolkit's implementation of {@code Dialog}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Dialog
     * @see java.awt.peer.DialogPeer
     */
    default DialogPeer createDialog(Dialog target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of MenuBar using the specified peer interface. 
Params:
  • target – the menu bar to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of MenuBar
/**
     * Creates this toolkit's implementation of {@code MenuBar} using the
     * specified peer interface.
     *
     * @param  target the menu bar to be implemented
     * @return this toolkit's implementation of {@code MenuBar}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.MenuBar
     * @see java.awt.peer.MenuBarPeer
     */
    default MenuBarPeer createMenuBar(MenuBar target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of Menu using the specified peer interface. 
Params:
  • target – the menu to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of Menu
/**
     * Creates this toolkit's implementation of {@code Menu} using the specified
     * peer interface.
     *
     * @param  target the menu to be implemented
     * @return this toolkit's implementation of {@code Menu}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.Menu
     * @see java.awt.peer.MenuPeer
     */
    default MenuPeer createMenu(Menu target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of PopupMenu using the specified peer interface. 
Params:
  • target – the popup menu to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of PopupMenu
Since:1.1
/**
     * Creates this toolkit's implementation of {@code PopupMenu} using the
     * specified peer interface.
     *
     * @param  target the popup menu to be implemented
     * @return this toolkit's implementation of {@code PopupMenu}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.PopupMenu
     * @see java.awt.peer.PopupMenuPeer
     * @since 1.1
     */
    default PopupMenuPeer createPopupMenu(PopupMenu target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of MenuItem using the specified peer interface. 
Params:
  • target – the menu item to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of MenuItem
/**
     * Creates this toolkit's implementation of {@code MenuItem} using the
     * specified peer interface.
     *
     * @param  target the menu item to be implemented
     * @return this toolkit's implementation of {@code MenuItem}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.MenuItem
     * @see java.awt.peer.MenuItemPeer
     */
    default MenuItemPeer createMenuItem(MenuItem target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of FileDialog using the specified peer interface. 
Params:
  • target – the file dialog to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of FileDialog
/**
     * Creates this toolkit's implementation of {@code FileDialog} using the
     * specified peer interface.
     *
     * @param  target the file dialog to be implemented
     * @return this toolkit's implementation of {@code FileDialog}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.FileDialog
     * @see java.awt.peer.FileDialogPeer
     */
    default FileDialogPeer createFileDialog(FileDialog target) {
        throw new HeadlessException();
    }

    
Creates this toolkit's implementation of CheckboxMenuItem using the specified peer interface. 
Params:
  • target – the checkbox menu item to be implemented
Throws:
See Also:
Returns:this toolkit's implementation of CheckboxMenuItem
/**
     * Creates this toolkit's implementation of {@code CheckboxMenuItem} using
     * the specified peer interface.
     *
     * @param  target the checkbox menu item to be implemented
     * @return this toolkit's implementation of {@code CheckboxMenuItem}
     * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns
     *         true
     * @see java.awt.GraphicsEnvironment#isHeadless
     * @see java.awt.CheckboxMenuItem
     * @see java.awt.peer.CheckboxMenuItemPeer
     */
    default CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem target) {
        throw new HeadlessException();
    }

    
Creates the peer for a DragSourceContext. Always throws
InvalidDndOperationException if GraphicsEnvironment.isHeadless() returns
true.

Params:
  • dge – the DragGestureEvent
See Also:
Returns:the peer created
/**
     * Creates the peer for a DragSourceContext. Always throws
     * InvalidDndOperationException if GraphicsEnvironment.isHeadless() returns
     * true.
     *
     * @param  dge the {@code DragGestureEvent}
     * @return the peer created
     * @see java.awt.GraphicsEnvironment#isHeadless
     */
    default DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge) {
        throw new InvalidDnDOperationException("Headless environment");
    }

    
Creates this toolkit's implementation of Font using the specified peer interface. 
Params:
  • name – the font to be implemented
  • style – the style of the font, such as PLAIN, BOLD, ITALIC, or a combination
See Also:
Returns:this toolkit's implementation of Font
/**
     * Creates this toolkit's implementation of {@code Font} using the specified
     * peer interface.
     *
     * @param name the font to be implemented
     * @param style the style of the font, such as {@code PLAIN}, {@code BOLD},
     *        {@code ITALIC}, or a combination
     * @return this toolkit's implementation of {@code Font}
     * @see java.awt.Font
     * @see java.awt.peer.FontPeer
     * @see java.awt.GraphicsEnvironment#getAllFonts
     */
    default FontPeer getFontPeer(String name, int style) {
        return null;
    }

    
Creates the peer for a Robot.

Params:
  • screen – the GraphicsDevice indicating the coordinate system the
        Robot will operate in
Throws:
  • AWTException – if the platform configuration does not allow
        low-level input control
Returns:the peer created
/**
     * Creates the peer for a Robot.
     *
     * @param  screen the GraphicsDevice indicating the coordinate system the
     *         Robot will operate in
     * @return the peer created
     * @throws AWTException if the platform configuration does not allow
     *         low-level input control
     */
    default RobotPeer createRobot(GraphicsDevice screen) throws AWTException {
        throw new AWTException(String.format("Unsupported device: %s", screen));
    }

    default DataTransferer getDataTransferer() {
        return null;
    }

    
Obtains this toolkit's implementation of helper class for 
MouseInfo operations. 
Throws:
See Also:
Returns:this toolkit's implementation of helper for MouseInfo
Since:1.5
/**
     * Obtains this toolkit's implementation of helper class for {@code
     * MouseInfo} operations.
     *
     * @return this toolkit's implementation of helper for {@code MouseInfo}
     * @throws UnsupportedOperationException if this operation is not
     *         implemented
     * @see java.awt.peer.MouseInfoPeer
     * @see java.awt.MouseInfo
     * @since 1.5
     */
    default MouseInfoPeer getMouseInfoPeer() {
        throw new UnsupportedOperationException("Not implemented");
    }
}