1 /*
   2  * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.awt;
  27 
  28 import sun.awt.datatransfer.DataTransferer;
  29 
  30 import java.awt.*;
  31 import java.awt.dnd.*;
  32 import java.awt.dnd.peer.DragSourceContextPeer;
  33 import java.awt.event.*;
  34 import java.awt.font.TextAttribute;
  35 import java.awt.im.InputMethodHighlight;
  36 import java.awt.image.*;
  37 import java.awt.datatransfer.Clipboard;
  38 import java.awt.peer.*;
  39 import java.beans.PropertyChangeListener;
  40 import java.net.URL;
  41 import java.util.Map;
  42 import java.util.Properties;
  43 
  44 public class HeadlessToolkit extends Toolkit
  45     implements ComponentFactory, KeyboardFocusManagerPeerProvider {
  46 
  47     private static final KeyboardFocusManagerPeer kfmPeer = new KeyboardFocusManagerPeer() {
  48         public void setCurrentFocusedWindow(Window win) {}
  49         public Window getCurrentFocusedWindow() { return null; }
  50         public void setCurrentFocusOwner(Component comp) {}
  51         public Component getCurrentFocusOwner() { return null; }
  52         public void clearGlobalFocusOwner(Window activeWindow) {}
  53     };
  54 
  55     private Toolkit tk;
  56     private ComponentFactory componentFactory;
  57 
  58     public HeadlessToolkit(Toolkit tk) {
  59         this.tk = tk;
  60         if (tk instanceof ComponentFactory) {
  61             componentFactory = (ComponentFactory)tk;
  62         }
  63     }
  64 
  65     public Toolkit getUnderlyingToolkit() {
  66         return tk;
  67     }
  68 
  69     /*
  70      * Component peer objects.
  71      */
  72 
  73     /* Lightweight implementation of Canvas and Panel */
  74 
  75     public CanvasPeer createCanvas(Canvas target) {
  76         return (CanvasPeer)createComponent(target);
  77     }
  78 
  79     public PanelPeer createPanel(Panel target) {
  80         return (PanelPeer)createComponent(target);
  81     }
  82 
  83     /*
  84      * Component peer objects - unsupported.
  85      */
  86 
  87     public WindowPeer createWindow(Window target)
  88         throws HeadlessException {
  89         throw new HeadlessException();
  90     }
  91 
  92     public FramePeer createFrame(Frame target)
  93         throws HeadlessException {
  94         throw new HeadlessException();
  95     }
  96 
  97     public DialogPeer createDialog(Dialog target)
  98         throws HeadlessException {
  99         throw new HeadlessException();
 100     }
 101 
 102     public ButtonPeer createButton(Button target)
 103         throws HeadlessException {
 104         throw new HeadlessException();
 105     }
 106 
 107     public TextFieldPeer createTextField(TextField target)
 108         throws HeadlessException {
 109         throw new HeadlessException();
 110     }
 111 
 112     public ChoicePeer createChoice(Choice target)
 113         throws HeadlessException {
 114         throw new HeadlessException();
 115     }
 116 
 117     public LabelPeer createLabel(Label target)
 118         throws HeadlessException {
 119         throw new HeadlessException();
 120     }
 121 
 122     public ListPeer createList(List target)
 123         throws HeadlessException {
 124         throw new HeadlessException();
 125     }
 126 
 127     public CheckboxPeer createCheckbox(Checkbox target)
 128         throws HeadlessException {
 129         throw new HeadlessException();
 130     }
 131 
 132     public ScrollbarPeer createScrollbar(Scrollbar target)
 133         throws HeadlessException {
 134         throw new HeadlessException();
 135     }
 136 
 137     public ScrollPanePeer createScrollPane(ScrollPane target)
 138         throws HeadlessException {
 139         throw new HeadlessException();
 140     }
 141 
 142     public TextAreaPeer createTextArea(TextArea target)
 143         throws HeadlessException {
 144         throw new HeadlessException();
 145     }
 146 
 147     public FileDialogPeer createFileDialog(FileDialog target)
 148         throws HeadlessException {
 149         throw new HeadlessException();
 150     }
 151 
 152     public MenuBarPeer createMenuBar(MenuBar target)
 153         throws HeadlessException {
 154         throw new HeadlessException();
 155     }
 156 
 157     public MenuPeer createMenu(Menu target)
 158         throws HeadlessException {
 159         throw new HeadlessException();
 160     }
 161 
 162     public PopupMenuPeer createPopupMenu(PopupMenu target)
 163         throws HeadlessException {
 164         throw new HeadlessException();
 165     }
 166 
 167     public MenuItemPeer createMenuItem(MenuItem target)
 168         throws HeadlessException {
 169         throw new HeadlessException();
 170     }
 171 
 172     public CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem target)
 173         throws HeadlessException {
 174         throw new HeadlessException();
 175     }
 176 
 177     public DragSourceContextPeer createDragSourceContextPeer(
 178         DragGestureEvent dge)
 179         throws InvalidDnDOperationException {
 180         throw new InvalidDnDOperationException("Headless environment");
 181     }
 182 
 183     public RobotPeer createRobot(Robot target, GraphicsDevice screen)
 184         throws AWTException, HeadlessException {
 185         throw new HeadlessException();
 186     }
 187 
 188     public KeyboardFocusManagerPeer getKeyboardFocusManagerPeer() {
 189         // See 6833019.
 190         return kfmPeer;
 191     }
 192 
 193     public TrayIconPeer createTrayIcon(TrayIcon target)
 194       throws HeadlessException {
 195         throw new HeadlessException();
 196     }
 197 
 198     public SystemTrayPeer createSystemTray(SystemTray target)
 199       throws HeadlessException {
 200         throw new HeadlessException();
 201     }
 202 
 203     public boolean isTraySupported() {
 204         return false;
 205     }
 206 
 207     public GlobalCursorManager getGlobalCursorManager()
 208         throws HeadlessException {
 209         throw new HeadlessException();
 210     }
 211 
 212     /*
 213      * Headless toolkit - unsupported.
 214      */
 215     protected void loadSystemColors(int[] systemColors)
 216         throws HeadlessException {
 217         throw new HeadlessException();
 218     }
 219 
 220     public ColorModel getColorModel()
 221         throws HeadlessException {
 222         throw new HeadlessException();
 223     }
 224 
 225     public int getScreenResolution()
 226         throws HeadlessException {
 227         throw new HeadlessException();
 228     }
 229 
 230     public Map<TextAttribute, ?> mapInputMethodHighlight(InputMethodHighlight highlight)
 231         throws HeadlessException {
 232         throw new HeadlessException();
 233     }
 234 
 235     public int getMenuShortcutKeyMask()
 236         throws HeadlessException {
 237         throw new HeadlessException();
 238     }
 239 
 240     public boolean getLockingKeyState(int keyCode)
 241         throws UnsupportedOperationException {
 242         throw new HeadlessException();
 243     }
 244 
 245     public void setLockingKeyState(int keyCode, boolean on)
 246         throws UnsupportedOperationException {
 247         throw new HeadlessException();
 248     }
 249 
 250     public Cursor createCustomCursor(Image cursor, Point hotSpot, String name)
 251         throws IndexOutOfBoundsException, HeadlessException {
 252         throw new HeadlessException();
 253     }
 254 
 255     public Dimension getBestCursorSize(int preferredWidth, int preferredHeight)
 256         throws HeadlessException {
 257         throw new HeadlessException();
 258     }
 259 
 260     public int getMaximumCursorColors()
 261         throws HeadlessException {
 262         throw new HeadlessException();
 263     }
 264 
 265     public <T extends DragGestureRecognizer> T
 266         createDragGestureRecognizer(Class<T> abstractRecognizerClass,
 267                                     DragSource ds, Component c,
 268                                     int srcActions, DragGestureListener dgl)
 269     {
 270         return null;
 271     }
 272 
 273     public int getScreenHeight()
 274         throws HeadlessException {
 275         throw new HeadlessException();
 276     }
 277 
 278     public int getScreenWidth()
 279         throws HeadlessException {
 280         throw new HeadlessException();
 281     }
 282 
 283     public Dimension getScreenSize()
 284         throws HeadlessException {
 285         throw new HeadlessException();
 286     }
 287 
 288     public Insets getScreenInsets(GraphicsConfiguration gc)
 289         throws HeadlessException {
 290         throw new HeadlessException();
 291     }
 292 
 293     public void setDynamicLayout(boolean dynamic)
 294         throws HeadlessException {
 295         throw new HeadlessException();
 296     }
 297 
 298     protected boolean isDynamicLayoutSet()
 299         throws HeadlessException {
 300         throw new HeadlessException();
 301     }
 302 
 303     public boolean isDynamicLayoutActive()
 304         throws HeadlessException {
 305         throw new HeadlessException();
 306     }
 307 
 308     public Clipboard getSystemClipboard()
 309         throws HeadlessException {
 310         throw new HeadlessException();
 311     }
 312 
 313     /*
 314      * Printing
 315      */
 316     public PrintJob getPrintJob(Frame frame, String jobtitle,
 317         JobAttributes jobAttributes,
 318         PageAttributes pageAttributes) {
 319         if (frame != null) {
 320             // Should never happen
 321             throw new HeadlessException();
 322         }
 323         throw new NullPointerException("frame must not be null");
 324     }
 325 
 326     public PrintJob getPrintJob(Frame frame, String doctitle, Properties props)
 327     {
 328         if (frame != null) {
 329             // Should never happen
 330             throw new HeadlessException();
 331         }
 332         throw new NullPointerException("frame must not be null");
 333     }
 334 
 335     /*
 336      * Headless toolkit - supported.
 337      */
 338 
 339     public void sync() {
 340         // Do nothing
 341     }
 342 
 343     public void beep() {
 344         // Send alert character
 345         System.out.write(0x07);
 346     }
 347 
 348     /*
 349      * Event Queue
 350      */
 351     public EventQueue getSystemEventQueueImpl() {
 352         return SunToolkit.getSystemEventQueueImplPP();
 353     }
 354 
 355     /*
 356      * Images.
 357      */
 358     public int checkImage(Image img, int w, int h, ImageObserver o) {
 359         return tk.checkImage(img, w, h, o);
 360     }
 361 
 362     public boolean prepareImage(
 363         Image img, int w, int h, ImageObserver o) {
 364         return tk.prepareImage(img, w, h, o);
 365     }
 366 
 367     public Image getImage(String filename) {
 368         return tk.getImage(filename);
 369     }
 370 
 371     public Image getImage(URL url) {
 372         return tk.getImage(url);
 373     }
 374 
 375     public Image createImage(String filename) {
 376         return tk.createImage(filename);
 377     }
 378 
 379     public Image createImage(URL url) {
 380         return tk.createImage(url);
 381     }
 382 
 383     public Image createImage(byte[] data, int offset, int length) {
 384         return tk.createImage(data, offset, length);
 385     }
 386 
 387     public Image createImage(ImageProducer producer) {
 388         return tk.createImage(producer);
 389     }
 390 
 391     public Image createImage(byte[] imagedata) {
 392         return tk.createImage(imagedata);
 393     }
 394 
 395 
 396     /*
 397      * Fonts
 398      */
 399     @SuppressWarnings("deprecation")
 400     public FontPeer getFontPeer(String name, int style) {
 401         if (componentFactory != null) {
 402             return componentFactory.getFontPeer(name, style);
 403         }
 404         return null;
 405     }
 406 
 407     @Override
 408     public DataTransferer getDataTransferer() {
 409         return null;
 410     }
 411 
 412     @SuppressWarnings("deprecation")
 413     public FontMetrics getFontMetrics(Font font) {
 414         return tk.getFontMetrics(font);
 415     }
 416 
 417     @SuppressWarnings("deprecation")
 418     public String[] getFontList() {
 419         return tk.getFontList();
 420     }
 421 
 422     /*
 423      * Desktop properties
 424      */
 425 
 426     public void addPropertyChangeListener(String name,
 427         PropertyChangeListener pcl) {
 428         tk.addPropertyChangeListener(name, pcl);
 429     }
 430 
 431     public void removePropertyChangeListener(String name,
 432         PropertyChangeListener pcl) {
 433         tk.removePropertyChangeListener(name, pcl);
 434     }
 435 
 436     /*
 437      * Modality
 438      */
 439     public boolean isModalityTypeSupported(Dialog.ModalityType modalityType) {
 440         return false;
 441     }
 442 
 443     public boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType exclusionType) {
 444         return false;
 445     }
 446 
 447     /*
 448      * Always on top
 449      */
 450     public boolean isAlwaysOnTopSupported() {
 451         return false;
 452     }
 453 
 454     /*
 455      * AWT Event listeners
 456      */
 457 
 458     public void addAWTEventListener(AWTEventListener listener,
 459         long eventMask) {
 460         tk.addAWTEventListener(listener, eventMask);
 461     }
 462 
 463     public void removeAWTEventListener(AWTEventListener listener) {
 464         tk.removeAWTEventListener(listener);
 465     }
 466 
 467     public AWTEventListener[] getAWTEventListeners() {
 468         return tk.getAWTEventListeners();
 469     }
 470 
 471     public AWTEventListener[] getAWTEventListeners(long eventMask) {
 472         return tk.getAWTEventListeners(eventMask);
 473     }
 474 
 475     public boolean isDesktopSupported() {
 476         return false;
 477     }
 478 
 479     public DesktopPeer createDesktopPeer(Desktop target)
 480     throws HeadlessException{
 481         throw new HeadlessException();
 482     }
 483 
 484     public boolean areExtraMouseButtonsEnabled() throws HeadlessException{
 485         throw new HeadlessException();
 486     }
 487 }