mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-10 00:51:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:elmindreda/glfw

Browse Source
This commit is contained in:
Camilla Berglund 2013-01-16 20:33:24 +01:00
commit c00839e4d7
20 changed files with 320 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -12,7 +12,6 @@ set(LIB_SUFFIX "" CACHE STRING "Takes an empty string or 64. Directory where lib
option(GLFW_BUILD_EXAMPLES "Build the GLFW example programs" ON)
option(GLFW_BUILD_TESTS "Build the GLFW test programs" ON)
option(GLFW_NATIVE_API "Build the GLFW native API" OFF)
option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
if (NOT APPLE)
@ -355,12 +354,7 @@ configure_file(${GLFW_SOURCE_DIR}/src/config.h.in
# The src directory's CMakeLists.txt file installs the library
#--------------------------------------------------------------------
install(DIRECTORY include/GL DESTINATION include
FILES_MATCHING PATTERN glfw3.h)
if (GLFW_NATIVE_API)
install(DIRECTORY include/GL DESTINATION include
FILES_MATCHING PATTERN glfw3native.h)
endif()
FILES_MATCHING PATTERN glfw3.h PATTERN glfw3native.h)
install(FILES COPYING.txt readme.html
DESTINATION share/doc/glfw-${GLFW_VERSION_FULL})

77
include/GL/glfw3native.h
View File

@ -51,29 +51,30 @@ extern "C" {
* System headers and types
*************************************************************************/
#if defined(GLFW_EXPOSE_NATIVE_WIN32_WGL)
/* We are building for Win32 and WGL */
#if defined(GLFW_EXPOSE_NATIVE_WIN32)
#include <windows.h>
#elif defined(GLFW_EXPOSE_NATIVE_COCOA_NSGL)
/* We are building for Cocoa and NSOpenGL */
#elif defined(GLFW_EXPOSE_NATIVE_COCOA)
#if defined(__OBJC__)
#import <Cocoa/Cocoa.h>
#else
typedef void* id;
#endif
#elif defined(GLFW_EXPOSE_NATIVE_X11_GLX)
/* We are building for X11 and GLX */
#elif defined(GLFW_EXPOSE_NATIVE_X11)
#include <X11/Xlib.h>
#else
#error "No window API specified"
#endif
#error "No platform specified"
#if defined(GLFW_EXPOSE_NATIVE_WGL)
/* WGL is declared by windows.h */
#elif defined(GLFW_EXPOSE_NATIVE_NSGL)
/* NSGL is declared by Cocoa.h */
#elif defined(GLFW_EXPOSE_NATIVE_GLX)
#include <GL/glx.h>
#elif defined(GLFW_EXPOSE_NATIVE_EGL)
#include <EGL/egl.h>
#else
#error "No context API specified"
#endif
@ -81,56 +82,76 @@ extern "C" {
* Functions
*************************************************************************/
#if defined(GLFW_EXPOSE_NATIVE_WIN32_WGL)
#if defined(GLFW_EXPOSE_NATIVE_WIN32)
/*! @brief Returns the @c HWND of the specified window.
* @return The @c HWND of the specified window.
* @ingroup native
*/
GLFWAPI HWND glfwGetWin32Window(GLFWwindow window);
GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_WGL)
/*! @brief Returns the @c HGLRC of the specified window.
* @return The @c HGLRC of the specified window.
* @ingroup native
*/
GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow window);
#elif defined(GLFW_EXPOSE_NATIVE_COCOA_NSGL)
GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_COCOA)
/*! @brief Returns the @c NSWindow of the specified window.
* @return The @c NSWindow of the specified window.
* @ingroup native
*/
GLFWAPI id glfwGetCocoaWindow(GLFWwindow window);
GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_NSGL)
/*! @brief Returns the @c NSOpenGLContext of the specified window.
* @return The @c NSOpenGLContext of the specified window.
* @ingroup native
*/
GLFWAPI id glfwGetNSGLContext(GLFWwindow window);
#elif defined(GLFW_EXPOSE_NATIVE_X11_GLX)
GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_X11)
/*! @brief Returns the @c Display used by GLFW.
* @return The @c Display used by GLFW.
* @ingroup native
*/
GLFWAPI Display* glfwGetX11Display(void);
/*! @brief Returns the @c Window of the specified window.
* @return The @c Window of the specified window.
* @ingroup native
*/
GLFWAPI Window glfwGetX11Window(GLFWwindow window);
GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_GLX)
/*! @brief Returns the @c GLXContext of the specified window.
* @return The @c GLXContext of the specified window.
* @ingroup native
*/
GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow window);
GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_EGL)
/*! @brief Returns the @c EGLDisplay used by GLFW.
* @return The @c EGLDisplay used by GLFW.
* @ingroup native
*/
GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
/*! @brief Returns the @c EGLContext of the specified window.
* @return The @c EGLContext of the specified window.
* @ingroup native
*/
GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
/*! @brief Returns the @c EGLSurface of the specified window.
* @return The @c EGLSurface of the specified window.
* @ingroup native
*/
GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
#endif
#ifdef __cplusplus
}

12
src/CMakeLists.txt
View File

@ -16,28 +16,16 @@ if (_GLFW_COCOA)
set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_gamma.c
cocoa_init.m cocoa_joystick.m cocoa_monitor.m cocoa_time.c
cocoa_window.m)
if (GLFW_NATIVE_API)
list(APPEND glfw_SOURCES cocoa_native.m)
endif()
elseif (_GLFW_WIN32)
set(glfw_HEADERS ${common_HEADERS} win32_platform.h)
set(glfw_SOURCES ${common_SOURCES} win32_clipboard.c win32_gamma.c
win32_init.c win32_joystick.c win32_monitor.c win32_time.c
win32_window.c)
if (GLFW_NATIVE_API)
list(APPEND glfw_SOURCES win32_native.c)
endif()
elseif (_GLFW_X11)
set(glfw_HEADERS ${common_HEADERS} x11_platform.h)
set(glfw_SOURCES ${common_SOURCES} x11_clipboard.c x11_gamma.c x11_init.c
x11_joystick.c x11_keysym2unicode.c x11_monitor.c
x11_time.c x11_window.c)
if (GLFW_NATIVE_API)
list(APPEND glfw_SOURCES x11_native.c)
endif()
endif()
if (_GLFW_EGL)

4
src/cocoa_init.m
View File

@ -101,7 +101,7 @@ int _glfwPlatformInit(void)
_glfwInitJoysticks();
if (!_glfwInitOpenGL())
if (!_glfwInitContextAPI())
return GL_FALSE;
_glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
@ -141,7 +141,7 @@ void _glfwPlatformTerminate(void)
_glfwTerminateJoysticks();
_glfwTerminateOpenGL();
_glfwTerminateContextAPI();
}

74
src/cocoa_native.m
View File

@ -1,74 +0,0 @@
//========================================================================
// GLFW - An OpenGL library
// Platform: Cocoa/NSOpenGL
// API version: 3.0
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would
// be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
// be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
// distribution.
//
//========================================================================
#include "internal.h"
#define GLFW_EXPOSE_NATIVE_COCOA_NSGL
#include "../include/GL/glfw3native.h"
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Returns the X11 handle of the specified window
//========================================================================
GLFWAPI id glfwGetCocoaWindow(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return 0;
}
return window->ns.object;
}
//========================================================================
// Return the GLX context of the specified window
//========================================================================
GLFWAPI id glfwGetNSGLContext(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->nsgl.context;
}

4
src/cocoa_platform.h
View File

@ -118,8 +118,8 @@ GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, int* width, int* height, int*
void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
// OpenGL support
int _glfwInitOpenGL(void);
void _glfwTerminateOpenGL(void);
int _glfwInitContextAPI(void);
void _glfwTerminateContextAPI(void);
int _glfwCreateContext(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig);

22
src/cocoa_window.m
View File

@ -969,3 +969,25 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
}
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Returns the Cocoa object of the specified window
//========================================================================
GLFWAPI id glfwGetCocoaWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return 0;
}
return window->ns.object;
}

59
src/egl_context.c
View File

@ -113,7 +113,7 @@ static const char* getErrorString(EGLint error)
// Initialize EGL
//========================================================================
int _glfwInitOpenGL(void)
int _glfwInitContextAPI(void)
{
_glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
if (_glfw.egl.display == EGL_NO_DISPLAY)
@ -145,7 +145,7 @@ int _glfwInitOpenGL(void)
// Terminate EGL
//========================================================================
void _glfwTerminateOpenGL(void)
void _glfwTerminateContextAPI(void)
{
eglTerminate(_glfw.egl.display);
}
@ -497,3 +497,58 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
return eglGetProcAddress(procname);
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Return the EGL display
//========================================================================
GLFWAPI EGLDisplay glfwGetEGLDisplay(void)
{
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return _glfw.egl.display;
}
//========================================================================
// Return the WGL context of the specified window
//========================================================================
GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return 0;
}
return window->egl.context;
}
//========================================================================
// Return the EGL surface of the specified window
//========================================================================
GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return 0;
}
return window->egl.surface;
}

26
src/glx_context.c
View File

@ -113,7 +113,7 @@ static GLXContext createLegacyContext(_GLFWwindow* window,
// Initialize GLX
//========================================================================
int _glfwInitOpenGL(void)
int _glfwInitContextAPI(void)
{
#ifdef _GLFW_DLOPEN_LIBGL
int i;
@ -237,7 +237,7 @@ int _glfwInitOpenGL(void)
// Terminate GLX
//========================================================================
void _glfwTerminateOpenGL(void)
void _glfwTerminateContextAPI(void)
{
// Unload libGL.so if necessary
#ifdef _GLFW_DLOPEN_LIBGL
@ -633,3 +633,25 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
return _glfw_glXGetProcAddress((const GLubyte*) procname);
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Return the GLX context of the specified window
//========================================================================
GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->glx.context;
}

40
src/input.c
View File

@ -146,8 +146,8 @@ void _glfwInputKey(_GLFWwindow* window, int key, int action)
}
// Call user callback function
if (window->keyCallback && !repeated)
window->keyCallback((GLFWwindow*) window, key, action);
if (window->callbacks.key && !repeated)
window->callbacks.key((GLFWwindow*) window, key, action);
}
@ -161,8 +161,8 @@ void _glfwInputChar(_GLFWwindow* window, int character)
if (!((character >= 32 && character <= 126) || character >= 160))
return;
if (window->charCallback)
window->charCallback((GLFWwindow*) window, character);
if (window->callbacks.character)
window->callbacks.character((GLFWwindow*) window, character);
}
@ -175,8 +175,8 @@ void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
window->scrollX += xoffset;
window->scrollY += yoffset;
if (window->scrollCallback)
window->scrollCallback((GLFWwindow*) window, xoffset, yoffset);
if (window->callbacks.scroll)
window->callbacks.scroll((GLFWwindow*) window, xoffset, yoffset);
}
@ -195,8 +195,8 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action)
else
window->mouseButton[button] = (char) action;
if (window->mouseButtonCallback)
window->mouseButtonCallback((GLFWwindow*) window, button, action);
if (window->callbacks.mouseButton)
window->callbacks.mouseButton((GLFWwindow*) window, button, action);
}
@ -223,11 +223,11 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
window->cursorPosY = y;
}
if (window->cursorPosCallback)
if (window->callbacks.cursorPos)
{
window->cursorPosCallback((GLFWwindow*) window,
window->cursorPosX,
window->cursorPosY);
window->callbacks.cursorPos((GLFWwindow*) window,
window->cursorPosX,
window->cursorPosY);
}
}
@ -238,8 +238,8 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
{
if (window->cursorEnterCallback)
window->cursorEnterCallback((GLFWwindow*) window, entered);
if (window->callbacks.cursorEnter)
window->callbacks.cursorEnter((GLFWwindow*) window, entered);
}
@ -464,7 +464,7 @@ GLFWAPI void glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
return;
}
window->keyCallback = cbfun;
window->callbacks.key = cbfun;
}
@ -482,7 +482,7 @@ GLFWAPI void glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
return;
}
window->charCallback = cbfun;
window->callbacks.character = cbfun;
}
@ -500,7 +500,7 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow* handle, GLFWmousebuttonfun c
return;
}
window->mouseButtonCallback = cbfun;
window->callbacks.mouseButton = cbfun;
}
@ -518,7 +518,7 @@ GLFWAPI void glfwSetCursorPosCallback(GLFWwindow* handle, GLFWcursorposfun cbfun
return;
}
window->cursorPosCallback = cbfun;
window->callbacks.cursorPos = cbfun;
}
@ -536,7 +536,7 @@ GLFWAPI void glfwSetCursorEnterCallback(GLFWwindow* handle, GLFWcursorenterfun c
return;
}
window->cursorEnterCallback = cbfun;
window->callbacks.cursorEnter = cbfun;
}
@ -554,6 +554,6 @@ GLFWAPI void glfwSetScrollCallback(GLFWwindow* handle, GLFWscrollfun cbfun)
return;
}
window->scrollCallback = cbfun;
window->callbacks.scroll = cbfun;
}

26
src/internal.h
View File

@ -235,18 +235,20 @@ struct _GLFWwindow
PFNGLGETSTRINGIPROC GetStringi;
#endif
GLFWwindowposfun windowPosCallback;
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWwindowfocusfun windowFocusCallback;
GLFWwindowiconifyfun windowIconifyCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWcursorposfun cursorPosCallback;
GLFWcursorenterfun cursorEnterCallback;
GLFWscrollfun scrollCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
struct {
GLFWwindowposfun pos;
GLFWwindowsizefun size;
GLFWwindowclosefun close;
GLFWwindowrefreshfun refresh;
GLFWwindowfocusfun focus;
GLFWwindowiconifyfun iconify;
GLFWmousebuttonfun mouseButton;
GLFWcursorposfun cursorPos;
GLFWcursorenterfun cursorEnter;
GLFWscrollfun scroll;
GLFWkeyfun key;
GLFWcharfun character;
} callbacks;
// This is defined in the window API's platform.h
_GLFW_PLATFORM_WINDOW_STATE;

26
src/nsgl_context.m
View File

@ -46,7 +46,7 @@ static pthread_key_t _glfwCurrentTLS;
// Initialize OpenGL support
//========================================================================
int _glfwInitOpenGL(void)
int _glfwInitContextAPI(void)
{
if (pthread_key_create(&_glfwCurrentTLS, NULL) != 0)
{
@ -63,7 +63,7 @@ int _glfwInitOpenGL(void)
// Terminate OpenGL support
//========================================================================
void _glfwTerminateOpenGL(void)
void _glfwTerminateContextAPI(void)
{
pthread_key_delete(_glfwCurrentTLS);
}
@ -325,3 +325,25 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
return symbol;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Return the NSGL context of the specified window
//========================================================================
GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->nsgl.context;
}

22
src/wgl_context.c
View File

@ -612,3 +612,25 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
return (GLFWglproc) wglGetProcAddress(procname);
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Return the WGL context of the specified window
//========================================================================
GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->wgl.context;
}

74
src/win32_native.c
View File

@ -1,74 +0,0 @@
_glfw
// GLFW - An OpenGL library
// Platform: Win32/WGL
// API version: 3.0
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would
// be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
// be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
// distribution.
//
//========================================================================
#include "internal.h"
#define GLFW_EXPOSE_NATIVE_WIN32_WGL
#include "../include/GL/glfw3native.h"
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Returns the Win32 handle of the specified window
//========================================================================
GLFWAPI HWND glfwGetWin32Window(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->win32.handle;
}
//========================================================================
// Return the WGL context of the specified window
//========================================================================
GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->WGL.context;
}

21
src/win32_window.c
View File

@ -579,7 +579,6 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
case WM_MOUSEHWHEEL:
{
// This message is only sent on Windows Vista and later
_glfwInputScroll(window, (SHORT) HIWORD(wParam) / (double) WHEEL_DELTA, 0.0);
return 0;
}
@ -1142,4 +1141,24 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
}
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Returns the Win32 handle of the specified window
//========================================================================
GLFWAPI HWND glfwGetWin32Window(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->win32.handle;
}

53
src/window.c
View File

@ -80,8 +80,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
{
_glfw.focusedWindow = window;
if (window->windowFocusCallback)
window->windowFocusCallback((GLFWwindow*) window, focused);
if (window->callbacks.focus)
window->callbacks.focus((GLFWwindow*) window, focused);
}
}
else
@ -106,8 +106,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
_glfw.focusedWindow = NULL;
if (window->windowFocusCallback)
window->windowFocusCallback((GLFWwindow*) window, focused);
if (window->callbacks.focus)
window->callbacks.focus((GLFWwindow*) window, focused);
}
}
}
@ -125,8 +125,8 @@ void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
window->positionX = x;
window->positionY = y;
if (window->windowPosCallback)
window->windowPosCallback((GLFWwindow*) window, x, y);
if (window->callbacks.pos)
window->callbacks.pos((GLFWwindow*) window, x, y);
}
@ -142,8 +142,8 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
window->width = width;
window->height = height;
if (window->windowSizeCallback)
window->windowSizeCallback((GLFWwindow*) window, width, height);
if (window->callbacks.size)
window->callbacks.size((GLFWwindow*) window, width, height);
}
@ -158,8 +158,8 @@ void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
window->iconified = iconified;
if (window->windowIconifyCallback)
window->windowIconifyCallback((GLFWwindow*) window, iconified);
if (window->callbacks.iconify)
window->callbacks.iconify((GLFWwindow*) window, iconified);
}
@ -179,8 +179,8 @@ void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
void _glfwInputWindowDamage(_GLFWwindow* window)
{
if (window->windowRefreshCallback)
window->windowRefreshCallback((GLFWwindow*) window);
if (window->callbacks.refresh)
window->callbacks.refresh((GLFWwindow*) window);
}
@ -190,8 +190,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
void _glfwInputWindowCloseRequest(_GLFWwindow* window)
{
if (window->windowCloseCallback)
window->closeRequested = window->windowCloseCallback((GLFWwindow*) window);
if (window->callbacks.close)
window->closeRequested = window->callbacks.close((GLFWwindow*) window);
else
window->closeRequested = GL_TRUE;
}
@ -489,18 +489,7 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
return;
// Clear all callbacks to avoid exposing a half torn-down window object
window->windowPosCallback = NULL;
window->windowSizeCallback = NULL;
window->windowCloseCallback = NULL;
window->windowRefreshCallback = NULL;
window->windowFocusCallback = NULL;
window->windowIconifyCallback = NULL;
window->mouseButtonCallback = NULL;
window->cursorPosCallback = NULL;
window->cursorEnterCallback = NULL;
window->scrollCallback = NULL;
window->keyCallback = NULL;
window->charCallback = NULL;
memset(&window->callbacks, 0, sizeof(window->callbacks));
// The window's context must not be current on another thread when the
// window is destroyed
@ -800,7 +789,7 @@ GLFWAPI void glfwSetWindowPosCallback(GLFWwindow* handle, GLFWwindowposfun cbfun
return;
}
window->windowPosCallback = cbfun;
window->callbacks.pos = cbfun;
}
@ -818,7 +807,7 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow* handle, GLFWwindowsizefun cbf
return;
}
window->windowSizeCallback = cbfun;
window->callbacks.size = cbfun;
}
@ -836,7 +825,7 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow* handle, GLFWwindowclosefun c
return;
}
window->windowCloseCallback = cbfun;
window->callbacks.close = cbfun;
}
@ -854,7 +843,7 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow* handle, GLFWwindowrefreshf
return;
}
window->windowRefreshCallback = cbfun;
window->callbacks.refresh = cbfun;
}
@ -872,7 +861,7 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow* handle, GLFWwindowfocusfun c
return;
}
window->windowFocusCallback = cbfun;
window->callbacks.focus = cbfun;
}
@ -890,7 +879,7 @@ GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow* handle, GLFWwindowiconifyf
return;
}
window->windowIconifyCallback = cbfun;
window->callbacks.iconify = cbfun;
}

4
src/x11_init.c
View File

@ -632,7 +632,7 @@ int _glfwPlatformInit(void)
_glfwInitGammaRamp();
if (!_glfwInitOpenGL())
if (!_glfwInitContextAPI())
return GL_FALSE;
_glfw.x11.cursor = createNULLCursor();
@ -662,7 +662,7 @@ void _glfwPlatformTerminate(void)
_glfwTerminateJoysticks();
_glfwTerminateOpenGL();
_glfwTerminateContextAPI();
terminateDisplay();

84
src/x11_native.c
View File

@ -1,84 +0,0 @@
//========================================================================
// GLFW - An OpenGL library
// Platform: Win32/WGL
// API version: 3.0
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would
// be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
// be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
// distribution.
//
//========================================================================
#include "internal.h"
#define GLFW_EXPOSE_NATIVE_X11_GLX
#include "../include/GL/glfw3native.h"
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Returns the X11 display
//========================================================================
GLFWAPI Display* glfwGetX11Display(void)
{
return _glfw.x11.display;
}
//========================================================================
// Returns the X11 handle of the specified window
//========================================================================
GLFWAPI Window glfwGetX11Window(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return 0;
}
return window->x11.handle;
}
//========================================================================
// Return the GLX context of the specified window
//========================================================================
GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return window->glx.context;
}

4
src/x11_platform.h
View File

@ -224,8 +224,8 @@ void _glfwInitGammaRamp(void);
void _glfwTerminateGammaRamp(void);
// OpenGL support
int _glfwInitOpenGL(void);
void _glfwTerminateOpenGL(void);
int _glfwInitContextAPI(void);
void _glfwTerminateContextAPI(void);
int _glfwCreateContext(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig);

38
src/x11_window.c
View File

@ -1111,3 +1111,41 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
}
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Return the X11 display
//========================================================================
GLFWAPI Display* glfwGetX11Display(void)
{
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
return _glfw.x11.display;
}
//========================================================================
// Return the X11 handle of the specified window
//========================================================================
GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwInputError(GLFW_NOT_INITIALIZED, NULL);
return 0;
}
return window->x11.handle;
}