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.font.*;
  15 import java.awt.im.*;
  16 import java.awt.peer.*;
  17 import java.awt.image.ImageProducer;
  18 import java.awt.image.ImageObserver;
  19 import java.net.*;
  20 import java.awt.datatransfer.Clipboard;
  21 import java.io.InputStream;
  22 import java.text.AttributedString;
  23 import java.util.Map;
  24 import java.util.Properties;
  25 import gnu.gcj.xlib.Display;
  26 import gnu.gcj.xlib.Screen;
  27 import gnu.gcj.xlib.Visual;
  28 import gnu.java.awt.ClasspathToolkit;
  29 import gnu.java.awt.peer.ClasspathFontPeer;
  30 import gnu.java.awt.peer.ClasspathTextLayoutPeer;
  31
  32 public class XToolkit extends ClasspathToolkit
  33 {
  34   static XToolkit INSTANCE;
  35
  36   Display display;
  37
  38   EventQueue queue;
  39   XEventLoop eventLoop;
  40
  41   XGraphicsConfiguration defaultConfig;
  42
  43   public XToolkit()
  44   {
  45     INSTANCE = this;
  46     display = new Display();
  47     synchronized (display)
  48       {
  49         queue = new XEventQueue(display);
  50         eventLoop = new XEventLoop(display, queue);
  51       }
  52   }
  53
  54   public void flushIfIdle()
  55   {
  56     eventLoop.flushIfIdle();
  57   }
  58
  59   protected ButtonPeer createButton(Button frontend)
  60   {
  61     // FIXME: Stubbed out, needs Swing:
  62     /*
  63     XCanvasPeer realPeer = new XCanvasPeer(frontend);
  64     SButtonPeer sbPeer = new SButtonPeer(frontend, realPeer);
  65     return sbPeer;
  66     */
  67     return null;
  68   }
  69
  70   protected TextFieldPeer createTextField(TextField frontend)
  71   {
  72     return null; // FIXME
  73   }
  74
  75   protected LabelPeer createLabel(Label frontend)
  76   {
  77     return null; // FIXME
  78   }
  79
  80   protected ListPeer createList(List frontend)
  81   {
  82     return null; // FIXME
  83   }
  84
  85   protected CheckboxPeer createCheckbox(Checkbox frontend)
  86   {
  87     return null; // FIXME
  88   }
  89
  90   protected ScrollbarPeer createScrollbar(Scrollbar frontend)
  91   {
  92     return null; // FIXME
  93   }
  94
  95   protected ScrollPanePeer createScrollPane(ScrollPane frontend)
  96   {
  97     return null; // FIXME
  98   }
  99
 100   protected TextAreaPeer createTextArea(TextArea frontend)
 101   {
 102     return null; // FIXME
 103   }
 104
 105   protected ChoicePeer createChoice(Choice frontend)
 106   {
 107     return null; // FIXME
 108   }
 109
 110   protected FramePeer createFrame(Frame frontend) {
 111     return new XFramePeer(frontend);
 112   }
 113
 114   protected CanvasPeer createCanvas(Canvas frontend) {
 115     XCanvasPeer peer = new XCanvasPeer(frontend);
 116     return peer;
 117   }
 118
 119   protected PanelPeer createPanel(Panel frontend) {
 120     return new XPanelPeer(frontend);
 121   }
 122
 123   protected WindowPeer createWindow(Window frontend)
 124   {
 125     return null; // FIXME
 126   }
 127
 128   protected DialogPeer createDialog(Dialog frontend)
 129   {
 130     return null; // FIXME
 131   }
 132
 133   protected MenuBarPeer createMenuBar(MenuBar frontend)
 134   {
 135     return null; // FIXME
 136   }
 137
 138   protected MenuPeer createMenu(Menu frontend)
 139   {
 140     return null; // FIXME
 141   }
 142
 143   protected PopupMenuPeer createPopupMenu(PopupMenu frontend)
 144   {
 145     return null; // FIXME
 146   }
 147
 148   protected MenuItemPeer createMenuItem(MenuItem frontend)
 149   {
 150     return null; // FIXME
 151   }
 152
 153   protected FileDialogPeer createFileDialog(FileDialog frontend)
 154   {
 155     return null; // FIXME
 156   }
 157
 158   protected CheckboxMenuItemPeer
 159       createCheckboxMenuItem(CheckboxMenuItem frontend)
 160   {
 161     return null; // FIXME
 162   }
 163
 164   protected java.awt.peer.FontPeer getFontPeer(String name, int style)
 165   {
 166     return new XFontPeer (name,style);
 167   }
 168
 169   public Dimension getScreenSize()
 170   {
 171     throw new UnsupportedOperationException("not implemented yet");
 172   }
 173
 174   public int getScreenResolution()
 175   {
 176     throw new UnsupportedOperationException("not implemented yet");
 177   }
 178
 179   public java.awt.image.ColorModel getColorModel()
 180   {
 181     return getDefaultXGraphicsConfiguration().getColorModel();
 182   }
 183
 184   public String[] getFontList()
 185   {
 186     throw new UnsupportedOperationException("not implemented yet");
 187   }
 188
 189   public FontMetrics getFontMetrics(Font font)
 190   {
 191     return getDefaultXGraphicsConfiguration().getXFontMetrics(font);
 192   }
 193
 194   public void sync()
 195   {
 196     flushIfIdle ();
 197     // FIXME: should instead wait for eventLoop to go idle
 198     // (perhaps send a dummy event there and block till it makes
 199     // it through the queue)
 200   }
 201
 202   public Image getImage(String filename)
 203   {
 204     return createImage(filename);
 205   }
 206
 207   public Image getImage(URL url)
 208   {
 209     throw new UnsupportedOperationException("not implemented yet");
 210   }
 211
 212   public Image createImage(String filename)
 213   {
 214     // FIXME: Stubbed out. We need a proper image I/O API.
 215
 216     /*
 217     BufferedImage jpeg;
 218     FileInputStream fis = openFile(filename);
 219     if (fis == null)
 220       return null;
 221
 222     BasicRasterImageConsumer consumer = new BasicRasterImageConsumer();
 223     JPEGImageDecoder jid = new JPEGImageDecoder(fis);
 224
 225     jid.startProduction(consumer);
 226     jpeg = consumer.getImage();
 227
 228     int w = jpeg.getWidth();
 229     int h = jpeg.getHeight();
 230
 231     BufferedImage img =
 232       getDefaultXGraphicsConfiguration().createCompatibleImage(w, h);
 233
 234     Renderers renderers = Renderers.getInstance();
 235
 236     RasterOp renderer = renderers.createRenderer(jpeg.getColorModel(),
 237                                                  jpeg.getSampleModel(),
 238                                                  img.getColorModel(),
 239                                                  img.getSampleModel());
 240
 241     if (renderer == null)
 242       {
 243         throw new UnsupportedOperationException("couldn't find renderer");
 244       }
 245
 246     renderer.filter(jpeg.getRaster(), img.getRaster());
 247
 248     return img;
 249     */
 250
 251     return null;
 252   }
 253
 254   public Image createImage(URL url)
 255   {
 256     throw new UnsupportedOperationException("not implemented yet");
 257   }
 258
 259   public boolean prepareImage(Image image,
 260                               int width,
 261                               int height,
 262                               ImageObserver observer)
 263   {
 264     throw new UnsupportedOperationException("not implemented yet");
 265   }
 266
 267   public int checkImage(Image image,
 268                         int width,
 269                         int height,
 270                         ImageObserver observer)
 271   {
 272     throw new UnsupportedOperationException("not implemented yet");
 273   }
 274
 275   public Image createImage(ImageProducer producer)
 276   {
 277     throw new UnsupportedOperationException("not implemented yet");
 278   }
 279
 280   public Image createImage(byte[] imagedata,
 281                            int imageoffset,
 282                            int imagelength)
 283   {
 284     throw new UnsupportedOperationException("not implemented yet");
 285   }
 286
 287   /*
 288     public PrintJob getPrintJob(Frame frame,
 289                                 String jobtitle,
 290                                 Properties props);
 291   */
 292
 293   public void beep()
 294   {
 295     throw new UnsupportedOperationException("not implemented yet");
 296   }
 297
 298   public Clipboard getSystemClipboard()
 299   {
 300     return null; // FIXME
 301   }
 302
 303   protected EventQueue getSystemEventQueueImpl()
 304   {
 305     return queue;
 306   }
 307
 308   public PrintJob getPrintJob (Frame frame, String title, Properties props)
 309   {
 310     return null;                // FIXME
 311   }
 312
 313   XGraphicsConfiguration getDefaultXGraphicsConfiguration()
 314   {
 315     if (defaultConfig == null)
 316       {
 317         Screen screen = display.getDefaultScreen();
 318         Visual visual = screen.getRootVisual();
 319         defaultConfig = new XGraphicsConfiguration(visual);
 320
 321         // ASSERT:
 322         if (!defaultConfig.getVisual().getScreen().equals(screen))
 323           {
 324             String msg = "screen of graphics configuration is not " +
 325               "default screen";
 326             throw new Error(msg);
 327           }
 328       }
 329
 330     return defaultConfig;
 331   }
 332
 333   public DragSourceContextPeer
 334     createDragSourceContextPeer(DragGestureEvent dge)
 335     throws InvalidDnDOperationException
 336   {
 337     throw new UnsupportedOperationException("not implemented");
 338   }
 339
 340   public DragGestureRecognizer
 341     createDragGestureRecognizer(Class abstractRecognizerClass,
 342                                 DragSource ds, Component c,
 343                                 int srcActions, DragGestureListener dgl)
 344   {
 345     throw new UnsupportedOperationException("not implemented");
 346   }
 347
 348
 349   public Map mapInputMethodHighlight(InputMethodHighlight highlight)
 350   {
 351     throw new UnsupportedOperationException("not implemented");
 352   }
 353
 354   /** Returns a shared instance of the local, platform-specific
 355    * graphics environment.
 356    *
 357    * <p>This method is specific to GNU Classpath. It gets called by
 358    * the Classpath implementation of {@link
 359    * GraphicsEnvironment.getLocalGraphcisEnvironment()}.
 360    */
 361   public GraphicsEnvironment getLocalGraphicsEnvironment ()
 362   {
 363     throw new java.lang.UnsupportedOperationException ();
 364   }
 365
 366   /** Acquires an appropriate {@link ClasspathFontPeer}, for use in
 367    * classpath's implementation of {@link java.awt.Font}.
 368    *
 369    * @param name The logical name of the font. This may be either a face
 370    * name or a logical font name, or may even be null. A default
 371    * implementation of name decoding is provided in
 372    * {@link ClasspathFontPeer}, but may be overridden in other toolkits.
 373    *
 374    * @param attrs Any extra {@link java.awt.font.TextAttribute} attributes
 375    * this font peer should have, such as size, weight, family name, or
 376    * transformation.
 377    */
 378   public ClasspathFontPeer getClasspathFontPeer (String name, Map attrs)
 379   {
 380     int style = Font.PLAIN;
 381     float size = 12;
 382
 383     if (attrs.containsKey (TextAttribute.WEIGHT))
 384       {
 385         Float weight = (Float) attrs.get (TextAttribute.WEIGHT);
 386         if (weight.floatValue () >= TextAttribute.WEIGHT_BOLD.floatValue ())
 387           style += Font.BOLD;
 388       }
 389
 390     if (attrs.containsKey (TextAttribute.POSTURE))
 391       {
 392         Float posture = (Float) attrs.get (TextAttribute.POSTURE);
 393         if (posture.floatValue () >= TextAttribute.POSTURE_OBLIQUE.floatValue ())
 394           style += Font.ITALIC;
 395       }
 396
 397     if (attrs.containsKey (TextAttribute.SIZE))
 398       {
 399         Float fsize = (Float) attrs.get (TextAttribute.SIZE);
 400         size = fsize.floatValue ();
 401       }
 402
 403     return new XFontPeer (name,style,size);
 404   }
 405
 406   public ClasspathTextLayoutPeer
 407   getClasspathTextLayoutPeer (AttributedString str, FontRenderContext frc)
 408   {
 409     throw new Error("not implemented");
 410   }
 411
 412   /** Creates a font, reading the glyph definitions from a stream.
 413    *
 414    * <p>This method provides the platform-specific implementation for
 415    * the static factory method {@link Font#createFont(int,
 416    * java.io.InputStream)}.
 417    *
 418    * @param format the format of the font data, such as {@link
 419    * Font#TRUETYPE_FONT}. An implementation may ignore this argument
 420    * if it is able to automatically recognize the font format from the
 421    * provided data.
 422    *
 423    * @param stream an input stream from where the font data is read
 424    * in. The stream will be advanced to the position after the font
 425    * data, but not closed.
 426    *
 427    * @throws IllegalArgumentException if <code>format</code> is
 428    * not supported.
 429    *
 430    * @throws FontFormatException if <code>stream</code> does not
 431    * contain data in the expected format, or if required tables are
 432    * missing from a font.
 433    *
 434    * @throws IOException if a problem occurs while reading in the
 435    * contents of <code>stream</code>.
 436    */
 437   public Font createFont (int format, InputStream stream)
 438   {
 439     throw new java.lang.UnsupportedOperationException ();
 440   }
 441
 442   public RobotPeer createRobot (GraphicsDevice screen) throws AWTException
 443   {
 444     throw new java.lang.UnsupportedOperationException ();
 445   }
 446
 447   boolean interrupted;
 448
 449   public boolean nativeQueueEmpty()
 450   {
 451     return eventLoop.isIdle();
 452   }
 453
 454   public void wakeNativeQueue()
 455   {
 456     interrupted = true;
 457     eventLoop.interrupt();
 458   }
 459
 460   public void iterateNativeQueue(java.awt.EventQueue locked, boolean block)
 461   {
 462     interrupted = false;
 463     while (!interrupted)
 464       eventLoop.postNextEvent(block);
 465   };
 466 }