void myHideMenuBar(
GDHandle ignoredDev)
{
(void)ignoredDev;
switch (mbarstate)
{
case UNKNOWN:
case SHOWING:
mbarstate = HIDDEN;
HideMenuBar();
break;
case HIDDEN:
dprintf("HideMenuBar called while menubar was already hidden.");
break;
}
}
EXPORT(sqInt) primitiveHideMenuBar(void) {
HideMenuBar();
return null;
}
static int RLXAPI CreateSurface(int numberOfSparePages)
{
static GLint attrib[32];
GLint *pAttrib = attrib;
*pAttrib = AGL_RGBA; pAttrib++;
*pAttrib = AGL_DOUBLEBUFFER; pAttrib++;
*pAttrib = AGL_NONE; pAttrib++;
AGLPixelFormat fmt;
GLboolean ok;
g_pRLX->pGX->View.lpBackBuffer = NULL;
/* Choose an rgb pixel format */
GDHandle gdhDisplay;
ok = DMGetGDeviceByDisplayID((DisplayIDType)g_cgDisplayID, &gdhDisplay, false);
SYS_ASSERT(ok == noErr);
fmt = aglChoosePixelFormat(&gdhDisplay, 1, attrib);
SYS_AGLTRACE(0);
if(fmt == NULL)
{
ok = SYS_AGLTRACE(aglGetError());
return -1;
}
/* Create an AGL context */
g_pAGLC = aglCreateContext(fmt, NULL);
SYS_AGLTRACE(0);
if(g_pAGLC == NULL)
return -2;
/* Attach the window to the context */
ok = SYS_AGLTRACE(aglSetDrawable(g_pAGLC, GetWindowPort(g_hWnd)));
if(!ok)
return -3;
/* Make the context the current context */
ok = SYS_AGLTRACE(aglSetCurrentContext(g_pAGLC));
if(!ok)
return -4;
SizeWindow(g_hWnd, gl_lx, gl_ly, true);
if ((g_pRLX->Video.Config & RLXVIDEO_Windowed))
CenterWindow(g_hWnd);
ShowWindow(g_hWnd);
// copy portRect
GetPortBounds(GetWindowPort(g_hWnd), g_pRect);
/* Pixel format is no more needed */
aglDestroyPixelFormat(fmt);
if (!(g_pRLX->Video.Config & RLXVIDEO_Windowed))
{
HideMenuBar();
aglSetFullScreen(g_pAGLC, 0, 0, 0, 0);
GLint swap = !!(g_pRLX->pGX->View.Flags & GX_CAPS_VSYNC);
aglSetInteger(g_pAGLC, AGL_SWAP_INTERVAL, &swap);
SYS_AGLTRACE(0);
}
// Reset engine
GL_InstallExtensions();
GL_ResetViewport();
g_pRLX->pGX->Surfaces.maxSurface = numberOfSparePages;;
if (g_pRLX->pGX->View.Flags & GX_CAPS_MULTISAMPLING)
{
glEnable(GL_MULTISAMPLE_ARB);
}
return 0;
}
static int RLXAPI CreateSurface(int numberOfSparePages)
{
CGOpenGLDisplayMask displayMask = CGDisplayIDToOpenGLDisplayMask( g_cgDisplayID ) ;
static CGLPixelFormatAttribute attribs[32];
CGLPixelFormatAttribute *pAttrib = attribs;
CGLPixelFormatObj pixelFormatObj ;
long numPixelFormats = 0;
*pAttrib = kCGLPFAFullScreen; pAttrib++;
*pAttrib = kCGLPFASingleRenderer; pAttrib++;
*pAttrib = kCGLPFADisplayMask; pAttrib++;
*pAttrib = (CGLPixelFormatAttribute)displayMask; pAttrib++;
*pAttrib = kCGLPFADoubleBuffer; pAttrib++;
*pAttrib = kCGLPFAColorSize; pAttrib++;
*pAttrib = (CGLPixelFormatAttribute)gl_bpp; pAttrib++;
if ((g_pRLX->pGX->View.Flags & GX_CAPS_MULTISAMPLING))
{
*pAttrib = kCGLPFASampleBuffers; pAttrib++;
*pAttrib = (CGLPixelFormatAttribute)1; pAttrib++;
*pAttrib = kCGLPFASamples; pAttrib++;
*pAttrib = (CGLPixelFormatAttribute)g_pRLX->pGX->View.Multisampling; pAttrib++;
}
if (SYS_CGLTRACE(CGLChoosePixelFormat( attribs, &pixelFormatObj, &numPixelFormats )))
return -1;
if (!numPixelFormats)
return -2;
DEBUG_PIXEL_FORMAT(pixelFormatObj);
if (SYS_CGLTRACE(CGLCreateContext( pixelFormatObj, NULL, &g_pCGLC )))
return -3;
CGLDestroyPixelFormat( pixelFormatObj ) ;
long swapInterval = !!(g_pRLX->pGX->View.Flags & GX_CAPS_VSYNC);
SYS_CGLTRACE(CGLSetParameter( g_pCGLC, kCGLCPSwapInterval, &swapInterval));
SYS_CGLTRACE(CGLSetCurrentContext( g_pCGLC ));
if (SYS_CGLTRACE(CGLSetFullScreen( g_pCGLC )))
{
CGDisplaySwitchToMode(g_cgDisplayID, g_cgPrevDisplayMode);
CGReleaseAllDisplays();
return -5;
}
HideMenuBar();
// Reset engine
GL_InstallExtensions();
GL_ResetViewport();
g_pRLX->pGX->Surfaces.maxSurface = numberOfSparePages;;
if (g_pRLX->pGX->View.Flags & GX_CAPS_MULTISAMPLING)
{
glEnable(GL_MULTISAMPLE_ARB);
}
return 0;
}
int _glfwPlatformOpenWindow( int width,
int height,
int redbits,
int greenbits,
int bluebits,
int alphabits,
int depthbits,
int stencilbits,
int mode,
int accumredbits,
int accumgreenbits,
int accumbluebits,
int accumalphabits,
int auxbuffers,
int stereo,
int refreshrate )
{
OSStatus error;
// TO DO: Refactor this function!
_glfwWin.WindowFunctions = (mode == GLFW_FULLSCREEN ? &_glfwMacFSWindowFunctions : &_glfwMacDWWindowFunctions);
// create pixel format attribute list
GLint pixelFormatAttributes[256];
int numAttrs = 0;
pixelFormatAttributes[numAttrs++] = AGL_RGBA;
pixelFormatAttributes[numAttrs++] = AGL_DOUBLEBUFFER;
if ( mode == GLFW_FULLSCREEN )
{
pixelFormatAttributes[numAttrs++] = AGL_FULLSCREEN;
}
if ( stereo )
{
pixelFormatAttributes[numAttrs++] = AGL_STEREO;
}
_setAGLAttribute( AGL_AUX_BUFFERS, auxbuffers);
_setAGLAttribute( AGL_RED_SIZE, redbits );
_setAGLAttribute( AGL_GREEN_SIZE, greenbits );
_setAGLAttribute( AGL_BLUE_SIZE, bluebits );
_setAGLAttribute( AGL_ALPHA_SIZE, alphabits );
_setAGLAttribute( AGL_DEPTH_SIZE, depthbits );
_setAGLAttribute( AGL_STENCIL_SIZE, stencilbits );
_setAGLAttribute( AGL_ACCUM_RED_SIZE, accumredbits );
_setAGLAttribute( AGL_ACCUM_GREEN_SIZE, accumgreenbits );
_setAGLAttribute( AGL_ACCUM_BLUE_SIZE, accumbluebits );
_setAGLAttribute( AGL_ACCUM_ALPHA_SIZE, accumalphabits );
pixelFormatAttributes[numAttrs++] = AGL_NONE;
// create pixel format.
AGLDevice mainMonitor = GetMainDevice();
AGLPixelFormat pixelFormat = aglChoosePixelFormat( &mainMonitor,
1,
pixelFormatAttributes );
if ( pixelFormat == NULL )
{
return GL_FALSE;
}
// store pixel format's values for _glfwPlatformGetWindowParam's use
_getAGLAttribute( AGL_ACCELERATED, _glfwWin.Accelerated );
_getAGLAttribute( AGL_RED_SIZE, _glfwWin.RedBits );
_getAGLAttribute( AGL_GREEN_SIZE, _glfwWin.GreenBits );
_getAGLAttribute( AGL_BLUE_SIZE, _glfwWin.BlueBits );
_getAGLAttribute( AGL_ALPHA_SIZE, _glfwWin.AlphaBits );
_getAGLAttribute( AGL_DEPTH_SIZE, _glfwWin.DepthBits );
_getAGLAttribute( AGL_STENCIL_SIZE, _glfwWin.StencilBits );
_getAGLAttribute( AGL_ACCUM_RED_SIZE, _glfwWin.AccumRedBits );
_getAGLAttribute( AGL_ACCUM_GREEN_SIZE, _glfwWin.AccumGreenBits );
_getAGLAttribute( AGL_ACCUM_BLUE_SIZE, _glfwWin.AccumBlueBits );
_getAGLAttribute( AGL_ACCUM_ALPHA_SIZE, _glfwWin.AccumAlphaBits );
_getAGLAttribute( AGL_AUX_BUFFERS, _glfwWin.AuxBuffers );
_getAGLAttribute( AGL_STEREO, _glfwWin.Stereo );
_glfwWin.RefreshRate = refreshrate;
// create AGL context
_glfwWin.AGLContext = aglCreateContext( pixelFormat, NULL );
aglDestroyPixelFormat( pixelFormat );
if ( _glfwWin.AGLContext == NULL )
{
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// create window
Rect windowContentBounds;
windowContentBounds.left = 0;
windowContentBounds.top = 0;
windowContentBounds.right = width;
windowContentBounds.bottom = height;
error = CreateNewWindow( kDocumentWindowClass,
GLFW_WINDOW_ATTRIBUTES,
&windowContentBounds,
&( _glfwWin.MacWindow ) );
if ( ( error != noErr ) || ( _glfwWin.MacWindow == NULL ) )
{
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if ( !_glfwWin.Fullscreen )
{
_glfwWin.WindowUPP = NewEventHandlerUPP( _glfwWindowEventHandler );
error = InstallWindowEventHandler( _glfwWin.MacWindow,
_glfwWin.WindowUPP,
GetEventTypeCount( GLFW_WINDOW_EVENT_TYPES ),
GLFW_WINDOW_EVENT_TYPES,
NULL,
NULL );
if ( error != noErr )
{
_glfwPlatformCloseWindow();
return GL_FALSE;
}
}
// Don't care if we fail here
(void)SetWindowTitleWithCFString( _glfwWin.MacWindow, CFSTR( "GLFW Window" ) );
(void)RepositionWindow( _glfwWin.MacWindow,
NULL,
kWindowCenterOnMainScreen );
// TO DO: put this somewhere else; this is a bit too soon
ShowWindow( _glfwWin.MacWindow );
// show window, attach OpenGL context, &c
if ( mode == GLFW_FULLSCREEN )
{
CGDisplayErr cgError;
cgError = CGCaptureAllDisplays();
if ( cgError != CGDisplayNoErr )
{
_glfwPlatformCloseWindow();
return GL_FALSE;
}
HideMenuBar();
// I have no idea if this will work at all, particularly on
// multi-monitor systems. Might need to use CGL for full-screen
// setup and AGL for windowed (ugh!).
if ( !aglSetFullScreen( _glfwWin.AGLContext,
width,
height,
refreshrate,
0 ) )
{
_glfwPlatformCloseWindow();
return GL_FALSE;
}
}
else
{
if ( !aglSetDrawable( _glfwWin.AGLContext,
GetWindowPort( _glfwWin.MacWindow ) ) )
{
_glfwPlatformCloseWindow();
return GL_FALSE;
}
}
// Make OpenGL context current;
if ( !aglSetCurrentContext( _glfwWin.AGLContext ) )
{
_glfwPlatformCloseWindow();
return GL_FALSE;
}
return GL_TRUE;
}
