package gnu.java.awt.peer.gtk;
import java.awt.*;
import java.awt.datatransfer.Clipboard;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.peer.DragSourceContextPeer;
import java.awt.font.TextAttribute;
import java.awt.im.InputMethodHighlight;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.GraphicsEnvironment;
import java.awt.peer.*;
import java.net.URL;
import java.util.Hashtable;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Properties;
import gnu.java.awt.EmbeddedWindow;
import gnu.java.awt.EmbeddedWindowSupport;
import gnu.java.awt.peer.EmbeddedWindowPeer;
import gnu.java.awt.peer.ClasspathFontPeer;
import gnu.classpath.Configuration;
import gnu.java.awt.peer.gtk.GdkPixbufDecoder;
public class GtkToolkit extends gnu.java.awt.ClasspathToolkit
implements EmbeddedWindowSupport
{
GtkMainThread main;
Hashtable containers = new Hashtable();
static EventQueue q = new EventQueue();
static Clipboard systemClipboard;
static boolean useGraphics2dSet;
static boolean useGraphics2d;
public static boolean useGraphics2D()
{
if (useGraphics2dSet)
return useGraphics2d;
useGraphics2d = System.getProperty("gnu.java.awt.peer.gtk.Graphics",
"Graphics").equals("Graphics2D");
useGraphics2dSet = true;
return useGraphics2d;
}
static
{
if (Configuration.INIT_LOAD_LIBRARY)
System.loadLibrary("gtkpeer");
}
public GtkToolkit ()
{
main = new GtkMainThread ();
systemClipboard = new GtkClipboard ();
GtkGenericPeer.enableQueue (q);
}
native public void beep ();
native private void getScreenSizeDimensions (int[] xy);
public int checkImage (Image image, int width, int height,
ImageObserver observer)
{
int status = ((GtkImage) image).checkImage ();
if (observer != null)
observer.imageUpdate (image, status,
-1, -1,
image.getWidth (observer),
image.getHeight (observer));
return status;
}
public Image createImage (String filename)
{
return new GtkImage (new GdkPixbufDecoder (filename), null);
}
public Image createImage (URL url)
{
return new GtkImage (new GdkPixbufDecoder (url), null);
}
public Image createImage (ImageProducer producer)
{
return new GtkImage (producer, null);
}
public Image createImage (byte[] imagedata, int imageoffset,
int imagelength)
{
return new GtkImage (new GdkPixbufDecoder (imagedata,
imageoffset,
imagelength),
null);
}
public ColorModel getColorModel ()
{
return ColorModel.getRGBdefault ();
}
public String[] getFontList ()
{
return (new String[] { "Dialog",
"DialogInput",
"Monospaced",
"Serif",
"SansSerif" });
}
public FontMetrics getFontMetrics (Font font)
{
if (useGraphics2D())
return new GdkClasspathFontPeerMetrics (font);
else
return new GdkFontMetrics (font);
}
public Image getImage (String filename)
{
GdkPixbufDecoder d = new GdkPixbufDecoder (filename);
GtkImage image = new GtkImage (d, null);
d.startProduction (image);
return image;
}
public Image getImage (URL url)
{
GdkPixbufDecoder d = new GdkPixbufDecoder (url);
GtkImage image = new GtkImage (d, null);
d.startProduction (image);
return image;
}
public PrintJob getPrintJob (Frame frame, String jobtitle, Properties props)
{
return null;
}
native public int getScreenResolution();
public Dimension getScreenSize () {
int dim[] = new int[2];
getScreenSizeDimensions(dim);
return new Dimension(dim[0], dim[1]);
}
public Clipboard getSystemClipboard()
{
return systemClipboard;
}
public boolean prepareImage (Image image, int width, int height,
ImageObserver observer)
{
GtkImage i = (GtkImage) image;
if (i.isLoaded ()) return true;
class PrepareImage extends Thread
{
GtkImage image;
ImageObserver observer;
PrepareImage (GtkImage image, ImageObserver observer)
{
this.image = image;
image.setObserver (observer);
}
public void run ()
{
image.source.startProduction (image);
}
}
new PrepareImage (i, observer).start ();
return false;
}
native public void sync ();
protected void setComponentState (Component c, GtkComponentPeer cp)
{
if (c.getForeground () == null)
c.setForeground (cp.getForeground ());
if (c.getBackground () == null)
c.setBackground (cp.getBackground ());
if (! (c instanceof Window))
{
cp.setCursor (c.getCursor ());
Rectangle bounds = c.getBounds ();
cp.setBounds (bounds.x, bounds.y, bounds.width, bounds.height);
cp.setVisible (c.isVisible ());
}
}
protected ButtonPeer createButton (Button b)
{
return new GtkButtonPeer (b);
}
protected CanvasPeer createCanvas (Canvas c)
{
return new GtkCanvasPeer (c);
}
protected CheckboxPeer createCheckbox (Checkbox cb)
{
return new GtkCheckboxPeer (cb);
}
protected CheckboxMenuItemPeer createCheckboxMenuItem (CheckboxMenuItem cmi)
{
return new GtkCheckboxMenuItemPeer (cmi);
}
protected ChoicePeer createChoice (Choice c)
{
return new GtkChoicePeer (c);
}
protected DialogPeer createDialog (Dialog d)
{
return new GtkDialogPeer (d);
}
protected FileDialogPeer createFileDialog (FileDialog fd)
{
return new GtkFileDialogPeer (fd);
}
protected FramePeer createFrame (Frame f)
{
return new GtkFramePeer (f);
}
protected LabelPeer createLabel (Label label)
{
return new GtkLabelPeer (label);
}
protected ListPeer createList (List list)
{
return new GtkListPeer (list);
}
protected MenuPeer createMenu (Menu m)
{
return new GtkMenuPeer (m);
}
protected MenuBarPeer createMenuBar (MenuBar mb)
{
return new GtkMenuBarPeer (mb);
}
protected MenuItemPeer createMenuItem (MenuItem mi)
{
return new GtkMenuItemPeer (mi);
}
protected PanelPeer createPanel (Panel p)
{
return new GtkPanelPeer (p);
}
protected PopupMenuPeer createPopupMenu (PopupMenu target)
{
return new GtkPopupMenuPeer (target);
}
protected ScrollPanePeer createScrollPane (ScrollPane sp)
{
return new GtkScrollPanePeer (sp);
}
protected ScrollbarPeer createScrollbar (Scrollbar sb)
{
return new GtkScrollbarPeer (sb);
}
protected TextAreaPeer createTextArea (TextArea ta)
{
return new GtkTextAreaPeer (ta);
}
protected TextFieldPeer createTextField (TextField tf)
{
return new GtkTextFieldPeer (tf);
}
protected WindowPeer createWindow (Window w)
{
return new GtkWindowPeer (w);
}
public EmbeddedWindowPeer createEmbeddedWindow (EmbeddedWindow w)
{
return new GtkEmbeddedWindowPeer (w);
}
protected FontPeer getFontPeer (String name, int style) {
return getFontPeer(name, style, 12);
}
private FontPeer getFontPeer (String name, int style, int size)
{
GtkFontPeer fp = new GtkFontPeer (name, style, size);
return fp;
}
public ClasspathFontPeer getClasspathFontPeer (String name, Map attrs)
{
if (useGraphics2D())
return new GdkClasspathFontPeer (name, attrs);
else
{
int size = 12;
int style = Font.PLAIN;
if (name == null)
name = "Default";
if (attrs.containsKey (TextAttribute.WEIGHT))
{
Float weight = (Float) attrs.get (TextAttribute.WEIGHT);
if (weight.floatValue () >= TextAttribute.WEIGHT_BOLD.floatValue ())
style += Font.BOLD;
}
if (attrs.containsKey (TextAttribute.POSTURE))
{
Float posture = (Float) attrs.get (TextAttribute.POSTURE);
if (posture.floatValue () >= TextAttribute.POSTURE_OBLIQUE.floatValue ())
style += Font.ITALIC;
}
if (attrs.containsKey (TextAttribute.SIZE))
{
Float fsize = (Float) attrs.get (TextAttribute.SIZE);
size = fsize.intValue();
}
return (ClasspathFontPeer) this.getFontPeer (name, style, size);
}
}
protected EventQueue getSystemEventQueueImpl()
{
return q;
}
protected void loadSystemColors (int[] systemColors)
{
}
public DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent e)
{
throw new Error("not implemented");
}
public Map mapInputMethodHighlight(InputMethodHighlight highlight)
{
throw new Error("not implemented");
}
public GraphicsEnvironment getLocalGraphicsEnvironment()
{
GraphicsEnvironment ge;
ge = new GdkGraphicsEnvironment ();
return ge;
}
public Font createFont(int format, java.io.InputStream stream)
{
throw new java.lang.UnsupportedOperationException ();
}
}