libjava/gnu/awt/xlib/XToolkit.java

   1 /* Copyright (C) 2000, 2002, 2003  Free Software Foundation
   2
   3    This file is part of libgcj.
   4
   5 This software is copyrighted work licensed under the terms of the
   6 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   7 details.  */
   8
   9 package gnu.awt.xlib;
  10
  11 import java.awt.*;
  12 import java.awt.dnd.*;
  13 import java.awt.dnd.peer.*;
  14 import java.awt.im.*;
  15 import java.awt.peer.*;
  16 import java.awt.image.ImageProducer;
  17 import java.awt.image.ImageObserver;
  18 import java.net.*;
  19 import java.awt.datatransfer.Clipboard;
  20 import java.util.Properties;
  21 import java.util.Map;
  22
  23 import gnu.gcj.xlib.Display;
  24 import gnu.gcj.xlib.Screen;
  25 import gnu.gcj.xlib.Visual;
  26
  27 public class XToolkit extends Toolkit
  28 {
  29   static XToolkit INSTANCE;
  30
  31   Display display;
  32
  33   EventQueue queue;
  34   XEventLoop eventLoop;
  35
  36   XGraphicsConfiguration defaultConfig;
  37
  38   public XToolkit()
  39   {
  40     INSTANCE = this;
  41     display = new Display();
  42     synchronized (display)
  43       {
  44         queue = new XEventQueue(display);
  45         eventLoop = new XEventLoop(display, queue);
  46       }
  47   }
  48
  49   public void flushIfIdle()
  50   {
  51     eventLoop.flushIfIdle();
  52   }
  53
  54   protected ButtonPeer createButton(Button frontend)
  55   {
  56     // FIXME: Stubbed out, needs Swing:
  57     /*
  58     XCanvasPeer realPeer = new XCanvasPeer(frontend);
  59     SButtonPeer sbPeer = new SButtonPeer(frontend, realPeer);
  60     return sbPeer;
  61     */
  62     return null;
  63   }
  64
  65   protected TextFieldPeer createTextField(TextField frontend)
  66   {
  67     return null; // FIXME
  68   }
  69
  70   protected LabelPeer createLabel(Label frontend)
  71   {
  72     return null; // FIXME
  73   }
  74
  75   protected ListPeer createList(List frontend)
  76   {
  77     return null; // FIXME
  78   }
  79
  80   protected CheckboxPeer createCheckbox(Checkbox frontend)
  81   {
  82     return null; // FIXME
  83   }
  84
  85   protected ScrollbarPeer createScrollbar(Scrollbar frontend)
  86   {
  87     return null; // FIXME
  88   }
  89
  90   protected ScrollPanePeer createScrollPane(ScrollPane frontend)
  91   {
  92     return null; // FIXME
  93   }
  94
  95   protected TextAreaPeer createTextArea(TextArea frontend)
  96   {
  97     return null; // FIXME
  98   }
  99
 100   protected ChoicePeer createChoice(Choice frontend)
 101   {
 102     return null; // FIXME
 103   }
 104
 105   protected FramePeer createFrame(Frame frontend) {
 106     return new XFramePeer(frontend);
 107   }
 108
 109   protected CanvasPeer createCanvas(Canvas frontend) {
 110     XCanvasPeer peer = new XCanvasPeer(frontend);
 111     return peer;
 112   }
 113
 114   protected PanelPeer createPanel(Panel frontend) {
 115     return new XPanelPeer(frontend);
 116   }
 117
 118   protected WindowPeer createWindow(Window frontend)
 119   {
 120     return null; // FIXME
 121   }
 122
 123   protected DialogPeer createDialog(Dialog frontend)
 124   {
 125     return null; // FIXME
 126   }
 127
 128   protected MenuBarPeer createMenuBar(MenuBar frontend)
 129   {
 130     return null; // FIXME
 131   }
 132
 133   protected MenuPeer createMenu(Menu frontend)
 134   {
 135     return null; // FIXME
 136   }
 137
 138   protected PopupMenuPeer createPopupMenu(PopupMenu frontend)
 139   {
 140     return null; // FIXME
 141   }
 142
 143   protected MenuItemPeer createMenuItem(MenuItem frontend)
 144   {
 145     return null; // FIXME
 146   }
 147
 148   protected FileDialogPeer createFileDialog(FileDialog frontend)
 149   {
 150     return null; // FIXME
 151   }
 152
 153   protected CheckboxMenuItemPeer
 154       createCheckboxMenuItem(CheckboxMenuItem frontend)
 155   {
 156     return null; // FIXME
 157   }
 158
 159   protected java.awt.peer.FontPeer getFontPeer(String name, int style)
 160   {
 161     return null;
 162   }
 163
 164   public Dimension getScreenSize()
 165   {
 166     throw new UnsupportedOperationException("not implemented yet");
 167   }
 168
 169   public int getScreenResolution()
 170   {
 171     throw new UnsupportedOperationException("not implemented yet");
 172   }
 173
 174   public java.awt.image.ColorModel getColorModel()
 175   {
 176     return getDefaultXGraphicsConfiguration().getColorModel();
 177   }
 178
 179   public String[] getFontList()
 180   {
 181     throw new UnsupportedOperationException("not implemented yet");
 182   }
 183
 184   public FontMetrics getFontMetrics(Font font)
 185   {
 186     return getDefaultXGraphicsConfiguration().getXFontMetrics(font);
 187   }
 188
 189   public void sync()
 190   {
 191     flushIfIdle ();
 192     // FIXME: should instead wait for eventLoop to go idle
 193     // (perhaps send a dummy event there and block till it makes
 194     // it through the queue)
 195   }
 196
 197   public Image getImage(String filename)
 198   {
 199     return createImage(filename);
 200   }
 201
 202   public Image getImage(URL url)
 203   {
 204     throw new UnsupportedOperationException("not implemented yet");
 205   }
 206
 207   public Image createImage(String filename)
 208   {
 209     // FIXME: Stubbed out. We need a proper image I/O API.
 210
 211     /*
 212     BufferedImage jpeg;
 213     FileInputStream fis = openFile(filename);
 214     if (fis == null)
 215       return null;
 216
 217     BasicRasterImageConsumer consumer = new BasicRasterImageConsumer();
 218     JPEGImageDecoder jid = new JPEGImageDecoder(fis);
 219
 220     jid.startProduction(consumer);
 221     jpeg = consumer.getImage();
 222
 223     int w = jpeg.getWidth();
 224     int h = jpeg.getHeight();
 225
 226     BufferedImage img =
 227       getDefaultXGraphicsConfiguration().createCompatibleImage(w, h);
 228
 229     Renderers renderers = Renderers.getInstance();
 230
 231     RasterOp renderer = renderers.createRenderer(jpeg.getColorModel(),
 232                                                  jpeg.getSampleModel(),
 233                                                  img.getColorModel(),
 234                                                  img.getSampleModel());
 235
 236     if (renderer == null)
 237       {
 238         throw new UnsupportedOperationException("couldn't find renderer");
 239       }
 240
 241     renderer.filter(jpeg.getRaster(), img.getRaster());
 242
 243     return img;
 244     */
 245
 246     return null;
 247   }
 248
 249   public Image createImage(URL url)
 250   {
 251     throw new UnsupportedOperationException("not implemented yet");
 252   }
 253
 254   public boolean prepareImage(Image image,
 255                               int width,
 256                               int height,
 257                               ImageObserver observer)
 258   {
 259     throw new UnsupportedOperationException("not implemented yet");
 260   }
 261
 262   public int checkImage(Image image,
 263                         int width,
 264                         int height,
 265                         ImageObserver observer)
 266   {
 267     throw new UnsupportedOperationException("not implemented yet");
 268   }
 269
 270   public Image createImage(ImageProducer producer)
 271   {
 272     throw new UnsupportedOperationException("not implemented yet");
 273   }
 274
 275   public Image createImage(byte[] imagedata,
 276                            int imageoffset,
 277                            int imagelength)
 278   {
 279     throw new UnsupportedOperationException("not implemented yet");
 280   }
 281
 282   /*
 283     public PrintJob getPrintJob(Frame frame,
 284                                 String jobtitle,
 285                                 Properties props);
 286   */
 287
 288   public void beep()
 289   {
 290     throw new UnsupportedOperationException("not implemented yet");
 291   }
 292
 293   public Clipboard getSystemClipboard()
 294   {
 295     return null; // FIXME
 296   }
 297
 298   protected EventQueue getSystemEventQueueImpl()
 299   {
 300     return queue;
 301   }
 302
 303   public PrintJob getPrintJob (Frame frame, String title, Properties props)
 304   {
 305     return null;                // FIXME
 306   }
 307
 308   XGraphicsConfiguration getDefaultXGraphicsConfiguration()
 309   {
 310     if (defaultConfig == null)
 311       {
 312         Screen screen = display.getDefaultScreen();
 313         Visual visual = screen.getRootVisual();
 314         defaultConfig = new XGraphicsConfiguration(visual);
 315
 316         // ASSERT:
 317         if (!defaultConfig.getVisual().getScreen().equals(screen))
 318           {
 319             String msg = "screen of graphics configuration is not " +
 320               "default screen";
 321             throw new Error(msg);
 322           }
 323       }
 324
 325     return defaultConfig;
 326   }
 327
 328   public DragSourceContextPeer
 329     createDragSourceContextPeer(DragGestureEvent dge)
 330     throws InvalidDnDOperationException
 331   {
 332     throw new UnsupportedOperationException("not implemented");
 333   }
 334
 335   public DragGestureRecognizer
 336     createDragGestureRecognizer(Class abstractRecognizerClass,
 337                                 DragSource ds, Component c,
 338                                 int srcActions, DragGestureListener dgl)
 339   {
 340     throw new UnsupportedOperationException("not implemented");
 341   }
 342
 343
 344   public Map mapInputMethodHighlight(InputMethodHighlight highlight)
 345   {
 346     throw new UnsupportedOperationException("not implemented");
 347   }
 348 }