--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/macosx/native/sun/java2d/opengl/CGLSurfaceData.m Tue Mar 06 20:34:38 2012 +0000
@@ -0,0 +1,593 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#import <stdlib.h>
+#import <JavaNativeFoundation/JavaNativeFoundation.h>
+
+#import "sun_java2d_opengl_CGLSurfaceData.h"
+
+#import "jni.h"
+#import "jni_util.h"
+#import "OGLRenderQueue.h"
+#import "CGLGraphicsConfig.h"
+#import "CGLSurfaceData.h"
+#import "CGLLayer.h"
+#import "ThreadUtilities.h"
+
+/* JDK's glext.h is already included and will prevent the Apple glext.h
+ * being included, so define the externs directly
+ */
+extern void glBindFramebufferEXT(GLenum target, GLuint framebuffer);
+extern CGLError CGLTexImageIOSurface2D(
+ CGLContextObj ctx, GLenum target, GLenum internal_format,
+ GLsizei width, GLsizei height, GLenum format, GLenum type,
+ IOSurfaceRef ioSurface, GLuint plane);
+
+/**
+ * The methods in this file implement the native windowing system specific
+ * layer (CGL) for the OpenGL-based Java 2D pipeline.
+ */
+
+#pragma mark -
+#pragma mark "--- Mac OS X specific methods for GL pipeline ---"
+
+// TODO: hack that's called from OGLRenderQueue to test out unlockFocus behavior
+#if 0
+void
+OGLSD_UnlockFocus(OGLContext *oglc, OGLSDOps *dstOps)
+{
+ CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
+ CGLSDOps *cglsdo = (CGLSDOps *)dstOps->privOps;
+ fprintf(stderr, "about to unlock focus: %p %p\n",
+ cglsdo->peerData, ctxinfo->context);
+
+ NSOpenGLView *nsView = cglsdo->peerData;
+ if (nsView != NULL) {
+JNF_COCOA_ENTER(env);
+ [nsView unlockFocus];
+JNF_COCOA_EXIT(env);
+ }
+}
+#endif
+
+/**
+ * Makes the given context current to its associated "scratch" surface. If
+ * the operation is successful, this method will return JNI_TRUE; otherwise,
+ * returns JNI_FALSE.
+ */
+static jboolean
+CGLSD_MakeCurrentToScratch(JNIEnv *env, OGLContext *oglc)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "CGLSD_MakeCurrentToScratch");
+
+ if (oglc == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR,
+ "CGLSD_MakeCurrentToScratch: context is null");
+ return JNI_FALSE;
+ }
+
+JNF_COCOA_ENTER(env);
+
+ CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
+#if USE_NSVIEW_FOR_SCRATCH
+ [ctxinfo->context makeCurrentContext];
+ [ctxinfo->context setView: ctxinfo->scratchSurface];
+#else
+ [ctxinfo->context clearDrawable];
+ [ctxinfo->context makeCurrentContext];
+ [ctxinfo->context setPixelBuffer: ctxinfo->scratchSurface
+ cubeMapFace: 0
+ mipMapLevel: 0
+ currentVirtualScreen: [ctxinfo->context currentVirtualScreen]];
+#endif
+
+JNF_COCOA_EXIT(env);
+
+ return JNI_TRUE;
+}
+
+/**
+ * This function disposes of any native windowing system resources associated
+ * with this surface. For instance, if the given OGLSDOps is of type
+ * OGLSD_PBUFFER, this method implementation will destroy the actual pbuffer
+ * surface.
+ */
+void
+OGLSD_DestroyOGLSurface(JNIEnv *env, OGLSDOps *oglsdo)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "OGLSD_DestroyOGLSurface");
+
+JNF_COCOA_ENTER(env);
+
+ CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
+ if (oglsdo->drawableType == OGLSD_PBUFFER) {
+ if (oglsdo->textureID != 0) {
+ j2d_glDeleteTextures(1, &oglsdo->textureID);
+ oglsdo->textureID = 0;
+ }
+ if (cglsdo->pbuffer != NULL) {
+ [cglsdo->pbuffer release];
+ cglsdo->pbuffer = NULL;
+ }
+ } else if (oglsdo->drawableType == OGLSD_WINDOW) {
+ // detach the NSView from the NSOpenGLContext
+ CGLGraphicsConfigInfo *cglInfo = cglsdo->configInfo;
+ OGLContext *oglc = cglInfo->context;
+ CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
+ [ctxinfo->context clearDrawable];
+ }
+
+ oglsdo->drawableType = OGLSD_UNDEFINED;
+
+JNF_COCOA_EXIT(env);
+}
+
+/**
+ * Returns a pointer (as a jlong) to the native CGLGraphicsConfigInfo
+ * associated with the given OGLSDOps. This method can be called from
+ * shared code to retrieve the native GraphicsConfig data in a platform-
+ * independent manner.
+ */
+jlong
+OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "OGLSD_GetNativeConfigInfo");
+
+ if (oglsdo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: ops are null");
+ return 0L;
+ }
+
+ CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
+ if (cglsdo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_GetNativeConfigInfo: cgl ops are null");
+ return 0L;
+ }
+
+ return ptr_to_jlong(cglsdo->configInfo);
+}
+
+/**
+ * Makes the given GraphicsConfig's context current to its associated
+ * "scratch" surface. If there is a problem making the context current,
+ * this method will return NULL; otherwise, returns a pointer to the
+ * OGLContext that is associated with the given GraphicsConfig.
+ */
+OGLContext *
+OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext");
+
+ CGLGraphicsConfigInfo *cglInfo = (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
+ if (cglInfo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_SetScratchContext: cgl config info is null");
+ return NULL;
+ }
+
+ OGLContext *oglc = cglInfo->context;
+ CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
+
+JNF_COCOA_ENTER(env);
+
+ // avoid changing the context's target view whenever possible, since
+ // calling setView causes flickering; as long as our context is current
+ // to some view, it's not necessary to switch to the scratch surface
+ if ([ctxinfo->context view] == nil) {
+ // it seems to be necessary to explicitly flush between context changes
+ OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
+ if (currentContext != NULL) {
+ j2d_glFlush();
+ }
+
+ if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
+ return NULL;
+ }
+ } else if ([NSOpenGLContext currentContext] == nil) {
+ [ctxinfo->context makeCurrentContext];
+ }
+
+ if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
+ // the GL_EXT_framebuffer_object extension is present, so this call
+ // will ensure that we are bound to the scratch surface (and not
+ // some other framebuffer object)
+ j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+ }
+
+JNF_COCOA_EXIT(env);
+
+ return oglc;
+}
+
+/**
+ * Makes a context current to the given source and destination
+ * surfaces. If there is a problem making the context current, this method
+ * will return NULL; otherwise, returns a pointer to the OGLContext that is
+ * associated with the destination surface.
+ */
+OGLContext *
+OGLSD_MakeOGLContextCurrent(JNIEnv *env, OGLSDOps *srcOps, OGLSDOps *dstOps)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "OGLSD_MakeOGLContextCurrent");
+
+ CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
+
+ J2dTraceLn4(J2D_TRACE_VERBOSE, " src: %d %p dst: %d %p", srcOps->drawableType, srcOps, dstOps->drawableType, dstOps);
+
+ OGLContext *oglc = dstCGLOps->configInfo->context;
+ if (oglc == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_MakeOGLContextCurrent: context is null");
+ return NULL;
+ }
+
+ CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
+
+ // it seems to be necessary to explicitly flush between context changes
+ OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
+ if (currentContext != NULL) {
+ j2d_glFlush();
+ }
+
+ if (dstOps->drawableType == OGLSD_FBOBJECT) {
+ // first make sure we have a current context (if the context isn't
+ // already current to some drawable, we will make it current to
+ // its scratch surface)
+ if (oglc != currentContext) {
+ if (!CGLSD_MakeCurrentToScratch(env, oglc)) {
+ return NULL;
+ }
+ }
+
+ // now bind to the fbobject associated with the destination surface;
+ // this means that all rendering will go into the fbobject destination
+ // (note that we unbind the currently bound texture first; this is
+ // recommended procedure when binding an fbobject)
+ j2d_glBindTexture(GL_TEXTURE_2D, 0);
+ j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dstOps->fbobjectID);
+
+ return oglc;
+ }
+
+JNF_COCOA_ENTER(env);
+
+ // set the current surface
+ if (dstOps->drawableType == OGLSD_PBUFFER) {
+ // REMIND: pbuffers are not fully tested yet...
+ [ctxinfo->context clearDrawable];
+ [ctxinfo->context makeCurrentContext];
+ [ctxinfo->context setPixelBuffer: dstCGLOps->pbuffer
+ cubeMapFace: 0
+ mipMapLevel: 0
+ currentVirtualScreen: [ctxinfo->context currentVirtualScreen]];
+ } else {
+ CGLSDOps *cglsdo = (CGLSDOps *)dstOps->privOps;
+ NSView *nsView = (NSView *)cglsdo->peerData;
+
+ if ([ctxinfo->context view] != nsView) {
+ [ctxinfo->context makeCurrentContext];
+ [ctxinfo->context setView: nsView];
+ }
+ }
+
+ if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
+ // the GL_EXT_framebuffer_object extension is present, so we
+ // must bind to the default (windowing system provided)
+ // framebuffer
+ j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+ }
+
+ if ((srcOps != dstOps) && (srcOps->drawableType == OGLSD_PBUFFER)) {
+ // bind pbuffer to the render texture object (since we are preparing
+ // to copy from the pbuffer)
+ CGLSDOps *srcCGLOps = (CGLSDOps *)srcOps->privOps;
+ j2d_glBindTexture(GL_TEXTURE_2D, srcOps->textureID);
+ [ctxinfo->context
+ setTextureImageToPixelBuffer: srcCGLOps->pbuffer
+ colorBuffer: GL_FRONT];
+ }
+
+JNF_COCOA_EXIT(env);
+
+ return oglc;
+}
+
+/**
+ * This function initializes a native window surface and caches the window
+ * bounds in the given OGLSDOps. Returns JNI_TRUE if the operation was
+ * successful; JNI_FALSE otherwise.
+ */
+jboolean
+OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow");
+
+ if (oglsdo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: ops are null");
+ return JNI_FALSE;
+ }
+
+ CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
+ if (cglsdo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: cgl ops are null");
+ return JNI_FALSE;
+ }
+
+ AWTView *v = cglsdo->peerData;
+ if (v == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "OGLSD_InitOGLWindow: view is invalid");
+ return JNI_FALSE;
+ }
+
+JNF_COCOA_ENTER(env);
+ NSRect surfaceBounds = [v bounds];
+ oglsdo->drawableType = OGLSD_WINDOW;
+ oglsdo->isOpaque = JNI_TRUE;
+ oglsdo->width = surfaceBounds.size.width;
+ oglsdo->height = surfaceBounds.size.height;
+JNF_COCOA_EXIT(env);
+
+ J2dTraceLn2(J2D_TRACE_VERBOSE, " created window: w=%d h=%d", oglsdo->width, oglsdo->height);
+
+ return JNI_TRUE;
+}
+
+void
+OGLSD_SwapBuffers(JNIEnv *env, jlong pPeerData)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers");
+
+JNF_COCOA_ENTER(env);
+ [[NSOpenGLContext currentContext] flushBuffer];
+JNF_COCOA_EXIT(env);
+}
+
+void
+OGLSD_Flush(JNIEnv *env)
+{
+ OGLSDOps *dstOps = OGLRenderQueue_GetCurrentDestination();
+ if (dstOps != NULL) {
+ CGLSDOps *dstCGLOps = (CGLSDOps *)dstOps->privOps;
+ CGLLayer *layer = (CGLLayer*)dstCGLOps->layer;
+ if (layer != NULL) {
+ [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^(){
+ AWT_ASSERT_APPKIT_THREAD;
+ [layer setNeedsDisplay];
+
+#ifdef REMOTELAYER
+ /* If there's a remote layer (being used for testing)
+ * then we want to have that also receive the texture.
+ * First sync. up its dimensions with that of the layer
+ * we have attached to the local window and tell it that
+ * it also needs to copy the texture.
+ */
+ if (layer.remoteLayer != nil) {
+ CGLLayer* remoteLayer = layer.remoteLayer;
+ remoteLayer.target = GL_TEXTURE_2D;
+ remoteLayer.textureID = layer.textureID;
+ remoteLayer.textureWidth = layer.textureWidth;
+ remoteLayer.textureHeight = layer.textureHeight;
+ [remoteLayer setNeedsDisplay];
+ }
+#endif /* REMOTELAYER */
+ }];
+ }
+ }
+}
+
+#pragma mark -
+#pragma mark "--- CGLSurfaceData methods ---"
+
+extern LockFunc OGLSD_Lock;
+extern GetRasInfoFunc OGLSD_GetRasInfo;
+extern UnlockFunc OGLSD_Unlock;
+extern DisposeFunc OGLSD_Dispose;
+
+JNIEXPORT void JNICALL
+Java_sun_java2d_opengl_CGLSurfaceData_initOps
+ (JNIEnv *env, jobject cglsd,
+ jlong pConfigInfo, jlong pPeerData, jlong layerPtr,
+ jint xoff, jint yoff, jboolean isOpaque)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "CGLSurfaceData_initOps");
+ J2dTraceLn1(J2D_TRACE_INFO, " pPeerData=%p", jlong_to_ptr(pPeerData));
+ J2dTraceLn2(J2D_TRACE_INFO, " xoff=%d, yoff=%d", (int)xoff, (int)yoff);
+
+ OGLSDOps *oglsdo = (OGLSDOps *)
+ SurfaceData_InitOps(env, cglsd, sizeof(OGLSDOps));
+ CGLSDOps *cglsdo = (CGLSDOps *)malloc(sizeof(CGLSDOps));
+ if (cglsdo == NULL) {
+ JNU_ThrowOutOfMemoryError(env, "creating native cgl ops");
+ return;
+ }
+
+ oglsdo->privOps = cglsdo;
+
+ oglsdo->sdOps.Lock = OGLSD_Lock;
+ oglsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
+ oglsdo->sdOps.Unlock = OGLSD_Unlock;
+ oglsdo->sdOps.Dispose = OGLSD_Dispose;
+
+ oglsdo->drawableType = OGLSD_UNDEFINED;
+ oglsdo->activeBuffer = GL_FRONT;
+ oglsdo->needsInit = JNI_TRUE;
+ oglsdo->xOffset = xoff;
+ oglsdo->yOffset = yoff;
+ oglsdo->isOpaque = isOpaque;
+
+ cglsdo->peerData = (AWTView *)jlong_to_ptr(pPeerData);
+ cglsdo->layer = (CGLLayer *)jlong_to_ptr(layerPtr);
+ cglsdo->configInfo = (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
+
+ if (cglsdo->configInfo == NULL) {
+ free(cglsdo);
+ JNU_ThrowNullPointerException(env, "Config info is null in initOps");
+ }
+}
+
+JNIEXPORT void JNICALL
+Java_sun_java2d_opengl_CGLSurfaceData_clearWindow
+(JNIEnv *env, jobject cglsd)
+{
+ J2dTraceLn(J2D_TRACE_INFO, "CGLSurfaceData_clearWindow");
+
+ OGLSDOps *oglsdo = (OGLSDOps*) SurfaceData_GetOps(env, cglsd);
+ CGLSDOps *cglsdo = (CGLSDOps*) oglsdo->privOps;
+
+ cglsdo->peerData = NULL;
+ cglsdo->layer = NULL;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_sun_java2d_opengl_CGLSurfaceData_initPbuffer
+ (JNIEnv *env, jobject cglsd,
+ jlong pData, jlong pConfigInfo, jboolean isOpaque,
+ jint width, jint height)
+{
+ J2dTraceLn3(J2D_TRACE_INFO, "CGLSurfaceData_initPbuffer: w=%d h=%d opq=%d", width, height, isOpaque);
+
+ OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
+ if (oglsdo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: ops are null");
+ return JNI_FALSE;
+ }
+
+ CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
+ if (cglsdo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: cgl ops are null");
+ return JNI_FALSE;
+ }
+
+ CGLGraphicsConfigInfo *cglInfo = (CGLGraphicsConfigInfo *)
+ jlong_to_ptr(pConfigInfo);
+ if (cglInfo == NULL) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: cgl config info is null");
+ return JNI_FALSE;
+ }
+
+ // find the maximum allowable texture dimensions (this value ultimately
+ // determines our maximum pbuffer size)
+ int pbMax = 0;
+ j2d_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &pbMax);
+
+ int pbWidth = 0;
+ int pbHeight = 0;
+ if (OGLC_IS_CAP_PRESENT(cglInfo->context, CAPS_TEXNONPOW2)) {
+ // use non-power-of-two dimensions directly
+ pbWidth = (width <= pbMax) ? width : 0;
+ pbHeight = (height <= pbMax) ? height : 0;
+ } else {
+ // find the appropriate power-of-two dimensions
+ pbWidth = OGLSD_NextPowerOfTwo(width, pbMax);
+ pbHeight = OGLSD_NextPowerOfTwo(height, pbMax);
+ }
+
+ J2dTraceLn3(J2D_TRACE_VERBOSE, " desired pbuffer dimensions: w=%d h=%d max=%d", pbWidth, pbHeight, pbMax);
+
+ // if either dimension is 0, we cannot allocate a pbuffer/texture with the
+ // requested dimensions
+ if (pbWidth == 0 || pbHeight == 0) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: dimensions too large");
+ return JNI_FALSE;
+ }
+
+ int format = isOpaque ? GL_RGB : GL_RGBA;
+
+JNF_COCOA_ENTER(env);
+
+ cglsdo->pbuffer =
+ [[NSOpenGLPixelBuffer alloc]
+ initWithTextureTarget: GL_TEXTURE_2D
+ textureInternalFormat: format
+ textureMaxMipMapLevel: 0
+ pixelsWide: pbWidth
+ pixelsHigh: pbHeight];
+ if (cglsdo->pbuffer == nil) {
+ J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: could not create pbuffer");
+ return JNI_FALSE;
+ }
+
+ // make sure the actual dimensions match those that we requested
+ GLsizei actualWidth = [cglsdo->pbuffer pixelsWide];
+ GLsizei actualHeight = [cglsdo->pbuffer pixelsHigh];
+ if (actualWidth != pbWidth || actualHeight != pbHeight) {
+ J2dRlsTraceLn2(J2D_TRACE_ERROR, "CGLSurfaceData_initPbuffer: actual (w=%d h=%d) != requested", actualWidth, actualHeight);
+ [cglsdo->pbuffer release];
+ return JNI_FALSE;
+ }
+
+ GLuint texID = 0;
+ j2d_glGenTextures(1, &texID);
+ j2d_glBindTexture(GL_TEXTURE_2D, texID);
+
+ oglsdo->drawableType = OGLSD_PBUFFER;
+ oglsdo->isOpaque = isOpaque;
+ oglsdo->width = width;
+ oglsdo->height = height;
+ oglsdo->textureID = texID;
+ oglsdo->textureWidth = pbWidth;
+ oglsdo->textureHeight = pbHeight;
+ oglsdo->activeBuffer = GL_FRONT;
+ oglsdo->needsInit = JNI_TRUE;
+
+ OGLSD_INIT_TEXTURE_FILTER(oglsdo, GL_NEAREST);
+
+JNF_COCOA_EXIT(env);
+
+ return JNI_TRUE;
+}
+
+#pragma mark -
+#pragma mark "--- CGLSurfaceData methods - Mac OS X specific ---"
+
+// Must be called on the QFT...
+JNIEXPORT void JNICALL
+Java_sun_java2d_opengl_CGLSurfaceData_validate
+ (JNIEnv *env, jobject jsurfacedata,
+ jint xoff, jint yoff, jint width, jint height, jboolean isOpaque)
+{
+ J2dTraceLn2(J2D_TRACE_INFO, "CGLSurfaceData_validate: w=%d h=%d", width, height);
+
+ OGLSDOps *oglsdo = (OGLSDOps*)SurfaceData_GetOps(env, jsurfacedata);
+ oglsdo->needsInit = JNI_TRUE;
+ oglsdo->xOffset = xoff;
+ oglsdo->yOffset = yoff;
+
+ oglsdo->width = width;
+ oglsdo->height = height;
+ oglsdo->isOpaque = isOpaque;
+
+ if (oglsdo->drawableType == OGLSD_WINDOW) {
+ OGLContext_SetSurfaces(env, ptr_to_jlong(oglsdo), ptr_to_jlong(oglsdo));
+
+ // we have to explicitly tell the NSOpenGLContext that its target
+ // drawable has changed size
+ CGLSDOps *cglsdo = (CGLSDOps *)oglsdo->privOps;
+ OGLContext *oglc = cglsdo->configInfo->context;
+ CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
+
+JNF_COCOA_ENTER(env);
+ [ctxinfo->context update];
+JNF_COCOA_EXIT(env);
+ }
+}