1 /*
2 * Copyright 2000-2008 Sun Microsystems, Inc. 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. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26 package sun.awt;
27
28 import java.awt.*;
29 import java.awt.dnd.*;
30 import java.awt.dnd.peer.DragSourceContextPeer;
31 import java.awt.event.*;
32 import java.awt.im.InputMethodHighlight;
33 import java.awt.im.spi.InputMethodDescriptor;
34 import java.awt.image.*;
35 import java.awt.datatransfer.Clipboard;
36 import java.awt.peer.*;
37 import java.beans.PropertyChangeListener;
38 import java.lang.reflect.Constructor;
39 import java.lang.reflect.InvocationTargetException;
40 import java.net.URL;
41 import java.util.Map;
42 import java.util.Properties;
43 import sun.awt.im.InputContext;
44 import sun.awt.image.ImageRepresentation;
45
46 public class HeadlessToolkit extends Toolkit
47 implements ComponentFactory, KeyboardFocusManagerPeerProvider {
48
49 private Toolkit tk;
50 private ComponentFactory componentFactory;
51
52 public HeadlessToolkit(Toolkit tk) {
53 this.tk = tk;
54 if (tk instanceof ComponentFactory) {
55 componentFactory = (ComponentFactory)tk;
56 }
57 }
58
59 public Toolkit getUnderlyingToolkit() {
60 return tk;
61 }
62
63 /*
64 * Component peer objects.
65 */
66
67 /* Lightweight implementation of Canvas and Panel */
68
69 public CanvasPeer createCanvas(Canvas target) {
70 return (CanvasPeer)createComponent(target);
71 }
72
73 public PanelPeer createPanel(Panel target) {
74 return (PanelPeer)createComponent(target);
75 }
76
77 /*
78 * Component peer objects - unsupported.
79 */
80
81 public WindowPeer createWindow(Window target)
82 throws HeadlessException {
83 throw new HeadlessException();
84 }
85
86 public FramePeer createFrame(Frame target)
87 throws HeadlessException {
88 throw new HeadlessException();
89 }
90
91 public DialogPeer createDialog(Dialog target)
92 throws HeadlessException {
93 throw new HeadlessException();
94 }
95
96 public ButtonPeer createButton(Button target)
97 throws HeadlessException {
98 throw new HeadlessException();
99 }
100
101 public TextFieldPeer createTextField(TextField target)
102 throws HeadlessException {
103 throw new HeadlessException();
104 }
105
106 public ChoicePeer createChoice(Choice target)
107 throws HeadlessException {
108 throw new HeadlessException();
109 }
110
111 public LabelPeer createLabel(Label target)
112 throws HeadlessException {
113 throw new HeadlessException();
114 }
115
116 public ListPeer createList(List target)
117 throws HeadlessException {
118 throw new HeadlessException();
119 }
120
121 public CheckboxPeer createCheckbox(Checkbox target)
122 throws HeadlessException {
123 throw new HeadlessException();
124 }
125
126 public ScrollbarPeer createScrollbar(Scrollbar target)
127 throws HeadlessException {
128 throw new HeadlessException();
129 }
130
131 public ScrollPanePeer createScrollPane(ScrollPane target)
132 throws HeadlessException {
133 throw new HeadlessException();
134 }
135
136 public TextAreaPeer createTextArea(TextArea target)
137 throws HeadlessException {
138 throw new HeadlessException();
139 }
140
141 public FileDialogPeer createFileDialog(FileDialog target)
142 throws HeadlessException {
143 throw new HeadlessException();
144 }
145
146 public MenuBarPeer createMenuBar(MenuBar target)
147 throws HeadlessException {
148 throw new HeadlessException();
149 }
150
151 public MenuPeer createMenu(Menu target)
152 throws HeadlessException {
153 throw new HeadlessException();
154 }
155
156 public PopupMenuPeer createPopupMenu(PopupMenu target)
157 throws HeadlessException {
158 throw new HeadlessException();
159 }
160
161 public MenuItemPeer createMenuItem(MenuItem target)
162 throws HeadlessException {
163 throw new HeadlessException();
164 }
165
166 public CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem target)
167 throws HeadlessException {
168 throw new HeadlessException();
169 }
170
171 public DragSourceContextPeer createDragSourceContextPeer(
172 DragGestureEvent dge)
173 throws InvalidDnDOperationException {
174 throw new InvalidDnDOperationException("Headless environment");
175 }
176
177 public RobotPeer createRobot(Robot target, GraphicsDevice screen)
178 throws AWTException, HeadlessException {
179 throw new HeadlessException();
180 }
181
182 public KeyboardFocusManagerPeer createKeyboardFocusManagerPeer(KeyboardFocusManager manager) {
183 // See 6833019.
184 return
185 new KeyboardFocusManagerPeer() {
186 public Window getCurrentFocusedWindow() { return null; }
187 public void setCurrentFocusOwner(Component comp) {}
188 public Component getCurrentFocusOwner() { return null; }
189 public void clearGlobalFocusOwner(Window activeWindow) {}
190 };
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 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 IllegalArgumentException(
324 "PrintJob not supported in a headless environment");
325 }
326
327 public PrintJob getPrintJob(Frame frame, String doctitle, Properties props)
328 {
329 if (frame != null) {
330 // Should never happen
331 throw new HeadlessException();
332 }
333 throw new IllegalArgumentException(
334 "PrintJob not supported in a headless environment");
335 }
336
337 /*
338 * Headless toolkit - supported.
339 */
340
341 public void sync() {
342 // Do nothing
343 }
344
345 public void beep() {
346 // Send alert character
347 System.out.write(0x07);
348 }
349
350 /*
351 * Event Queue
352 */
353 public EventQueue getSystemEventQueueImpl() {
354 return SunToolkit.getSystemEventQueueImplPP();
355 }
356
357 /*
358 * Images.
359 */
360 public int checkImage(Image img, int w, int h, ImageObserver o) {
361 return tk.checkImage(img, w, h, o);
362 }
363
364 public boolean prepareImage(
365 Image img, int w, int h, ImageObserver o) {
366 return tk.prepareImage(img, w, h, o);
367 }
368
369 public Image getImage(String filename) {
370 return tk.getImage(filename);
371 }
372
373 public Image getImage(URL url) {
374 return tk.getImage(url);
375 }
376
377 public Image createImage(String filename) {
378 return tk.createImage(filename);
379 }
380
381 public Image createImage(URL url) {
382 return tk.createImage(url);
383 }
384
385 public Image createImage(byte[] data, int offset, int length) {
386 return tk.createImage(data, offset, length);
387 }
388
389 public Image createImage(ImageProducer producer) {
390 return tk.createImage(producer);
391 }
392
393 public Image createImage(byte[] imagedata) {
394 return tk.createImage(imagedata);
395 }
396
397
398 /*
399 * Fonts
400 */
401 public FontPeer getFontPeer(String name, int style) {
402 if (componentFactory != null) {
403 return componentFactory.getFontPeer(name, style);
404 }
405 return null;
406 }
407
408 public FontMetrics getFontMetrics(Font font) {
409 return tk.getFontMetrics(font);
410 }
411
412 public String[] getFontList() {
413 return tk.getFontList();
414 }
415
416 /*
417 * Desktop properties
418 */
419
420 public void addPropertyChangeListener(String name,
421 PropertyChangeListener pcl) {
422 tk.addPropertyChangeListener(name, pcl);
423 }
424
425 public void removePropertyChangeListener(String name,
426 PropertyChangeListener pcl) {
427 tk.removePropertyChangeListener(name, pcl);
428 }
429
430 /*
431 * Modality
432 */
433 public boolean isModalityTypeSupported(Dialog.ModalityType modalityType) {
434 return false;
435 }
436
437 public boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType exclusionType) {
438 return false;
439 }
440
441 /*
442 * Always on top
443 */
444 public boolean isAlwaysOnTopSupported() {
445 return false;
446 }
447
448 /*
449 * AWT Event listeners
450 */
451
452 public void addAWTEventListener(AWTEventListener listener,
453 long eventMask) {
454 tk.addAWTEventListener(listener, eventMask);
455 }
456
457 public void removeAWTEventListener(AWTEventListener listener) {
458 tk.removeAWTEventListener(listener);
459 }
460
461 public AWTEventListener[] getAWTEventListeners() {
462 return tk.getAWTEventListeners();
463 }
464
465 public AWTEventListener[] getAWTEventListeners(long eventMask) {
466 return tk.getAWTEventListeners(eventMask);
467 }
468
469 public boolean isDesktopSupported() {
470 return false;
471 }
472
473 public DesktopPeer createDesktopPeer(Desktop target)
474 throws HeadlessException{
475 throw new HeadlessException();
476 }
477
478 public boolean areExtraMouseButtonsEnabled() throws HeadlessException{
479 throw new HeadlessException();
480 }
481 }