src/org/ibex/plat/X11.java

   1 // Copyright 2004 Adam Megacz, see the COPYING file for licensing [LGPL]
   2 package org.ibex.plat;
   3
   4 import gnu.gcj.RawData;
   5 import java.util.*;
   6 import org.ibex.js.*;
   7 import org.ibex.util.*;
   8 import org.ibex.graphics.*;
   9 import org.ibex.core.*;
  10 import org.ibex.net.*;
  11
  12 /** Platform implementation for POSIX compliant operating systems with an X11 Server */
  13 public class X11 extends POSIX {
  14
  15     // Static Data ///////////////////////////////////////////////////////////
  16
  17     /**
  18      *  When the user reads from the clipboard, the main thread blocks
  19      *  on this semaphore until we get an X11 SelectionNotify. Crude,
  20      *  but effective. We know that only one thread will ever block on
  21      *  this, since only one thread can ever be running JavaScript.
  22      */
  23     public static Semaphore waiting_for_selection_event = new Semaphore();
  24
  25     /** our local (in-process) copy of the clipboard */
  26     public static String clipboard = null;
  27
  28     /** map from Window's (casted to jlong, wrapped in java.lang.Long) to X11Surface objects */
  29     public static Hashtable windowToSurfaceMap = new Hashtable();
  30
  31
  32     // General Methods ///////////////////////////////////////////////////////
  33
  34     protected String _getAltKeyName() { return System.getProperty("os.name", "").indexOf("SunOS") != -1 ? "Meta" : "Alt"; }
  35
  36     protected Picture _createPicture(JS r) { return new X11Picture(r); }
  37     protected PixelBuffer _createPixelBuffer(int w, int h, Surface owner) { return new X11PixelBuffer(w, h); }
  38     protected Surface _createSurface(Box b, boolean framed) { return new X11Surface(b, framed); }
  39     protected boolean _needsAutoClick() { return true; }
  40     protected native int _getScreenWidth();
  41     protected native int _getScreenHeight();
  42     protected native String _getClipBoard();
  43     protected native void _setClipBoard(String s);
  44     protected boolean _needsAutoDoubleClick() { return true; }
  45     protected native String _fileDialog(String suggestedFileName, boolean write);
  46     protected native void eventThread();
  47     private native void natInit();
  48
  49     public void postInit() {
  50         natInit();
  51         (new Thread() { public void run() { eventThread(); } }).start();
  52     }
  53
  54     // X11Surface /////////////////////////////////////////////////////
  55
  56
  57     /** Implements a Surface as an X11 Window */
  58     public static class X11Surface extends Surface {
  59
  60         public PixelBuffer getPixelBuffer() { return null; }  // FIXME
  61
  62         gnu.gcj.RawData window;
  63         gnu.gcj.RawData gc;
  64         boolean framed = false;
  65         Semaphore waitForCreation = new Semaphore();
  66
  67         public native void setInvisible(boolean i);
  68         public void _setMaximized(boolean m) { if (Log.on) Log.warn(this, "X11 can't maximize windows"); }
  69         public native void setIcon(Picture p);
  70         public native void _setMinimized(boolean b);
  71         public native void setTitleBarText(String s);
  72         public native void _setSize(int w, int h);
  73         public native void setLocation();
  74         public native void natInit();
  75         public native void toFront();
  76         public native void toBack();
  77         public native void syncCursor();
  78         public native void _dispose();
  79         public native void setLimits(int minw, int minh, int maxw, int maxh);
  80         public native void blit(PixelBuffer s, int sx, int sy, int dx, int dy, int dx2, int dy2);
  81         public native void dispatchEvent(gnu.gcj.RawData ev);
  82         public void setMinimumSize(int minx, int miny, boolean resizable) {
  83             setLimits(minx, miny, resizable ? Short.MAX_VALUE : minx, resizable ? Short.MAX_VALUE : miny);
  84         }
  85         public X11Surface(Box root, boolean framed) {
  86             super(root);
  87             this.framed = framed;
  88             natInit();
  89         }
  90
  91     }
  92
  93
  94     // Our Subclass of Picture ///////////////////////////////////////////////
  95
  96     /**
  97      *  Implements a Picture. No special X11 structure is created
  98      *  unless the image has no alpha (in which case a
  99      *  non-shared-pixmap PixelBuffer is created), or all-or-nothing
 100      *  alpha (in which case a non-shared-pixmap PixelBuffer with a
 101      *  stipple bitmap is created).
 102      */
 103     public static class X11Picture extends Picture {
 104
 105         public X11PixelBuffer doublebuf = null;
 106
 107         public int getWidth() { return width; }
 108         public int getHeight() { return height; }
 109
 110         boolean initialized = false;
 111         public X11Picture(JS r) { super(r); }
 112         public void init() {
 113             if (initialized) return;
 114             initialized = true;
 115             boolean needsStipple = false;
 116
 117             // if we have any non-0x00, non-0xFF alphas, we can't double buffer ourselves
 118             for(int i=0; i<width*height; i++)
 119                 if ((data[i] & 0xFF000000) == 0xFF000000)
 120                     needsStipple = true;
 121                 else if ((data[i] & 0xFF000000) != 0x00)
 122                     return;
 123
 124             buildPixelBuffer(needsStipple);
 125         }
 126
 127         void buildPixelBuffer(boolean needsStipple) {
 128             if (doublebuf != null) return;
 129             // no point in using a shared pixmap since we'll only write to this image once
 130             X11PixelBuffer b = new X11PixelBuffer(width, height, false);
 131             b.drawPicture(this, 0, 0, 0, 0, width, height);
 132             if (needsStipple) b.createStipple(this);
 133             doublebuf = b;
 134         }
 135     }
 136
 137     /**
 138      *  An X11PixelBuffer is implemented as an X11 pixmap. "Normal"
 139      *  PixelBuffers will use XShm shared pixmaps if
 140      *  available. X11PixelBuffers created to accelerate Pictures
 141      *  with all-or-nothing alpha will not use shared pixmaps, however
 142      *  (since they are only written to once.
 143      */
 144     public static class X11PixelBuffer implements PixelBuffer {
 145
 146     public void drawLine(int x1, int y1, int x2, int y2, int color) { }
 147     public void drawGlyph(Font.Glyph source, int dx1, int dy1, int cx1, int cy1, int cx2, int cy2, int rgb, int pc){}
 148     public void stroke(Polygon p, int color){}
 149     public void fill(Polygon p, Paint paint){}
 150
 151         int clipx, clipy, clipw, cliph;
 152         int width;
 153         int height;
 154
 155         /** PixelBuffers of X11Pictures can have stipples -- the stipple of the Picture */
 156         RawData stipple = null;
 157
 158         /** Sets the PixelBuffer's internal stipple to the alpha==0x00 regions of xpi */
 159         public native void createStipple(X11Picture xpi);
 160
 161         RawData pm;                    // Pixmap (if any) representing this Picture
 162         boolean shared_pixmap = false; // true if pm is a ShmPixmap
 163         RawData fake_ximage = null;    // a 'fake' XImage corresponding to the shared pixmap; gives us the address and depth parameters
 164         RawData shm_segment = null;    // XShmSegmentInfo
 165
 166         RawData gc;                    // Graphics Interpreter on pm (never changes, so it's fast)
 167         RawData clipped_gc;            // Graphics Interpreter on pm, use this one if you need a clip/stipple
 168
 169         /** PixelBuffer mode */
 170         public X11PixelBuffer(int w, int h) { this(w, h, true); }
 171         public X11PixelBuffer(int w, int h, boolean shared_pixmap) {
 172             width = clipw = w;
 173             height = cliph = h;
 174             clipx = clipy = 0;
 175             this.shared_pixmap = shared_pixmap;
 176             natInit();
 177         }
 178
 179         public void drawGlyph(Font.Glyph source, int dx, int dy, int cx1, int cy1, int cx2, int cy2, int rgb) {
 180             cx1 = Math.max(dx, cx1);
 181             cy1 = Math.max(dy, cy1);
 182             cx2 = Math.min(dx + source.width, cx2);
 183             cy2 = Math.min(dy + source.height, cy2);
 184             if (cx1 >= cx2 || cy1 >= cy2) return;
 185             X11Picture pic = (X11Picture)((Platform.DefaultGlyph)source).getPicture();
 186             pic.init();
 187             slowDrawPicture(pic, dx, dy, cx1, cy1, cx2, cy2, rgb, true);
 188         }
 189         public void drawPicture(Picture source, int dx, int dy, int cx1, int cy1, int cx2, int cy2) {
 190             cx1 = Math.max(dx, cx1);
 191             cy1 = Math.max(dy, cy1);
 192             cx2 = Math.min(dx + source.width, cx2);
 193             cy2 = Math.min(dy + source.height, cy2);
 194             if (cx1 >= cx2 || cy1 >= cy2) return;
 195             ((X11Picture)source).init();
 196             if (((X11Picture)source).doublebuf != null)
 197                 fastDrawPicture(source, dx, dy, cx1, cy1, cx2, cy2);
 198             else
 199                 slowDrawPicture(source, dx, dy, cx1, cy1, cx2, cy2, 0, false);
 200         }
 201
 202         /** fast path for image drawing (no scaling, all-or-nothing alpha) */
 203         public native void fastDrawPicture(Picture source, int dx, int dy, int cx1, int cy1, int cx2, int cy2);
 204
 205         /** slow path for image drawing */
 206         public native void slowDrawPicture(Picture source, int dx, int dy, int cx1, int cy1, int cx2, int cy2, int rgb, boolean alphaOnly);
 207
 208         public int getWidth() { return width; }
 209         public int getHeight() { return height; }
 210         public native void natInit();
 211         public native void fillRect(int x, int y, int x2, int y2, int color);
 212         public native void finalize();
 213
 214         // FIXME: try to use os acceleration
 215         public void fillTrapezoid(int x1, int x2, int y1, int x3, int x4, int y2, int argb) {
 216             if (x1 == x3 && x2 == x4) {
 217                 fillRect(x1, y1, x4, y2, argb);
 218             } else for(int y=y1; y<y2; y++) {
 219                 int _x1 = (int)Math.floor((y - y1) * (x3 - x1) / (y2 - y1) + x1);
 220                 int _y1 = (int)Math.floor(y);
 221                 int _x2 = (int)Math.ceil((y - y1) * (x4 - x2) / (y2 - y1) + x2);
 222                 int _y2 = (int)Math.floor(y) + 1;
 223                 if (_x1 > _x2) { int _x0 = _x1; _x1 = _x2; _x2 = _x0; }
 224                 fillRect(_x1, _y1, _x2, _y2, argb);
 225             }
 226         }
 227     }
 228
 229 }