--- /dev/null
+// Copyright 2002 Adam Megacz, see the COPYING file for licensing [LGPL]
+package org.xwt.plat;
+
+// FIXME: protected void _newBrowserWindow(String url)
+// FIXME: When should I use RootWindow versus DefaultRootWindow?
+// FIXME: Solaris: xwt.altKeyName -> "Meta"
+// FIXME: minimize/taskbar icon
+// FIXME: 15bpp? can't assume depth/8 == bytespp
+// FIXME: check for x resource / memory leaks
+// FIXME: WM_HINTS flags: icon pixmap, icon window [[ have to wait until we have gnome/kde wm's installed ]]
+// FIXME: code-review POSIX.cc
+
+import java.awt.*;
+import java.awt.image.*;
+import gnu.gcj.RawData;
+import java.net.*;
+import java.lang.reflect.*;
+import java.io.*;
+import java.util.*;
+import java.awt.peer.*;
+import org.xwt.util.*;
+import org.xwt.*;
+
+/** Platform implementation for POSIX compliant operating systems with an X11 Server */
+public class POSIX extends GCJ {
+
+ // Static Data ///////////////////////////////////////////////////////////
+
+ /**
+ * When the user reads from the clipboard, the main thread blocks
+ * on this semaphore until we get an X11 SelectionNotify. Crude,
+ * but effective. We know that only one thread will ever block on
+ * this, since only one thread can ever be running JavaScript.
+ */
+ public static Semaphore waiting_for_selection_event = new Semaphore();
+
+ /** our local (in-process) copy of the clipboard */
+ public static String clipboard = null;
+
+ /** map from Window's (casted to jlong, wrapped in java.lang.Long) to X11Surface objects */
+ public static Hashtable windowToSurfaceMap = new Hashtable();
+
+
+ // General Methods ///////////////////////////////////////////////////////
+
+ protected String[] _listFonts() { return fontList; }
+ protected String getDescriptiveName() { return "GCJ Linux Binary"; }
+ protected Picture _createPicture(int[] data, int w, int h) { return new POSIX.X11Picture(data, w, h); }
+ protected DoubleBuffer _createDoubleBuffer(int w, int h, Surface owner) { return new POSIX.X11DoubleBuffer(w, h); }
+ protected Surface _createSurface(Box b, boolean framed) { return new X11Surface(b, framed); }
+ protected boolean _needsAutoClick() { return true; }
+ protected native int _getScreenWidth();
+ protected native int _getScreenHeight();
+ protected native String _getClipBoard();
+ protected native void _setClipBoard(String s);
+ protected native int _stringWidth(String font, String text);
+ protected native int _getMaxAscent(String font);
+ protected native int _getMaxDescent(String font);
+ protected boolean _needsAutoDoubleClick() { return true; }
+ protected native void eventThread();
+ private native void natInit();
+
+ public POSIX() { }
+ public void init() {
+ natInit();
+ (new Thread() { public void run() { eventThread(); } }).start();
+ initFonts();
+ }
+
+ // X11Surface /////////////////////////////////////////////////////
+
+ /** Implements a Surface as an X11 Window */
+ public static class X11Surface extends Surface {
+
+ gnu.gcj.RawData window;
+ gnu.gcj.RawData gc;
+ boolean framed = false;
+ Semaphore waitForCreation = new Semaphore();
+
+ public void setIcon(Picture p) { /* FIXME */ }
+ public void setInvisible(boolean i) { /* FIXME */ }
+ public void _setMaximized(boolean m) { if (Log.on) Log.log(this, "POSIX/X11 can't maximize windows"); }
+ public native void _setMinimized(boolean b);
+ public native void setTitleBarText(String s);
+ public native void setSize(int w, int h);
+ public native void setLocation(int x, int y);
+ public native void natInit();
+ public native void toFront();
+ public native void toBack();
+ public native void syncCursor();
+ public native void _dispose();
+ public native void setLimits(int minw, int minh, int maxw, int maxh);
+ public native void blit(DoubleBuffer s, int sx, int sy, int dx, int dy, int dx2, int dy2);
+ public native void dispatchEvent(gnu.gcj.RawData ev);
+
+ public X11Surface(Box root, boolean framed) {
+ super(root);
+ this.framed = framed;
+ natInit();
+ }
+
+ }
+
+
+ // Our Subclass of Picture ///////////////////////////////////////////////
+
+ // FIXME: what if display server runs out of pixmap space? Think resource conservation...
+
+ /** Implements a Picture as an X11 Pixmap */
+ public static class X11Picture implements Picture {
+
+ int width;
+ int height;
+ int[] data = null;
+ public X11DoubleBuffer doublebuf = null;
+
+ public int getWidth() { return width; }
+ public int getHeight() { return height; }
+
+ public X11Picture(int[] data, int w, int h) {
+ this.data = data;
+ this.width = w;
+ this.height = h;
+
+ // if we have any non-0x00, non-0xFF alphas, we can't double buffer ourselves
+ for(int i=0; i<w*h; i++)
+ if ((data[i] & 0xFF000000) != 0xFF000000 && (data[i] & 0xFF000000) != 0x00)
+ return;
+
+ X11DoubleBuffer b = new X11DoubleBuffer(w, h);
+ b.drawPicture(this, 0, 0);
+ b.createStipple(this);
+ doublebuf = b;
+ }
+
+ }
+
+ // FIXME: finalizer to free X resources
+ public static class X11DoubleBuffer implements DoubleBuffer {
+
+ int clipx, clipy, clipw, cliph;
+ int width;
+ int height;
+
+ /** DoubleBuffers of X11Pictures can have stipples -- the stipple of the Picture */
+ RawData stipple = null;
+
+ /** Sets the DoubleBuffer's internal stipple to the alpha==0x00 regions of xpi */
+ public native void createStipple(X11Picture xpi);
+
+ static int old_shmsize = 0;
+ static RawData shm_ximage;
+ static int shmsegs = 0;
+ int force_slowpath = 0;
+ RawData mxi = null;
+ int shared_pixmap = 0;
+
+ boolean usePixmap = false;
+
+ /** Pixmap (if any) representing this Picture */
+ RawData pm;
+
+ /** Graphics Context on pm (never changes, so it's fast) */
+ RawData gc;
+
+ /** Graphics Context on pm, use this one if you need a clip/stipple */
+ RawData clipped_gc;
+
+ /** DoubleBuffer mode */
+ public X11DoubleBuffer(int w, int h) {
+ width = clipw = w;
+ height = cliph = h;
+ clipx = clipy = 0;
+ shared_pixmap = 1;
+ natInit();
+ }
+
+ public void setClip(int x, int y, int x2, int y2) {
+ clipx = x; if (clipx < 0) clipx = 0;
+ clipy = y; if (clipy < 0) clipy = 0;
+ clipw = x2 - x; if (clipw < 0) clipw = 0;
+ cliph = y2 - y; if (cliph < 0) cliph = 0;
+ }
+
+ public void drawPicture(Picture source, int x, int y) {
+ drawPicture(source, x, y, x + source.getWidth(), y + source.getHeight(), 0, 0, source.getWidth(), source.getHeight());
+ }
+
+ public int getWidth() { return width; }
+ public int getHeight() { return height; }
+ public native void natInit();
+ public native void drawPicture(Picture source, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2);
+ public native void fillRect(int x, int y, int x2, int y2, int color);
+ public native void drawString(String font, String text, int x, int y, int color);
+
+ }
+
+
+ // Font Handling ////////////////////////////////////////////////////////////////////
+
+ static String[] fontList = null;
+
+ /** hashtable of all built in X11 fonts; key is XWT font spec, value is X11 font string */
+ static Hashtable nativeFontList = new Hashtable();
+
+ /** cache of all already-looked-up X11 fonts; key is XWT font name, value is a WrappedRawData */
+ static Hashtable xwtFontToFontStruct = new Hashtable();
+
+ /** dumps a list of X11 font strings */
+ private native String[] listNativeFonts();
+
+ /** load native font list */
+ public void initFonts() {
+ // use the font list to build nativeFontList
+ String[] fonts = listNativeFonts();
+ for(int k=0; k<fonts.length; k++) {
+ String s = fonts[k].toLowerCase();
+ StringTokenizer st = new StringTokenizer(s, "-", false);
+ String[] font = new String[st.countTokens()];
+
+ try {
+ for(int i=0; st.hasMoreTokens(); i++) font[i] = st.nextToken();
+ String name = font[1];
+ String size = font[6];
+ String slant = font[3].equals("i") ? "i" : "";
+ String bold = font[2].equals("bold") ? "b" : "";
+ String tail = s.substring(1 + font[0].length() + 1 + font[1].length() + 1 + font[2].length() + 1 +
+ font[3].length() + 1 + font[4].length() + 1);
+
+ if (bold.equals("*") && slant.equals("*")) {
+ nativeFontList.put(name + size, font[0] + "-" + font[1] + "-regular-r-" + font[4] + "-" + tail);
+ nativeFontList.put(name + size + "b", font[0] + "-" + font[1] + "-bold-r-" + font[4] + "-" + tail);
+ nativeFontList.put(name + size + "i", font[0] + "-" + font[1] + "-regular-i-" + font[4] + "-" + tail);
+ nativeFontList.put(name + size + "bi", font[0] + "-" + font[1] + "-bold-i-" + font[4] + "-" + tail);
+
+ } else if (bold.equals("*")) {
+ nativeFontList.put(name + size + slant, font[0] + "-" + font[1] + "-regular-" + font[3] + "-" + font[4] + "-" + tail);
+ nativeFontList.put(name + size + "b" + slant, font[0] + "-" + font[1] + "-bold-" + font[3] + "-" + font[4] + "-" + tail);
+
+ } else if (slant.equals("*")) {
+ nativeFontList.put(name + size + bold, font[0] + "-" + font[1] + "-" + font[2] + "-r-" + font[4] + "-" + tail);
+ nativeFontList.put(name + size + bold + "i", font[0] + "-" + font[1] + "-" + font[2] + "-i-" + font[4] + "-" + tail);
+
+ } else {
+ nativeFontList.put(name + size + bold + slant, s);
+
+ }
+ } catch (ArrayIndexOutOfBoundsException e) {
+ if (Log.on) Log.log(this, "skipping incomplete font string " + s);
+ continue;
+ }
+ }
+ fontList = new String[nativeFontList.size()];
+ Enumeration e = nativeFontList.keys();
+ for(int i=0; e.hasMoreElements(); i++) fontList[i] = (String)e.nextElement();
+ }
+
+ /** so we can put XFontStruct's into Hashtables */
+ private static class WrappedRawData {
+ public RawData wrapee = null;
+ public WrappedRawData(RawData r) { wrapee = r; }
+ }
+
+ /** translates an X11 font string into an XFontStruct* */
+ public static native gnu.gcj.RawData fontStringToStruct(String s);
+
+ /** translates an XWT font string into an XFontStruct*, performing caching as well */
+ public static RawData fontToXFont(String s) {
+ if (s == null) s = "sansserif";
+ s = s.toLowerCase();
+
+ WrappedRawData wrap = (WrappedRawData)xwtFontToFontStruct.get(s);
+ if (wrap != null) return wrap.wrapee;
+
+ String bestmatch = "";
+ int metric = -1 * Integer.MAX_VALUE;
+ ParsedFont arg = new ParsedFont(s);
+ ParsedFont pf = new ParsedFont();
+
+ if (arg.size == -1) arg.size = 10;
+ Enumeration e = nativeFontList.keys();
+ while(e.hasMoreElements()) {
+ String jfont = (String)e.nextElement();
+ pf.parse(jfont);
+ int thismetric = 0;
+ if (!pf.name.equals(arg.name)) {
+ if (pf.name.equals("lucidabright") && arg.name.equals("serif")) thismetric -= 1000;
+ else if (pf.name.equals("times") && arg.name.equals("serif")) thismetric -= 2000;
+ else if (pf.name.equals("helvetica") && arg.name.equals("sansserif")) thismetric -= 1000;
+ else if (pf.name.equals("courier") && arg.name.equals("monospaced")) thismetric -= 1000;
+ else if (pf.name.equals("lucida") && arg.name.equals("dialog")) thismetric -= 1000;
+ else if (pf.name.equals("helvetica") && arg.name.equals("dialog")) thismetric -= 2000;
+ else if (pf.name.equals("fixed") && arg.name.equals("tty")) thismetric -= 1000;
+ else if (pf.name.equals("sansserif")) thismetric -= 4000;
+ else thismetric -= 4004;
+ }
+ if (pf.size != 0) thismetric -= Math.abs(pf.size - arg.size) * 4;
+ if (pf.bold != arg.bold) thismetric -= 1;
+ if (pf.italic != arg.italic) thismetric -= 1;
+ if (thismetric > metric) {
+ metric = thismetric;
+ bestmatch = jfont;
+ }
+ }
+
+ pf.parse(bestmatch);
+ String target = (String)nativeFontList.get(bestmatch);
+ if (pf.size == 0) {
+ int i = 0;
+ for(int j=0; j<6; j++) i = target.indexOf('-', i + 1);
+ target = target.substring(0, i + 1) + arg.size + target.substring(target.indexOf('-', i+1));
+ }
+ RawData ret = fontStringToStruct(target);
+ if (ret == null) ret = fontStringToStruct("fixed");
+ xwtFontToFontStruct.put(s, new WrappedRawData(ret));
+ return ret;
+ }
+
+
+}
projects / org.ibex.core.git / blobdiff