src/org/ibex/plat/Darwin.java

   1 // Copyright 2004 Adam Megacz, see the COPYING file for licensing [LGPL]
   2 // Authors: Brian Alliet and Evan Jones
   3
   4 package org.ibex.plat;
   5
   6 import gnu.gcj.RawData;
   7 import org.ibex.util.*;
   8 import org.ibex.js.*;
   9 import org.ibex.*;
  10 import org.ibex.graphics.*;
  11 import org.ibex.core.*;
  12 import org.ibex.net.*;
  13
  14 public class Darwin extends POSIX {
  15     private static final Class openGLClass = OpenGL.class;
  16     static Darwin singleton;
  17     private CarbonOpenGL openGL;
  18     boolean jaguar; // true if we are on OS X >= 10.2
  19
  20     // General Methods
  21     protected String _getAltKeyName() { return "Option"; }
  22     protected boolean _needsAutoClick() { return false; }
  23     protected boolean _needsAutoDoubleClick() { return false; }
  24     protected String getDescriptiveName() { return "GCJ Darwin Binary"; }
  25     protected boolean _isCaseSensitive() { return false; /* Well, not always, could be UFS */ }
  26
  27
  28     // Native Methods
  29     protected int    _getScreenWidth() { return cgScreenWidth(); }
  30     protected int    _getScreenHeight() { return cgScreenHeight(); }
  31     private native static int cgScreenWidth();
  32     private native static int cgScreenHeight();
  33     protected native void   _newBrowserWindow(String url);
  34     protected native HTTP.Proxy   natDetectProxy();
  35     private   native void    natInit();
  36
  37     private native String natGetClipBoard();
  38     private native void natSetClipBoard(String text);
  39     protected void _setClipBoard(final String text) { CarbonMessage.add(new CarbonMessage() { public void perform() { natSetClipBoard(text); } }); }
  40     protected String _getClipBoard() {
  41         final Semaphore sem = new Semaphore();
  42         final String[] result = new String[1]; // Kind of like a pointer
  43         CarbonMessage.add(new CarbonMessage() { public void perform() { result[0] = natGetClipBoard(); sem.release(); } });
  44         sem.block();
  45         return result[0];
  46     }
  47
  48     private static class FileDialogHelper {
  49         public FileDialogHelper(boolean save) { this.save = save; }
  50         public boolean save;
  51         public Semaphore sem = new Semaphore();
  52         public String fileName;
  53         public String saveName;
  54     }
  55     private native void natFileDialog(FileDialogHelper helper, String suggestedFileName, boolean write);
  56     protected String _fileDialog(final String fn, final boolean w) {
  57         final FileDialogHelper helper = new FileDialogHelper(w);
  58         CarbonMessage.add(new CarbonMessage() { public void perform() { natFileDialog(helper,fn,w); } });
  59         helper.sem.block();
  60         if(w)
  61             return helper.fileName + "/" + helper.saveName;
  62         else
  63             return helper.fileName;
  64     }
  65
  66
  67     static void abort(String err) {
  68         throw new Error(err);
  69     }
  70
  71     public Darwin() {
  72         synchronized(Darwin.class) {
  73             if(singleton != null) abort("Tried to instansiate Darwin more than once");
  74             singleton = this;
  75         }
  76     }
  77
  78     protected synchronized HTTP.Proxy _detectProxy() {
  79         return natDetectProxy();
  80     }
  81
  82     private static native final boolean isJaguar();
  83
  84     public void postInit() {
  85         jaguar = isJaguar();
  86         try {
  87             openGL = new CarbonOpenGL();
  88             openGL.init();
  89         } catch(OpenGL.NotSupportedException e) {
  90             Log.info(this,"WARNING: OpenGL support not available: " + e);
  91             // FEATURE: fall back to quartz 2d
  92             throw new Error("No OpenGL support");
  93         }
  94         natInit();
  95     }
  96
  97     protected Scheduler _getScheduler() { return new DarwinScheduler(); }
  98     protected native void runApplicationEventLoop();
  99     private class DarwinScheduler extends org.ibex.Scheduler {
 100         public void run() {
 101             new Thread() { public void run() { defaultRun(); } }.start();
 102             runApplicationEventLoop();
 103         }
 104     }
 105
 106     private final class CarbonOpenGL extends OpenGL {
 107         public RawData rawPixelFormat;
 108         public RawData rawSharedContext;
 109         public int maxAglSurfaceTexSize;
 110         public int maxSurfaceWidth;
 111         public int maxSurfaceHeight;
 112
 113         private native boolean initPixelFormat();
 114         private native void initSharedContext();
 115
 116         public CarbonOpenGL() throws NotSupportedException {
 117             if(!jaguar)
 118                 throw new NotSupportedException("OpenGL requires Mac OS X 10.2 or greater");
 119             if(!initPixelFormat())
 120                 throw new NotSupportedException("Couldn't get an acceptable pixel format");
 121             initSharedContext();
 122         }
 123
 124         public void init() throws NotSupportedException {
 125             super.init();
 126             maxAglSurfaceTexSize = rectangularTextures ? maxRectTexSize : maxTexSize;
 127             if(renderer.startsWith("ATI Radeon 7500")) {
 128                 maxAglSurfaceTexSize = Math.min(rectangularTextures ? 1600 : 1024,maxAglSurfaceTexSize);
 129                 Log.info(this,"Working around Radeon 7500 bug: maxAglSurfaceTexSize: " + maxAglSurfaceTexSize);
 130             }
 131             maxSurfaceWidth = maxSurfaceHeight = maxAglSurfaceTexSize;
 132         }
 133         protected native void activateSharedContext();
 134     }
 135
 136     static abstract class CarbonSurface extends Surface.DoubleBufferedSurface {
 137         RawData rawWindowRef;
 138         int modifiers;
 139         int winWidth;
 140         int winHeight;
 141
 142         boolean pendingResize;
 143
 144         private native void natSetInvisible(boolean i);
 145         public void setInvisible(final boolean i) { CarbonMessage.add(new CarbonMessage() { public void perform() { natSetInvisible(i); } }); }
 146         private native void nat_setMaximized(boolean b);
 147         public void _setMaximized(final boolean b) { CarbonMessage.add(new CarbonMessage() { public void perform() { nat_setMaximized(b); } }); }
 148         private native void nat_setMinimized(boolean b);
 149         public void _setMinimized(final boolean b) { CarbonMessage.add(new CarbonMessage() { public void perform() { nat_setMinimized(b); } }); }
 150         private native void natSetIcon(Picture p);
 151         public void setIcon(final Picture p) { CarbonMessage.add(new CarbonMessage() { public void perform() { natSetIcon(p); } }); }
 152         private native void natSetTitleBarText(String s);
 153         public void setTitleBarText(final String s) { CarbonMessage.add(new CarbonMessage() { public void perform() { natSetTitleBarText(s); } }); }
 154         private native void natSetSize(int w, int h);
 155         public void _setSize(final int w, final int h) { CarbonMessage.add(new CarbonMessage() { public void perform() { natSetSize(w,h); } }); }
 156         private native void natSetLocation();
 157         public void setLocation() { CarbonMessage.add(new CarbonMessage() { public void perform() { natSetLocation(); } }); }
 158         private native void natToFront();
 159         public void toFront() { CarbonMessage.add(new CarbonMessage() { public void perform() { natToFront(); } }); }
 160         private native void natToBack();
 161         public void toBack() { CarbonMessage.add(new CarbonMessage() { public void perform() { natToBack(); } }); }
 162         private native void natSetLimits(int minWidth, int minHeight, int maxWidth, int maxHeight);
 163         public void setLimits(final int mnw, final int mnh, final int mxw, final int mxh) {
 164             if(Darwin.singleton.jaguar)
 165                 CarbonMessage.add(new CarbonMessage() { public void perform() { natSetLimits(mnw,mnh,mxw,mxh); } });
 166         }
 167         private native void natSyncCursor(int n);
 168         public void syncCursor() {
 169             int n;
 170             if(cursor.equals("default")) n = 0;
 171             else if(cursor.equals("wait")) n = 1;
 172             else if(cursor.equals("crosshair")) n = 2;
 173             else if(cursor.equals("text")) n = 3;
 174             else if(cursor.equals("hand")) n = 4;
 175             else if(cursor.equals("move")) n = 5;
 176             else if(cursor.equals("east") || cursor.equals("west")) n = 6;
 177             else n = 0;
 178             final int n_ = n;
 179             CarbonMessage.add(new CarbonMessage() { public void perform() { natSyncCursor(n_); } });
 180         }
 181
 182         /* Drawing stuff */
 183         public abstract void blit(PixelBuffer s, int sx, int sy, int dx, int dy, int dx2, int dy2);
 184
 185         public final void _dispose() { CarbonMessage.add(new CarbonMessage() { public void perform() { natDispose(); } }); }
 186         public native void natDispose();
 187
 188         public final native void natInit(boolean framed);
 189
 190         public CarbonSurface(Box root, final boolean framed) {
 191             super(root);
 192             final Semaphore sem = new Semaphore();
 193             CarbonMessage.add(new CarbonMessage() { public void perform() { CarbonSurface.this.natInit(framed); sem.release(); } });
 194             sem.block();
 195         }
 196
 197         public void needsReshape() { }
 198         protected static native void blitLock();
 199         protected static native void blitUnlock();
 200         protected static native void blitWait();
 201     }
 202
 203     static class GLCarbonPixelBuffer extends OpenGL.GLPixelBuffer {
 204         RawData rawCTX;
 205         RawData rawWindowRef;
 206         int textureName;
 207         boolean rectTexture;
 208         CarbonOpenGL gl;
 209
 210         private native void natInit();
 211         private static native void natCleanup(RawData rawWindowRef, RawData rawCTX);
 212
 213
 214         private static final int fixupDimension(CarbonOpenGL gl, int n) {
 215             if(!gl.rectangularTextures) n = OpenGL.roundToPowerOf2(n);
 216             return Math.min(n,gl.maxAglSurfaceTexSize);
 217         }
 218         public GLCarbonPixelBuffer(int w, int h, final CarbonOpenGL gl) {
 219             super(fixupDimension(gl,w),fixupDimension(gl,h));
 220             this.gl = gl;
 221             rectTexture = gl.hasRectangularTextures();
 222             final Semaphore sem = new Semaphore();
 223             CarbonMessage.add(new CarbonMessage() { public void perform() { GLCarbonPixelBuffer.this.natInit(); sem.release(); } });
 224             sem.block();
 225         }
 226         public native void activateContext();
 227         protected void finalize() {
 228             CarbonMessage.add(new CarbonMessage() { public void perform() { natCleanup(rawWindowRef,rawCTX); } });
 229             gl.deleteTexture(textureName);
 230         }
 231     }
 232
 233     static class GLCarbonSurface extends CarbonSurface {
 234         RawData rawCTX;
 235         CarbonOpenGL gl;
 236         boolean needsReshape;
 237
 238         private final native void natInit();
 239         private final native void flush();
 240         private final native void clear();
 241
 242         public GLCarbonSurface(Box root, boolean framed, CarbonOpenGL gl) {
 243             super(root,framed);
 244             this.gl = gl;
 245             natInit();
 246         }
 247
 248         public void setLimits(int mnw,int mnh, int mxw, int mxh) {
 249             mxw = Math.min(mxw,gl.maxSurfaceWidth);
 250             mxh = Math.min(mxh,gl.maxSurfaceHeight);
 251             super.setLimits(mnw,mnh,mxw,mxh);
 252         }
 253
 254         public void _setSize(int w, int h) {
 255             w = Math.min(w,gl.maxSurfaceWidth);
 256             h = Math.min(h,gl.maxSurfaceWidth);
 257             super._setSize(w,h);
 258         }
 259
 260         private native void natBlit(GLCarbonPixelBuffer db, int sx, int sy, int dx, int dy, int dx2, int dy2);
 261         public void blit(PixelBuffer db, int sx, int sy, int dx, int dy, int dx2, int dy2) {
 262             natBlit((GLCarbonPixelBuffer)db,sx,sy,dx,dy,dx2,dy2);
 263         }
 264
 265
 266         // The blit_lock ensures the window size does not change through the entire blit operation.
 267         public void render() {
 268             /*
 269             blitLock();
 270             while(pendingResize) blitWait();
 271             */
 272             if(needsReshape) {
 273                 needsReshape = false;
 274
 275                 reshape(winWidth,winHeight);
 276                 clear();
 277                 Dirty(0,0,winWidth,winHeight);
 278             }
 279             super.render();
 280             flush();
 281             /*
 282             blitUnlock();
 283             */
 284         }
 285
 286         private native void reshape(int w, int h);
 287         // blit_lock is assumed to be held
 288         public void needsReshape() { needsReshape = true; }
 289
 290         public native void natDispose();
 291     }
 292
 293     /*private class QZCarbonPixelBuffer extends PixelBuffer {
 294
 295         public QZCarbonPixelBuffer(int width, int height) {
 296         }
 297     }
 298        private class QZCarbonSurface extends CarbonSurface {
 299         public QZCarbonSurface(Box root, boolean framed) {
 300             super(b,root);
 301         }
 302         public native void blit(PixelBuffer s, int sx, int sy, int dx, int dy, int dx2, int dy2);
 303     }
 304
 305     private class QZCarbonPicture extends Picture {
 306         int width;
 307         int height;
 308
 309         public final int getWidth() { return width; }
 310         public final int getHeight() { return height; }
 311
 312         public QZCarbonPicture(int w, int h) {
 313             this.width = w;
 314             this.height = h;
 315         }
 316     }*/
 317
 318     protected PixelBuffer _createPixelBuffer(int w, int h, Surface owner) {
 319         if(openGL != null)
 320             return new GLCarbonPixelBuffer(w,h,openGL);
 321         else
 322             return /*new QZCarbonPixelBuffer(w,h)*/ null;
 323     }
 324     protected Surface _createSurface(Box b, boolean framed) {
 325         if(openGL != null)
 326             return new GLCarbonSurface(b,framed, openGL);
 327         else
 328             return /*new QZCarbonSufrace(b,framed)*/ null;
 329     }
 330     protected Picture _createPicture(JS r) {
 331         if(openGL != null)
 332             return openGL._createPicture(r, true);
 333         else
 334             return /*new QZCarbonPicture(data,w,h);*/ null;
 335     }
 336     protected org.ibex.Font.Glyph  _createGlyph(org.ibex.Font f, char c) {
 337         if(openGL != null)
 338             return openGL._createGlyph(f, c);
 339         else
 340             return super.createGlyph(f, c);
 341     }
 342
 343     /* A message that is sent through the carbon event queue */
 344     private static abstract class CarbonMessage {
 345         public abstract void perform();
 346
 347         static { natInit(); }
 348         public static native void natInit();
 349         public static native void add(CarbonMessage m);
 350     }
 351 }