Subversion Repositories openrisc

/* XToolkit.java -- The central AWT Toolkit for the X peers
   Copyright (C) 2006 Free Software Foundation, Inc.
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath 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 for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */
 
 
package gnu.java.awt.peer.x;
 
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.Dialog;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.FileDialog;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Frame;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.Label;
import java.awt.List;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.Panel;
import java.awt.PopupMenu;
import java.awt.PrintJob;
import java.awt.ScrollPane;
import java.awt.Scrollbar;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.Transparency;
import java.awt.Window;
import java.awt.Dialog.ModalExclusionType;
import java.awt.Dialog.ModalityType;
import java.awt.datatransfer.Clipboard;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.peer.DragSourceContextPeer;
import java.awt.im.InputMethodHighlight;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.DirectColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
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.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.ListPeer;
import java.awt.peer.MenuBarPeer;
import java.awt.peer.MenuItemPeer;
import java.awt.peer.MenuPeer;
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.TextAreaPeer;
import java.awt.peer.TextFieldPeer;
import java.awt.peer.WindowPeer;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.WeakHashMap;
 
import javax.imageio.ImageIO;
 
import gnu.classpath.SystemProperties;
import gnu.java.awt.ClasspathToolkit;
import gnu.java.awt.EmbeddedWindow;
import gnu.java.awt.font.OpenTypeFontPeer;
import gnu.java.awt.image.ImageConverter;
import gnu.java.awt.java2d.AbstractGraphics2D;
import gnu.java.awt.peer.ClasspathFontPeer;
import gnu.java.awt.peer.EmbeddedWindowPeer;
import gnu.java.awt.peer.swing.SwingButtonPeer;
import gnu.java.awt.peer.swing.SwingCanvasPeer;
import gnu.java.awt.peer.swing.SwingCheckboxPeer;
import gnu.java.awt.peer.swing.SwingLabelPeer;
import gnu.java.awt.peer.swing.SwingPanelPeer;
import gnu.java.awt.peer.swing.SwingTextAreaPeer;
import gnu.java.awt.peer.swing.SwingTextFieldPeer;
 
public class XToolkit
  extends ClasspathToolkit
{
 
  /**
   * Set to true to enable debug output.
   */
  static boolean DEBUG = false;
 
  /**
   * Maps AWT colors to X colors.
   */
  HashMap colorMap = new HashMap();
 
  /**
   * The system event queue.
   */
  private EventQueue eventQueue;
 
  /**
   * The default color model of this toolkit.
   */
  private ColorModel colorModel;
 
  /**
   * Maps image URLs to Image instances.
   */
  private HashMap imageCache = new HashMap();
 
  /**
   * The cached fonts.
   */
  private WeakHashMap<String,ClasspathFontPeer> fontCache =
    new WeakHashMap<String,ClasspathFontPeer>();
 
  public XToolkit()
  {
    SystemProperties.setProperty("gnu.javax.swing.noGraphics2D", "true");
    SystemProperties.setProperty("java.awt.graphicsenv",
                                 "gnu.java.awt.peer.x.XGraphicsEnvironment");
  }
 
  public GraphicsEnvironment getLocalGraphicsEnvironment()
  {
    return new XGraphicsEnvironment();
  }
 
  /**
   * Returns the font peer for a font with the specified name and attributes.
   *
   * @param name the font name
   * @param attrs the font attributes
   *
   * @return the font peer for a font with the specified name and attributes
   */
  public ClasspathFontPeer getClasspathFontPeer(String name, Map attrs)
  {
    ClasspathFontPeer font;
    if ("true".equals(System.getProperty("escherpeer.usexfonts")))
      {
        String canonical = XFontPeer.encodeFont(name, attrs);
        if (!fontCache.containsKey(canonical))
          {
            font = new XFontPeer(name, attrs);
            fontCache.put(canonical, font);
          }
        else
          {
            font = fontCache.get(canonical);
          }
      }
    else
      {
        String canonical = OpenTypeFontPeer.encodeFont(name, attrs);
        if (!fontCache.containsKey(canonical))
          {
            font = new OpenTypeFontPeer(name, attrs);
            fontCache.put(canonical, font);
          }
        else
          {
            font = fontCache.get(canonical);
          }
      }
    return font;
  }
 
  public Font createFont(int format, InputStream stream)
  {
    return null;
  }
 
  public RobotPeer createRobot(GraphicsDevice screen) throws AWTException
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  public EmbeddedWindowPeer createEmbeddedWindow(EmbeddedWindow w)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected ButtonPeer createButton(Button target)
  {
    checkHeadLess("No ButtonPeer can be created in an headless" +
                      "graphics environment.");
 
    return new SwingButtonPeer(target);
  }
 
  protected TextFieldPeer createTextField(TextField target)
  {
    checkHeadLess("No TextFieldPeer can be created in an headless " +
                      "graphics environment.");
 
    return new SwingTextFieldPeer(target);
  }
 
  protected LabelPeer createLabel(Label target)
  {
    checkHeadLess("No LabelPeer can be created in an headless graphics " +
                      "environment.");
    return new SwingLabelPeer(target);
  }
 
  protected ListPeer createList(List target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected CheckboxPeer createCheckbox(Checkbox target)
  {
    checkHeadLess("No CheckboxPeer can be created in an headless graphics " +
                  "environment.");
 
    return new SwingCheckboxPeer(target);
  }
 
  protected ScrollbarPeer createScrollbar(Scrollbar target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected ScrollPanePeer createScrollPane(ScrollPane target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected TextAreaPeer createTextArea(TextArea target)
  {
    checkHeadLess("No TextAreaPeer can be created in an headless graphics " +
                      "environment.");
 
    return new SwingTextAreaPeer(target);
  }
 
  protected ChoicePeer createChoice(Choice target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected FramePeer createFrame(Frame target)
  {
    XFramePeer frame = new XFramePeer(target);
    return frame;
  }
 
  protected CanvasPeer createCanvas(Canvas target)
  {
    return new SwingCanvasPeer(target);
  }
 
  protected PanelPeer createPanel(Panel target)
  {
    return new SwingPanelPeer(target);
  }
 
  protected WindowPeer createWindow(Window target)
  {
    return new XWindowPeer(target);
  }
 
  protected DialogPeer createDialog(Dialog target)
  {
    return new XDialogPeer(target);
  }
 
  protected MenuBarPeer createMenuBar(MenuBar target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected MenuPeer createMenu(Menu target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected PopupMenuPeer createPopupMenu(PopupMenu target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected MenuItemPeer createMenuItem(MenuItem target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected FileDialogPeer createFileDialog(FileDialog target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem target)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  protected FontPeer getFontPeer(String name, int style)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  public Dimension getScreenSize()
  {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice gd = ge.getDefaultScreenDevice();
    GraphicsConfiguration gc = gd.getDefaultConfiguration();
    XGraphicsConfiguration xgc = (XGraphicsConfiguration) gc;
 
    return xgc.getSize();
  }
 
  public int getScreenResolution()
  {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    GraphicsDevice gd = ge.getDefaultScreenDevice();
    GraphicsConfiguration gc = gd.getDefaultConfiguration();
    XGraphicsConfiguration xgc = (XGraphicsConfiguration) gc;
 
    return xgc.getResolution();
  }
 
  /**
   * Returns the color model used by this toolkit.
   *
   * @return the color model used by this toolkit
   */
  public ColorModel getColorModel()
  {
    // TODO: I assume 24 bit depth here, we can do this better.
    if (colorModel == null)
      colorModel = new DirectColorModel(24, 0xFF0000, 0xFF00, 0xFF);
    return colorModel;
  }
 
  public String[] getFontList()
  {
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
    return ge.getAvailableFontFamilyNames();
  }
 
  public FontMetrics getFontMetrics(Font name)
  {
    ClasspathFontPeer peer = (ClasspathFontPeer) name.getPeer();
    return peer.getFontMetrics(name);
  }
 
  public void sync()
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  /**
   * Returns an image that has its pixel data loaded from a file with the
   * specified name. If that file doesn't exist, an empty or error image
   * is returned instead.
   *
   * @param name the filename of the file that contains the pixel data
   *
   * @return the image
   */
  public Image getImage(String name)
  {
    Image image;
    try
      {
        File file = new File(name);
        image = getImage(file.toURL());
      }
    catch (MalformedURLException ex)
      {
        // TODO: Replace by a more meaningful error image instead.
        image = null;
      }
    return image;
  }
 
  /**
   * Returns an image that has its pixel data loaded from the specified URL.
   * If the image cannot be loaded for some reason, an empty or error image
   * is returned instead.
   *
   * @param url the URL to the image data
   *
   * @return the image
   */
  public Image getImage(URL url)
  {
    Image image;
    if (imageCache.containsKey(url))
      {
        image = (Image) imageCache.get(url);
      }
    else
      {
        image = createImage(url);
        imageCache.put(url, image);
      }
    return image;
  }
 
  /**
   * Returns an image that has its pixel data loaded from a file with the
   * specified name. If that file doesn't exist, an empty or error image
   * is returned instead.
   *
   * @param filename the filename of the file that contains the pixel data
   *
   * @return the image
   */
  public Image createImage(String filename)
  {
    Image im;
    try
      {
        File file = new File(filename);
        URL url = file.toURL();
        im = createImage(url);
      }
    catch (MalformedURLException ex)
      {
        im = createErrorImage();
      }
    return im;
  }
 
  /**
   * Returns an image that has its pixel data loaded from the specified URL.
   * If the image cannot be loaded for some reason, an empty or error image
   * is returned instead.
   *
   * @param url the URL to the image data
   *
   * @return the image
   */
  public Image createImage(URL url)
  {
    Image image;
    try
      {
        image = createImage(url.openStream());
      }
    catch (IOException ex)
      {
        image = createErrorImage();
      }
    return image;
  }
 
  /**
   * Creates an image that is returned when calls to createImage() yields an
   * error.
   *
   * @return an image that is returned when calls to createImage() yields an
   *         error
   */
  private Image createErrorImage()
  {
    // TODO: Create better error image.
    return new XImage(1, 1);
  }
 
  public boolean prepareImage(Image image, int width, int height, ImageObserver observer)
  {
    Image scaled = AbstractGraphics2D.prepareImage(image, width, height);
    return checkImage(image, width, height, observer) == ImageObserver.ALLBITS;
  }
 
  public int checkImage(Image image, int width, int height, ImageObserver observer)
  {
    // Images are loaded synchronously, so we don't bother and return true.
    return ImageObserver.ALLBITS;
  }
 
  public Image createImage(ImageProducer producer)
  {
    ImageConverter conv = new ImageConverter();
    producer.startProduction(conv);
    Image image = conv.getImage();
    return image;
  }
 
  public Image createImage(byte[] data, int offset, int len)
  {
    Image image;
    try
      {
        ByteArrayInputStream i = new ByteArrayInputStream(data, offset, len);
        image = createImage(i);
      }
    catch (IOException ex)
      {
        image = createErrorImage();
      }
    return image;
  }
 
  private Image createImage(InputStream i)
    throws IOException
  {
    Image image;
    BufferedImage buffered = ImageIO.read(i);
    // If the bufferedimage is opaque, then we can copy it over to an
    // X Pixmap for faster drawing.
    if (buffered != null && buffered.getTransparency() == Transparency.OPAQUE)
      {
        ImageProducer source = buffered.getSource();
        image = createImage(source);
      }
    else if (buffered != null)
      {
        image = buffered;
      }
    else
      {
        image = createErrorImage();
      }
    return image;
  }
 
  public PrintJob getPrintJob(Frame frame, String title, Properties props)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  public void beep()
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  public Clipboard getSystemClipboard()
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  /**
   * Returns the eventqueue used by the XLib peers.
   *
   * @return the eventqueue used by the XLib peers
   */
  protected EventQueue getSystemEventQueueImpl()
  {
    if (eventQueue == null)
      eventQueue = new EventQueue();
    return eventQueue;
  }
 
  public DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent e)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  public Map mapInputMethodHighlight(InputMethodHighlight highlight)
  {
    // TODO: Implement this.
    throw new UnsupportedOperationException("Not yet implemented.");
  }
 
  /**
   * Helper method to quickly fetch the default device (X Display).
   *
   * @return the default XGraphicsDevice
   */
  static XGraphicsDevice getDefaultDevice()
  {
    XGraphicsEnvironment env = (XGraphicsEnvironment)
      XGraphicsEnvironment.getLocalGraphicsEnvironment();
    return (XGraphicsDevice) env.getDefaultScreenDevice();
  }
 
  @Override
  public boolean isModalExclusionTypeSupported(ModalExclusionType modalExclusionType)
  {
    // TODO Auto-generated method stub
    return false;
  }
 
  @Override
  public boolean isModalityTypeSupported(ModalityType modalityType)
  {
    // TODO Auto-generated method stub
    return false;
  }
 
  private void checkHeadLess(String message) throws HeadlessException
  {
    if(GraphicsEnvironment.isHeadless())
      {
        if(message == null)
          message = "This method cannot be called in headless mode.";
 
        throw new HeadlessException(message);
      }
  }
}