mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-22 04:54:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial pass for multi-window support.

Browse Source
This commit is contained in:
Camilla Berglund 2010-09-09 18:15:32 +02:00
parent 8247a6b3eb
commit 135194a960
14 changed files with 986 additions and 1006 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
include/GL/glfw.h
View File

@ -306,7 +306,6 @@ extern "C" {
#define GLFW_FULLSCREEN 0x00010002
/* glfwGetWindowParam tokens */
#define GLFW_OPENED 0x00020001
#define GLFW_ACTIVE 0x00020002
#define GLFW_ICONIFIED 0x00020003
#define GLFW_ACCELERATED 0x00020004
@ -356,6 +355,8 @@ extern "C" {
* Typedefs
*************************************************************************/
typedef struct _GLFWwindow* GLFWwindow;
/* The video mode structure used by glfwGetVideoModes() */
typedef struct {
int width, height;
@ -382,41 +383,42 @@ GLFWAPI int glfwInit(void);
GLFWAPI void glfwTerminate(void);
GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev);
/* Window handling */
GLFWAPI int glfwOpenWindow(int width, int height, int redbits, int greenbits, int bluebits, int alphabits, int depthbits, int stencilbits, int mode);
GLFWAPI void glfwOpenWindowHint(int target, int hint);
GLFWAPI void glfwCloseWindow(void);
GLFWAPI void glfwSetWindowTitle(const char* title);
GLFWAPI void glfwGetWindowSize(int* width, int* height);
GLFWAPI void glfwSetWindowSize(int width, int height);
GLFWAPI void glfwSetWindowPos(int x, int y);
GLFWAPI void glfwIconifyWindow(void);
GLFWAPI void glfwRestoreWindow(void);
GLFWAPI void glfwSwapBuffers(void);
GLFWAPI void glfwSwapInterval(int interval);
GLFWAPI int glfwGetWindowParam(int param);
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun);
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun);
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun);
/* Video mode functions */
GLFWAPI int glfwGetVideoModes(GLFWvidmode* list, int maxcount);
GLFWAPI void glfwGetDesktopMode(GLFWvidmode* mode);
/* Input handling */
/* Window handling */
GLFWAPI GLFWwindow glfwOpenWindow(int width, int height, int redbits, int greenbits, int bluebits, int alphabits, int depthbits, int stencilbits, int mode);
GLFWAPI void glfwOpenWindowHint(int target, int hint);
GLFWAPI void glfwMakeWindowCurrent(GLFWwindow window);
GLFWAPI void glfwCloseWindow(GLFWwindow window);
GLFWAPI void glfwSetWindowTitle(GLFWwindow, const char* title);
GLFWAPI void glfwGetWindowSize(GLFWwindow, int* width, int* height);
GLFWAPI void glfwSetWindowSize(GLFWwindow, int width, int height);
GLFWAPI void glfwSetWindowPos(GLFWwindow, int x, int y);
GLFWAPI void glfwIconifyWindow(GLFWwindow window);
GLFWAPI void glfwRestoreWindow(GLFWwindow window);
GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param);
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun);
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun);
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun);
/* Event handling */
GLFWAPI void glfwPollEvents(void);
GLFWAPI void glfwWaitEvents(void);
GLFWAPI int glfwGetKey(int key);
GLFWAPI int glfwGetMouseButton(int button);
GLFWAPI void glfwGetMousePos(int* xpos, int* ypos);
GLFWAPI void glfwSetMousePos(int xpos, int ypos);
GLFWAPI int glfwGetMouseWheel(void);
GLFWAPI void glfwSetMouseWheel(int pos);
GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun);
GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun);
GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun);
GLFWAPI void glfwSetMousePosCallback(GLFWmouseposfun cbfun);
GLFWAPI void glfwSetMouseWheelCallback(GLFWmousewheelfun cbfun);
/* Input handling */
GLFWAPI int glfwGetKey(GLFWwindow window, int key);
GLFWAPI int glfwGetMouseButton(GLFWwindow window, int button);
GLFWAPI void glfwGetMousePos(GLFWwindow window, int* xpos, int* ypos);
GLFWAPI void glfwSetMousePos(GLFWwindow window, int xpos, int ypos);
GLFWAPI int glfwGetMouseWheel(GLFWwindow window);
GLFWAPI void glfwSetMouseWheel(GLFWwindow window, int pos);
GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun);
GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun);
GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun);
GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun);
GLFWAPI void glfwSetMouseWheelCallback(GLFWwindow window, GLFWmousewheelfun cbfun);
/* Joystick input */
GLFWAPI int glfwGetJoystickParam(int joy, int param);
@ -427,14 +429,16 @@ GLFWAPI int glfwGetJoystickButtons(int joy, unsigned char* buttons, int numbutto
GLFWAPI double glfwGetTime(void);
GLFWAPI void glfwSetTime(double time);
/* Extension support */
/* OpenGL support */
GLFWAPI void glfwSwapBuffers(void);
GLFWAPI void glfwSwapInterval(int interval);
GLFWAPI int glfwExtensionSupported(const char* extension);
GLFWAPI void* glfwGetProcAddress(const char* procname);
GLFWAPI void glfwGetGLVersion(int* major, int* minor, int* rev);
/* Enable/disable functions */
GLFWAPI void glfwEnable(int token);
GLFWAPI void glfwDisable(int token);
GLFWAPI void glfwEnable(GLFWwindow window, int token);
GLFWAPI void glfwDisable(GLFWwindow window, int token);
#ifdef __cplusplus

115
lib/enable.c
View File

@ -39,55 +39,56 @@
// Enable (show) mouse cursor
//========================================================================
static void enableMouseCursor(void)
static void enableMouseCursor(_GLFWwindow* window)
{
int centerPosX, centerPosY;
if (!_glfwWin.opened || !_glfwWin.mouseLock)
if (_glfwLibrary.cursorLockWindow != window)
return;
// Show mouse cursor
_glfwPlatformShowMouseCursor();
_glfwPlatformShowMouseCursor(window);
centerPosX = _glfwWin.width / 2;
centerPosY = _glfwWin.height / 2;
centerPosX = window->width / 2;
centerPosY = window->height / 2;
if (centerPosX != _glfwInput.MousePosX || centerPosY != _glfwInput.MousePosY)
if (centerPosX != window->mousePosX || centerPosY != window->mousePosY)
{
_glfwPlatformSetMouseCursorPos(centerPosX, centerPosY);
_glfwPlatformSetMouseCursorPos(window, centerPosX, centerPosY);
_glfwInput.MousePosX = centerPosX;
_glfwInput.MousePosY = centerPosY;
window->mousePosX = centerPosX;
window->mousePosY = centerPosY;
if (_glfwWin.mousePosCallback)
if (window->mousePosCallback)
{
_glfwWin.mousePosCallback(_glfwInput.MousePosX,
_glfwInput.MousePosY);
window->mousePosCallback(window->mousePosX,
window->mousePosY);
}
}
// From now on the mouse is unlocked
_glfwWin.mouseLock = GL_FALSE;
_glfwLibrary.cursorLockWindow = NULL;
}
//========================================================================
// Disable (hide) mouse cursor
//========================================================================
static void disableMouseCursor(void)
static void disableMouseCursor(_GLFWwindow* window)
{
if (!_glfwWin.opened || _glfwWin.mouseLock)
if (_glfwLibrary.cursorLockWindow)
return;
// Hide mouse cursor
_glfwPlatformHideMouseCursor();
_glfwPlatformHideMouseCursor(window);
// Move cursor to the middle of the window
_glfwPlatformSetMouseCursorPos(_glfwWin.width >> 1,
_glfwWin.height >> 1);
_glfwPlatformSetMouseCursorPos(window,
window->width / 2,
window->height / 2);
// From now on the mouse is locked
_glfwWin.mouseLock = GL_TRUE;
_glfwLibrary.cursorLockWindow = window;
}
@ -95,26 +96,26 @@ static void disableMouseCursor(void)
// Enable sticky keys
//========================================================================
static void enableStickyKeys(void)
static void enableStickyKeys(_GLFWwindow* window)
{
_glfwInput.StickyKeys = 1;
window->stickyKeys = GL_TRUE;
}
//========================================================================
// Disable sticky keys
//========================================================================
static void disableStickyKeys(void)
static void disableStickyKeys(_GLFWwindow* window)
{
int i;
_glfwInput.StickyKeys = 0;
window->stickyKeys = GL_FALSE;
// Release all sticky keys
for (i = 0; i <= GLFW_KEY_LAST; i++)
{
if (_glfwInput.Key[i] == 2)
_glfwInput.Key[i] = 0;
if (window->key[i] == GLFW_STICK)
window->key[i] = GLFW_RELEASE;
}
}
@ -123,26 +124,26 @@ static void disableStickyKeys(void)
// Enable sticky mouse buttons
//========================================================================
static void enableStickyMouseButtons(void)
static void enableStickyMouseButtons(_GLFWwindow* window)
{
_glfwInput.StickyMouseButtons = 1;
window->stickyMouseButtons = GL_TRUE;
}
//========================================================================
// Disable sticky mouse buttons
//========================================================================
static void disableStickyMouseButtons(void)
static void disableStickyMouseButtons(_GLFWwindow* window)
{
int i;
_glfwInput.StickyMouseButtons = 0;
window->stickyMouseButtons = GL_FALSE;
// Release all sticky mouse buttons
for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
{
if (_glfwInput.MouseButton[i] == 2)
_glfwInput.MouseButton[i] = 0;
if (window->mouseButton[i] == GLFW_STICK)
window->mouseButton[i] = GLFW_RELEASE;
}
}
@ -151,30 +152,30 @@ static void disableStickyMouseButtons(void)
// Enable system keys
//========================================================================
static void enableSystemKeys(void)
static void enableSystemKeys(_GLFWwindow* window)
{
if (!_glfwWin.sysKeysDisabled)
if (!window->sysKeysDisabled)
return;
_glfwPlatformEnableSystemKeys();
_glfwPlatformEnableSystemKeys(window);
// Indicate that system keys are no longer disabled
_glfwWin.sysKeysDisabled = GL_FALSE;
window->sysKeysDisabled = GL_FALSE;
}
//========================================================================
// Disable system keys
//========================================================================
static void disableSystemKeys(void)
static void disableSystemKeys(_GLFWwindow* window)
{
if (_glfwWin.sysKeysDisabled)
if (window->sysKeysDisabled)
return;
_glfwPlatformDisableSystemKeys();
_glfwPlatformDisableSystemKeys(window);
// Indicate that system keys are now disabled
_glfwWin.sysKeysDisabled = GL_TRUE;
window->sysKeysDisabled = GL_TRUE;
}
@ -182,18 +183,18 @@ static void disableSystemKeys(void)
// Enable key repeat
//========================================================================
static void enableKeyRepeat(void)
static void enableKeyRepeat(_GLFWwindow* window)
{
_glfwInput.KeyRepeat = 1;
window->keyRepeat = GL_TRUE;
}
//========================================================================
// Disable key repeat
//========================================================================
static void disableKeyRepeat(void)
static void disableKeyRepeat(_GLFWwindow* window)
{
_glfwInput.KeyRepeat = 0;
window->keyRepeat = GL_FALSE;
}
@ -202,10 +203,10 @@ static void disableKeyRepeat(void)
//************************************************************************
//========================================================================
// Enable certain GLFW/window/system functions.
// Enable certain GLFW/window/system functions
//========================================================================
GLFWAPI void glfwEnable(int token)
GLFWAPI void glfwEnable(GLFWwindow window, int token)
{
if (!_glfwInitialized)
return;
@ -213,19 +214,19 @@ GLFWAPI void glfwEnable(int token)
switch (token)
{
case GLFW_MOUSE_CURSOR:
enableMouseCursor();
enableMouseCursor(window);
break;
case GLFW_STICKY_KEYS:
enableStickyKeys();
enableStickyKeys(window);
break;
case GLFW_STICKY_MOUSE_BUTTONS:
enableStickyMouseButtons();
enableStickyMouseButtons(window);
break;
case GLFW_SYSTEM_KEYS:
enableSystemKeys();
enableSystemKeys(window);
break;
case GLFW_KEY_REPEAT:
enableKeyRepeat();
enableKeyRepeat(window);
break;
default:
break;
@ -234,10 +235,10 @@ GLFWAPI void glfwEnable(int token)
//========================================================================
// Disable certain GLFW/window/system functions.
// Disable certain GLFW/window/system functions
//========================================================================
GLFWAPI void glfwDisable(int token)
GLFWAPI void glfwDisable(GLFWwindow window, int token)
{
if (!_glfwInitialized)
return;
@ -245,19 +246,19 @@ GLFWAPI void glfwDisable(int token)
switch (token)
{
case GLFW_MOUSE_CURSOR:
disableMouseCursor();
disableMouseCursor(window);
break;
case GLFW_STICKY_KEYS:
disableStickyKeys();
disableStickyKeys(window);
break;
case GLFW_STICKY_MOUSE_BUTTONS:
disableStickyMouseButtons();
disableStickyMouseButtons(window);
break;
case GLFW_SYSTEM_KEYS:
disableSystemKeys();
disableSystemKeys(window);
break;
case GLFW_KEY_REPEAT:
disableKeyRepeat();
disableKeyRepeat(window);
break;
default:
break;

20
lib/glext.c
View File

@ -132,15 +132,17 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
GLint count;
int i;
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized || !_glfwLibrary.window)
return GL_FALSE;
_GLFWwindow* window = _glfwLibrary.window;
// Extension names should not have spaces
where = (GLubyte*) strchr(extension, ' ');
if (where || *extension == '\0')
return GL_FALSE;
if (_glfwWin.glMajor < 3)
if (window->glMajor < 3)
{
// Check if extension is in the old style OpenGL extensions string
@ -159,7 +161,7 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
for (i = 0; i < count; i++)
{
if (strcmp((const char*) _glfwWin.GetStringi(GL_EXTENSIONS, i),
if (strcmp((const char*) window->GetStringi(GL_EXTENSIONS, i),
extension) == 0)
{
return GL_TRUE;
@ -182,7 +184,7 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
GLFWAPI void* glfwGetProcAddress(const char* procname)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized || !_glfwLibrary.window)
return NULL;
return _glfwPlatformGetProcAddress(procname);
@ -195,16 +197,18 @@ GLFWAPI void* glfwGetProcAddress(const char* procname)
GLFWAPI void glfwGetGLVersion(int* major, int* minor, int* rev)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized || !_glfwLibrary.window)
return;
_GLFWwindow* window = _glfwLibrary.window;
if (major != NULL)
*major = _glfwWin.glMajor;
*major = window->glMajor;
if (minor != NULL)
*minor = _glfwWin.glMinor;
*minor = window->glMinor;
if (rev != NULL)
*rev = _glfwWin.glRevision;
*rev = window->glRevision;
}

7
lib/init.c
View File

@ -48,13 +48,6 @@ GLFWAPI int glfwInit(void)
return GL_TRUE;
memset(&_glfwLibrary, 0, sizeof(_glfwLibrary));
memset(&_glfwWin, 0, sizeof(_glfwWin ));
// Window is not yet opened
_glfwWin.opened = GL_FALSE;
// Default enable/disable settings
_glfwWin.sysKeysDisabled = GL_FALSE;
// Clear window hints
_glfwClearWindowHints();

93
lib/input.c
View File

@ -35,23 +35,23 @@
//
//========================================================================
GLFWAPI int glfwGetKey(int key)
GLFWAPI int glfwGetKey(GLFWwindow window, int key)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return GLFW_RELEASE;
// Is it a valid key?
if (key < 0 || key > GLFW_KEY_LAST)
return GLFW_RELEASE;
if (_glfwInput.Key[key] == GLFW_STICK)
if (window->key[key] == GLFW_STICK)
{
// Sticky mode: release key now
_glfwInput.Key[key] = GLFW_RELEASE;
window->key[key] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) _glfwInput.Key[key];
return (int) window->key[key];
}
@ -59,23 +59,23 @@ GLFWAPI int glfwGetKey(int key)
//
//========================================================================
GLFWAPI int glfwGetMouseButton(int button)
GLFWAPI int glfwGetMouseButton(GLFWwindow window, int button)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return GLFW_RELEASE;
// Is it a valid mouse button?
if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
return GLFW_RELEASE;
if (_glfwInput.MouseButton[button] == GLFW_STICK)
if (window->mouseButton[button] == GLFW_STICK)
{
// Sticky mode: release mouse button now
_glfwInput.MouseButton[button] = GLFW_RELEASE;
window->mouseButton[button] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) _glfwInput.MouseButton[button];
return (int) window->mouseButton[button];
}
@ -83,17 +83,17 @@ GLFWAPI int glfwGetMouseButton(int button)
//
//========================================================================
GLFWAPI void glfwGetMousePos(int* xpos, int* ypos)
GLFWAPI void glfwGetMousePos(GLFWwindow window, int* xpos, int* ypos)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Return mouse position
if (xpos != NULL)
*xpos = _glfwInput.MousePosX;
*xpos = window->mousePosX;
if (ypos != NULL)
*ypos = _glfwInput.MousePosY;
*ypos = window->mousePosY;
}
@ -101,25 +101,25 @@ GLFWAPI void glfwGetMousePos(int* xpos, int* ypos)
//
//========================================================================
GLFWAPI void glfwSetMousePos(int xpos, int ypos)
GLFWAPI void glfwSetMousePos(GLFWwindow window, int xpos, int ypos)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Don't do anything if the mouse position did not change
if (xpos == _glfwInput.MousePosX && ypos == _glfwInput.MousePosY)
if (xpos == window->mousePosX && ypos == window->mousePosY)
return;
// Set GLFW mouse position
_glfwInput.MousePosX = xpos;
_glfwInput.MousePosY = ypos;
window->mousePosX = xpos;
window->mousePosY = ypos;
// If we have a locked mouse, do not change cursor position
if (_glfwWin.mouseLock)
if (_glfwLibrary.cursorLockWindow)
return;
// Update physical cursor position
_glfwPlatformSetMouseCursorPos(xpos, ypos);
_glfwPlatformSetMouseCursorPos(window, xpos, ypos);
}
@ -127,13 +127,12 @@ GLFWAPI void glfwSetMousePos(int xpos, int ypos)
//
//========================================================================
GLFWAPI int glfwGetMouseWheel(void)
GLFWAPI int glfwGetMouseWheel(GLFWwindow window)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return 0;
// Return mouse wheel position
return _glfwInput.WheelPos;
return window->wheelPos;
}
@ -141,13 +140,12 @@ GLFWAPI int glfwGetMouseWheel(void)
//
//========================================================================
GLFWAPI void glfwSetMouseWheel(int pos)
GLFWAPI void glfwSetMouseWheel(GLFWwindow window, int pos)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set mouse wheel position
_glfwInput.WheelPos = pos;
window->wheelPos = pos;
}
@ -155,13 +153,12 @@ GLFWAPI void glfwSetMouseWheel(int pos)
// Set callback function for keyboard input
//========================================================================
GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set callback function
_glfwWin.keyCallback = cbfun;
window->keyCallback = cbfun;
}
@ -169,13 +166,12 @@ GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
// Set callback function for character input
//========================================================================
GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set callback function
_glfwWin.charCallback = cbfun;
window->charCallback = cbfun;
}
@ -183,13 +179,12 @@ GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
// Set callback function for mouse clicks
//========================================================================
GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set callback function
_glfwWin.mouseButtonCallback = cbfun;
window->mouseButtonCallback = cbfun;
}
@ -197,18 +192,18 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
// Set callback function for mouse moves
//========================================================================
GLFWAPI void glfwSetMousePosCallback(GLFWmouseposfun cbfun)
GLFWAPI void glfwSetMousePosCallback(GLFWwindow window, GLFWmouseposfun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized || !_glfwLibrary.window)
return;
// Set callback function
_glfwWin.mousePosCallback = cbfun;
_glfwLibrary.window->mousePosCallback = cbfun;
// Call the callback function to let the application know the current
// mouse position
if (cbfun)
cbfun(_glfwInput.MousePosX, _glfwInput.MousePosY);
cbfun(window->mousePosX, window->mousePosY);
}
@ -216,17 +211,17 @@ GLFWAPI void glfwSetMousePosCallback(GLFWmouseposfun cbfun)
// Set callback function for mouse wheel
//========================================================================
GLFWAPI void glfwSetMouseWheelCallback(GLFWmousewheelfun cbfun)
GLFWAPI void glfwSetMouseWheelCallback(GLFWwindow window, GLFWmousewheelfun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set callback function
_glfwWin.mouseWheelCallback = cbfun;
window->mouseWheelCallback = cbfun;
// Call the callback function to let the application know the current
// mouse wheel position
if (cbfun)
cbfun(_glfwInput.WheelPos);
cbfun(window->wheelPos);
}

142
lib/internal.h
View File

@ -51,6 +51,14 @@
#define GLFW_STICK 2
//------------------------------------------------------------------------
// Platform specific definitions goes in platform.h (which also includes
// glfw.h)
//------------------------------------------------------------------------
#include "platform.h"
//------------------------------------------------------------------------
// Window opening hints (set by glfwOpenWindowHint)
// A bucket of semi-random stuff bunched together for historical reasons
@ -75,14 +83,6 @@ typedef struct {
} _GLFWhints;
//------------------------------------------------------------------------
// Platform specific definitions goes in platform.h (which also includes
// glfw.h)
//------------------------------------------------------------------------
#include "platform.h"
//------------------------------------------------------------------------
// Parameters relating to the creation of the context and window but not
// directly related to the properties of the framebuffer
@ -126,6 +126,81 @@ typedef struct {
} _GLFWfbconfig;
//------------------------------------------------------------------------
// Window structure
//------------------------------------------------------------------------
typedef struct _GLFWwindow {
// User callback functions
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWmousewheelfun mouseWheelCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
// User selected window settings
int mode;
GLboolean sysKeysDisabled; // System keys disabled flag
GLboolean windowNoResize; // Resize- and maximize gadgets disabled flag
int refreshRate; // Vertical monitor refresh rate
// Input
GLboolean stickyKeys;
GLboolean stickyMouseButtons;
GLboolean keyRepeat;
int mousePosX, mousePosY;
int wheelPos;
char mouseButton[GLFW_MOUSE_BUTTON_LAST + 1];
char key[GLFW_KEY_LAST + 1];
int lastChar;
// Window status & parameters
GLboolean active; // Application active flag
GLboolean iconified; // Window iconified flag
int width, height; // Window width and heigth
GLboolean accelerated; // GL_TRUE if window is HW accelerated
// Framebuffer attributes
int redBits;
int greenBits;
int blueBits;
int alphaBits;
int depthBits;
int stencilBits;
int accumRedBits;
int accumGreenBits;
int accumBlueBits;
int accumAlphaBits;
int auxBuffers;
GLboolean stereo;
int samples;
// OpenGL extensions and context attributes
int glMajor, glMinor, glRevision;
int glForward, glDebug, glProfile;
PFNGLGETSTRINGIPROC GetStringi;
_GLFW_PLATFORM_WINDOW_STATE;
} _GLFWwindow;
//------------------------------------------------------------------------
// Library global data
//------------------------------------------------------------------------
typedef struct {
_GLFWhints hints;
_GLFWwindow* window;
_GLFWwindow* currentWindow;
_GLFWwindow* cursorLockWindow;
_GLFW_PLATFORM_LIBRARY_STATE;
} _GLFWlibrary;
//========================================================================
// System independent global variables (GLFW internals)
//========================================================================
@ -137,6 +212,8 @@ int _glfwInitialized = 0;
GLFWGLOBAL int _glfwInitialized;
#endif
GLFWGLOBAL _GLFWlibrary _glfwLibrary;
//========================================================================
// Prototypes for platform specific implementation functions
@ -147,17 +224,13 @@ int _glfwPlatformInit(void);
int _glfwPlatformTerminate(void);
// Enable/Disable
void _glfwPlatformEnableSystemKeys(void);
void _glfwPlatformDisableSystemKeys(void);
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window);
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window);
// Fullscreen
int _glfwPlatformGetVideoModes(GLFWvidmode* list, int maxcount);
void _glfwPlatformGetDesktopMode(GLFWvidmode* mode);
// OpenGL extensions
int _glfwPlatformExtensionSupported(const char* extension);
void* _glfwPlatformGetProcAddress(const char* procname);
// Joystick
int _glfwPlatformGetJoystickParam(int joy, int param);
int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes);
@ -168,21 +241,28 @@ double _glfwPlatformGetTime(void);
void _glfwPlatformSetTime(double time);
// Window management
int _glfwPlatformOpenWindow(int width, int height, const _GLFWwndconfig* wndconfig, const _GLFWfbconfig* fbconfig);
void _glfwPlatformCloseWindow(void);
void _glfwPlatformSetWindowTitle(const char* title);
void _glfwPlatformSetWindowSize(int width, int height);
void _glfwPlatformSetWindowPos(int x, int y);
void _glfwPlatformIconifyWindow(void);
void _glfwPlatformRestoreWindow(void);
int _glfwPlatformOpenWindow(_GLFWwindow* window, int width, int height, const _GLFWwndconfig* wndconfig, const _GLFWfbconfig* fbconfig);
int _glfwPlatformMakeWindowCurrent(_GLFWwindow* window);
void _glfwPlatformCloseWindow(_GLFWwindow* window);
void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);
void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height);
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y);
void _glfwPlatformIconifyWindow(_GLFWwindow* window);
void _glfwPlatformRestoreWindow(_GLFWwindow* window);
void _glfwPlatformHideMouseCursor(_GLFWwindow* window);
void _glfwPlatformShowMouseCursor(_GLFWwindow* window);
void _glfwPlatformSetMouseCursorPos(_GLFWwindow* window, int x, int y);
// Event management
void _glfwPlatformPollEvents(void);
void _glfwPlatformWaitEvents(void);
// OpenGL context management
void _glfwPlatformSwapBuffers(void);
void _glfwPlatformSwapInterval(int interval);
void _glfwPlatformRefreshWindowParams(void);
void _glfwPlatformPollEvents(void);
void _glfwPlatformWaitEvents(void);
void _glfwPlatformHideMouseCursor(void);
void _glfwPlatformShowMouseCursor(void);
void _glfwPlatformSetMouseCursorPos(int x, int y);
int _glfwPlatformExtensionSupported(const char* extension);
void* _glfwPlatformGetProcAddress(const char* procname);
//========================================================================
@ -193,11 +273,11 @@ void _glfwPlatformSetMouseCursorPos(int x, int y);
void _glfwClearWindowHints(void);
// Input handling (window.c)
void _glfwClearInput(void);
void _glfwInputDeactivation(void);
void _glfwInputKey(int key, int action);
void _glfwInputChar(int character, int action);
void _glfwInputMouseClick(int button, int action);
void _glfwClearInput(_GLFWwindow* window);
void _glfwInputDeactivation(_GLFWwindow* window);
void _glfwInputKey(_GLFWwindow* window, int key, int action);
void _glfwInputChar(_GLFWwindow* window, int character, int action);
void _glfwInputMouseClick(_GLFWwindow* window, int button, int action);
// OpenGL extensions (glext.c)
void _glfwParseGLVersion(int* major, int* minor, int* rev);

363
lib/window.c
View File

@ -32,6 +32,7 @@
#include <limits.h>
#include <string.h>
#include <stdlib.h>
//************************************************************************
@ -58,22 +59,22 @@ void _glfwClearWindowHints(void)
// Handle the input tracking part of window deactivation
//========================================================================
void _glfwInputDeactivation(void)
void _glfwInputDeactivation(_GLFWwindow* window)
{
int i;
// Release all keyboard keys
for (i = 0; i <= GLFW_KEY_LAST; i++)
{
if(_glfwInput.Key[i] == GLFW_PRESS)
_glfwInputKey(i, GLFW_RELEASE);
if (window->key[i] == GLFW_PRESS)
_glfwInputKey(window, i, GLFW_RELEASE);
}
// Release all mouse buttons
for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
{
if (_glfwInput.MouseButton[i] == GLFW_PRESS)
_glfwInputMouseClick(i, GLFW_RELEASE);
if (window->mouseButton[i] == GLFW_PRESS)
_glfwInputMouseClick(window, i, GLFW_RELEASE);
}
}
@ -82,34 +83,34 @@ void _glfwInputDeactivation(void)
// Clear all input state
//========================================================================
void _glfwClearInput(void)
void _glfwClearInput(_GLFWwindow* window)
{
int i;
// Release all keyboard keys
for (i = 0; i <= GLFW_KEY_LAST; i++)
_glfwInput.Key[i] = GLFW_RELEASE;
window->key[i] = GLFW_RELEASE;
// Clear last character
_glfwInput.LastChar = 0;
window->lastChar = 0;
// Release all mouse buttons
for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
_glfwInput.MouseButton[i] = GLFW_RELEASE;
window->mouseButton[i] = GLFW_RELEASE;
// Set mouse position to (0,0)
_glfwInput.MousePosX = 0;
_glfwInput.MousePosY = 0;
window->mousePosX = 0;
window->mousePosY = 0;
// Set mouse wheel position to 0
_glfwInput.WheelPos = 0;
window->wheelPos = 0;
// The default is to use non sticky keys and mouse buttons
_glfwInput.StickyKeys = GL_FALSE;
_glfwInput.StickyMouseButtons = GL_FALSE;
window->stickyKeys = GL_FALSE;
window->stickyMouseButtons = GL_FALSE;
// The default is to disable key repeat
_glfwInput.KeyRepeat = GL_FALSE;
window->keyRepeat = GL_FALSE;
}
@ -117,30 +118,30 @@ void _glfwClearInput(void)
// Register keyboard activity
//========================================================================
void _glfwInputKey(int key, int action)
void _glfwInputKey(_GLFWwindow* window, int key, int action)
{
int keyrepeat = 0;
GLboolean keyrepeat = GL_FALSE;
if (key < 0 || key > GLFW_KEY_LAST)
return;
// Are we trying to release an already released key?
if (action == GLFW_RELEASE && _glfwInput.Key[key] != GLFW_PRESS)
if (action == GLFW_RELEASE && window->key[key] != GLFW_PRESS)
return;
// Register key action
if(action == GLFW_RELEASE && _glfwInput.StickyKeys)
_glfwInput.Key[key] = GLFW_STICK;
if(action == GLFW_RELEASE && window->stickyKeys)
window->key[key] = GLFW_STICK;
else
{
keyrepeat = (_glfwInput.Key[key] == GLFW_PRESS) &&
keyrepeat = (window->key[key] == GLFW_PRESS) &&
(action == GLFW_PRESS);
_glfwInput.Key[key] = (char) action;
window->key[key] = (char) action;
}
// Call user callback function
if (_glfwWin.keyCallback && (_glfwInput.KeyRepeat || !keyrepeat) )
_glfwWin.keyCallback(key, action);
if (window->keyCallback && (window->keyRepeat || !keyrepeat) )
window->keyCallback(key, action);
}
@ -148,7 +149,7 @@ void _glfwInputKey(int key, int action)
// Register (keyboard) character activity
//========================================================================
void _glfwInputChar(int character, int action)
void _glfwInputChar(_GLFWwindow* window, int character, int action)
{
int keyrepeat = 0;
@ -157,14 +158,14 @@ void _glfwInputChar(int character, int action)
return;
// Is this a key repeat?
if (action == GLFW_PRESS && _glfwInput.LastChar == character)
if (action == GLFW_PRESS && window->lastChar == character)
keyrepeat = 1;
// Store this character as last character (or clear it, if released)
if (action == GLFW_PRESS)
_glfwInput.LastChar = character;
window->lastChar = character;
else
_glfwInput.LastChar = 0;
window->lastChar = 0;
if (action != GLFW_PRESS)
{
@ -184,8 +185,8 @@ void _glfwInputChar(int character, int action)
return;
}
if (_glfwWin.charCallback && (_glfwInput.KeyRepeat || !keyrepeat))
_glfwWin.charCallback(character, action);
if (window->charCallback && (window->keyRepeat || !keyrepeat))
window->charCallback(character, action);
}
@ -193,20 +194,19 @@ void _glfwInputChar(int character, int action)
// Register mouse button clicks
//========================================================================
void _glfwInputMouseClick(int button, int action)
void _glfwInputMouseClick(_GLFWwindow* window, int button, int action)
{
if (button >= 0 && button <= GLFW_MOUSE_BUTTON_LAST)
{
// Register mouse button action
if (action == GLFW_RELEASE && _glfwInput.StickyMouseButtons)
_glfwInput.MouseButton[button] = GLFW_STICK;
else
_glfwInput.MouseButton[button] = (char) action;
if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
return;
// Call user callback function
if (_glfwWin.mouseButtonCallback)
_glfwWin.mouseButtonCallback(button, action);
}
// Register mouse button action
if (action == GLFW_RELEASE && window->stickyMouseButtons)
window->mouseButton[button] = GLFW_STICK;
else
window->mouseButton[button] = (char) action;
if (window->mouseButtonCallback)
window->mouseButtonCallback(button, action);
}
@ -393,16 +393,25 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
// Create the GLFW window and its associated context
//========================================================================
GLFWAPI int glfwOpenWindow(int width, int height,
GLFWAPI GLFWwindow glfwOpenWindow(int width, int height,
int redbits, int greenbits, int bluebits,
int alphabits, int depthbits, int stencilbits,
int mode)
{
_GLFWfbconfig fbconfig;
_GLFWwndconfig wndconfig;
_GLFWwindow* window;
if (!_glfwInitialized || _glfwWin.opened)
return GL_FALSE;
if (!_glfwInitialized || _glfwLibrary.window)
return NULL;
window = (_GLFWwindow*) malloc(sizeof(_GLFWwindow));
if (!window)
return NULL;
_glfwLibrary.window = window;
memset(window, 0, sizeof(_GLFWwindow));
// Set up desired framebuffer config
fbconfig.redBits = Max(redbits, 0);
@ -429,19 +438,25 @@ GLFWAPI int glfwOpenWindow(int width, int height,
wndconfig.glDebug = _glfwLibrary.hints.glDebug ? GL_TRUE : GL_FALSE;
wndconfig.glProfile = _glfwLibrary.hints.glProfile;
// Clear for next open call
_glfwClearWindowHints();
if (wndconfig.glMajor == 1 && wndconfig.glMinor > 5)
{
// OpenGL 1.x series ended with version 1.5
glfwCloseWindow(window);
return GL_FALSE;
}
else if (wndconfig.glMajor == 2 && wndconfig.glMinor > 1)
{
// OpenGL 2.x series ended with version 2.1
glfwCloseWindow(window);
return GL_FALSE;
}
else if (wndconfig.glMajor == 3 && wndconfig.glMinor > 3)
{
// OpenGL 3.x series ended with version 3.3
glfwCloseWindow(window);
return GL_FALSE;
}
else
@ -453,37 +468,26 @@ GLFWAPI int glfwOpenWindow(int width, int height,
(wndconfig.glMajor < 3 || (wndconfig.glMajor == 3 && wndconfig.glMinor < 2)))
{
// Context profiles are only defined for OpenGL version 3.2 and above
glfwCloseWindow(window);
return GL_FALSE;
}
if (wndconfig.glForward && wndconfig.glMajor < 3)
{
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above
glfwCloseWindow(window);
return GL_FALSE;
}
// Clear for next open call
_glfwClearWindowHints();
// Check input arguments
if (mode != GLFW_WINDOW && mode != GLFW_FULLSCREEN)
{
// Invalid window mode
glfwCloseWindow(window);
return GL_FALSE;
}
// Clear GLFW window state
_glfwWin.active = GL_TRUE;
_glfwWin.iconified = GL_FALSE;
_glfwWin.mouseLock = GL_FALSE;
_glfwClearInput();
// Unregister all callback functions
_glfwWin.windowSizeCallback = NULL;
_glfwWin.windowCloseCallback = NULL;
_glfwWin.windowRefreshCallback = NULL;
_glfwWin.keyCallback = NULL;
_glfwWin.charCallback = NULL;
_glfwWin.mousePosCallback = NULL;
_glfwWin.mouseButtonCallback = NULL;
_glfwWin.mouseWheelCallback = NULL;
_glfwClearInput(window);
// Check width & height
if (width > 0 && height <= 0)
@ -504,52 +508,68 @@ GLFWAPI int glfwOpenWindow(int width, int height,
}
// Remember window settings
_glfwWin.width = width;
_glfwWin.height = height;
_glfwWin.fullscreen = (mode == GLFW_FULLSCREEN ? GL_TRUE : GL_FALSE);
window->width = width;
window->height = height;
window->mode = mode;
// Platform specific window opening routine
if (!_glfwPlatformOpenWindow(width, height, &wndconfig, &fbconfig))
return GL_FALSE;
// Flag that window is now opened
_glfwWin.opened = GL_TRUE;
// Get window parameters (such as color buffer bits etc)
_glfwPlatformRefreshWindowParams();
// Get OpenGL version
_glfwParseGLVersion(&_glfwWin.glMajor, &_glfwWin.glMinor,
&_glfwWin.glRevision);
if (_glfwWin.glMajor < wndconfig.glMajor ||
(_glfwWin.glMajor == wndconfig.glMajor &&
_glfwWin.glMinor < wndconfig.glMinor))
if (!_glfwPlatformOpenWindow(window, width, height, &wndconfig, &fbconfig))
{
_glfwPlatformCloseWindow();
glfwCloseWindow(window);
return GL_FALSE;
}
if (_glfwWin.glMajor > 2)
// Get window parameters (such as color buffer bits etc)
glfwMakeWindowCurrent(window);
_glfwPlatformRefreshWindowParams();
// Get OpenGL version
_glfwParseGLVersion(&window->glMajor, &window->glMinor, &window->glRevision);
if (window->glMajor < wndconfig.glMajor ||
(window->glMajor == wndconfig.glMajor &&
window->glMinor < wndconfig.glMinor))
{
_glfwWin.GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
if (!_glfwWin.GetStringi)
// The desired OpenGL version is greater than the actual version
// This only happens if the machine lacks {GLX|WGL}_ARB_create_context
glfwCloseWindow(window);
return GL_FALSE;
}
if (window->glMajor > 2)
{
_glfwPlatformCloseWindow();
window->GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
if (!window->GetStringi)
{
glfwCloseWindow(window);
return GL_FALSE;
}
}
// If full-screen mode was requested, disable mouse cursor
if (mode == GLFW_FULLSCREEN)
glfwDisable(GLFW_MOUSE_CURSOR);
glfwDisable(window, GLFW_MOUSE_CURSOR);
// Start by clearing the front buffer to black (avoid ugly desktop
// remains in our OpenGL window)
glClear(GL_COLOR_BUFFER_BIT);
_glfwPlatformSwapBuffers();
return GL_TRUE;
return window;
}
//========================================================================
// Make the OpenGL context associated with the specified window current
//========================================================================
GLFWAPI void glfwMakeWindowCurrent(GLFWwindow window)
{
if (_glfwLibrary.currentWindow == window)
return;
_glfwPlatformMakeWindowCurrent(window);
_glfwLibrary.currentWindow = window;
}
@ -616,18 +636,24 @@ GLFWAPI void glfwOpenWindowHint(int target, int hint)
// Properly kill the window / video display
//========================================================================
GLFWAPI void glfwCloseWindow(void)
GLFWAPI void glfwCloseWindow(GLFWwindow window)
{
if (!_glfwInitialized)
return;
// Show mouse pointer again (if hidden)
glfwEnable(GLFW_MOUSE_CURSOR);
if (window == _glfwLibrary.cursorLockWindow)
glfwEnable(window, GLFW_MOUSE_CURSOR);
_glfwPlatformCloseWindow();
if (window == _glfwLibrary.currentWindow)
glfwMakeWindowCurrent(NULL);
memset(&_glfwWin, 0, sizeof(_glfwWin));
_glfwWin.opened = GL_FALSE;
_glfwPlatformCloseWindow(window);
free(window);
// Yuck
_glfwLibrary.window = NULL;
}
@ -635,13 +661,12 @@ GLFWAPI void glfwCloseWindow(void)
// Set the window title
//========================================================================
GLFWAPI void glfwSetWindowTitle(const char* title)
GLFWAPI void glfwSetWindowTitle(GLFWwindow window, const char* title)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set window title
_glfwPlatformSetWindowTitle(title);
_glfwPlatformSetWindowTitle(window, title);
}
@ -649,13 +674,16 @@ GLFWAPI void glfwSetWindowTitle(const char* title)
// Get the window size
//========================================================================
GLFWAPI void glfwGetWindowSize(int* width, int* height)
GLFWAPI void glfwGetWindowSize(GLFWwindow window, int* width, int* height)
{
if (!_glfwInitialized)
return;
if (width != NULL)
*width = _glfwWin.width;
*width = window->width;
if (height != NULL)
*height = _glfwWin.height;
*height = window->height;
}
@ -663,21 +691,23 @@ GLFWAPI void glfwGetWindowSize(int* width, int* height)
// Set the window size
//========================================================================
GLFWAPI void glfwSetWindowSize(int width, int height)
GLFWAPI void glfwSetWindowSize(GLFWwindow window, int width, int height)
{
if (!_glfwInitialized || !_glfwWin.opened || _glfwWin.iconified)
if (!_glfwInitialized || window->iconified)
return;
// Don't do anything if the window size did not change
if (width == _glfwWin.width && height == _glfwWin.height)
if (width == window->width && height == window->height)
return;
// Change window size
_glfwPlatformSetWindowSize(width, height);
_glfwPlatformSetWindowSize(window, width, height);
if (window->mode == GLFW_FULLSCREEN)
{
// Refresh window parameters (may have changed due to changed video
// modes)
_glfwPlatformRefreshWindowParams();
}
}
@ -685,16 +715,14 @@ GLFWAPI void glfwSetWindowSize(int width, int height)
// Set the window position
//========================================================================
GLFWAPI void glfwSetWindowPos(int x, int y)
GLFWAPI void glfwSetWindowPos(GLFWwindow window, int x, int y)
{
if (!_glfwInitialized || !_glfwWin.opened || _glfwWin.fullscreen ||
_glfwWin.iconified)
if (!_glfwInitialized || window->mode == GLFW_FULLSCREEN || window->iconified)
{
return;
}
// Set window position
_glfwPlatformSetWindowPos(x, y);
_glfwPlatformSetWindowPos(window, x, y);
}
@ -702,13 +730,12 @@ GLFWAPI void glfwSetWindowPos(int x, int y)
// Window iconification
//========================================================================
GLFWAPI void glfwIconifyWindow(void)
GLFWAPI void glfwIconifyWindow(GLFWwindow window)
{
if (!_glfwInitialized || !_glfwWin.opened || _glfwWin.iconified)
if (!_glfwInitialized || window->iconified)
return;
// Iconify window
_glfwPlatformIconifyWindow();
_glfwPlatformIconifyWindow(window);
}
@ -716,30 +743,29 @@ GLFWAPI void glfwIconifyWindow(void)
// Window un-iconification
//========================================================================
GLFWAPI void glfwRestoreWindow(void)
GLFWAPI void glfwRestoreWindow(GLFWwindow window)
{
if (!_glfwInitialized || !_glfwWin.opened || !_glfwWin.iconified)
if (!_glfwInitialized || !window->iconified)
return;
// Restore iconified window
_glfwPlatformRestoreWindow();
_glfwPlatformRestoreWindow(window);
// Refresh window parameters
if (window->mode == GLFW_FULLSCREEN)
_glfwPlatformRefreshWindowParams();
}
//========================================================================
// Swap buffers (double-buffering) and poll any new events
// Swap buffers (double-buffering)
//========================================================================
GLFWAPI void glfwSwapBuffers(void)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Update display-buffer
if (_glfwWin.opened)
if (_glfwLibrary.currentWindow)
_glfwPlatformSwapBuffers();
}
@ -750,10 +776,9 @@ GLFWAPI void glfwSwapBuffers(void)
GLFWAPI void glfwSwapInterval(int interval)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set double buffering swap interval
_glfwPlatformSwapInterval(interval);
}
@ -762,70 +787,59 @@ GLFWAPI void glfwSwapInterval(int interval)
// Get window parameter
//========================================================================
GLFWAPI int glfwGetWindowParam(int param)
GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param)
{
if (!_glfwInitialized)
return 0;
if (!_glfwWin.opened)
{
if (param == GLFW_OPENED)
return GL_FALSE;
return 0;
}
// Window parameters
switch (param)
{
case GLFW_OPENED:
return GL_TRUE;
case GLFW_ACTIVE:
return _glfwWin.active;
return window->active;
case GLFW_ICONIFIED:
return _glfwWin.iconified;
return window->iconified;
case GLFW_ACCELERATED:
return _glfwWin.accelerated;
return window->accelerated;
case GLFW_RED_BITS:
return _glfwWin.redBits;
return window->redBits;
case GLFW_GREEN_BITS:
return _glfwWin.greenBits;
return window->greenBits;
case GLFW_BLUE_BITS:
return _glfwWin.blueBits;
return window->blueBits;
case GLFW_ALPHA_BITS:
return _glfwWin.alphaBits;
return window->alphaBits;
case GLFW_DEPTH_BITS:
return _glfwWin.depthBits;
return window->depthBits;
case GLFW_STENCIL_BITS:
return _glfwWin.stencilBits;
return window->stencilBits;
case GLFW_ACCUM_RED_BITS:
return _glfwWin.accumRedBits;
return window->accumRedBits;
case GLFW_ACCUM_GREEN_BITS:
return _glfwWin.accumGreenBits;
return window->accumGreenBits;
case GLFW_ACCUM_BLUE_BITS:
return _glfwWin.accumBlueBits;
return window->accumBlueBits;
case GLFW_ACCUM_ALPHA_BITS:
return _glfwWin.accumAlphaBits;
return window->accumAlphaBits;
case GLFW_AUX_BUFFERS:
return _glfwWin.auxBuffers;
return window->auxBuffers;
case GLFW_STEREO:
return _glfwWin.stereo;
return window->stereo;
case GLFW_REFRESH_RATE:
return _glfwWin.refreshRate;
return window->refreshRate;
case GLFW_WINDOW_NO_RESIZE:
return _glfwWin.windowNoResize;
return window->windowNoResize;
case GLFW_FSAA_SAMPLES:
return _glfwWin.samples;
return window->samples;
case GLFW_OPENGL_VERSION_MAJOR:
return _glfwWin.glMajor;
return window->glMajor;
case GLFW_OPENGL_VERSION_MINOR:
return _glfwWin.glMinor;
return window->glMinor;
case GLFW_OPENGL_FORWARD_COMPAT:
return _glfwWin.glForward;
return window->glForward;
case GLFW_OPENGL_DEBUG_CONTEXT:
return _glfwWin.glDebug;
return window->glDebug;
case GLFW_OPENGL_PROFILE:
return _glfwWin.glProfile;
return window->glProfile;
default:
return 0;
}
@ -836,31 +850,29 @@ GLFWAPI int glfwGetWindowParam(int param)
// Set callback function for window size changes
//========================================================================
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set callback function
_glfwWin.windowSizeCallback = cbfun;
window->windowSizeCallback = cbfun;
// Call the callback function to let the application know the current
// window size
if (cbfun)
cbfun(_glfwWin.width, _glfwWin.height);
cbfun(window->width, window->height);
}
//========================================================================
// Set callback function for window close events
//========================================================================
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set callback function
_glfwWin.windowCloseCallback = cbfun;
window->windowCloseCallback = cbfun;
}
@ -868,13 +880,12 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
// Set callback function for window refresh events
//========================================================================
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Set callback function
_glfwWin.windowRefreshCallback = cbfun;
window->windowRefreshCallback = cbfun;
}
@ -884,10 +895,9 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
GLFWAPI void glfwPollEvents(void)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Poll for new events
_glfwPlatformPollEvents();
}
@ -898,10 +908,9 @@ GLFWAPI void glfwPollEvents(void)
GLFWAPI void glfwWaitEvents(void)
{
if (!_glfwInitialized || !_glfwWin.opened)
if (!_glfwInitialized)
return;
// Poll for new events
_glfwPlatformWaitEvents();
}

151
lib/x11/platform.h
View File

@ -161,6 +161,10 @@ typedef const GLubyte* (APIENTRY *PFNGLGETSTRINGIPROC)(GLenum, GLuint);
#endif /*GL_VERSION_3_0*/
#define _GLFW_PLATFORM_WINDOW_STATE _GLFWwindowX11 X11
#define _GLFW_PLATFORM_LIBRARY_STATE _GLFWlibraryX11 X11
//========================================================================
// Global variables (GLFW internals)
@ -169,59 +173,7 @@ typedef const GLubyte* (APIENTRY *PFNGLGETSTRINGIPROC)(GLenum, GLuint);
//------------------------------------------------------------------------
// Window structure
//------------------------------------------------------------------------
typedef struct _GLFWwin_struct _GLFWwin;
struct _GLFWwin_struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// User callback functions
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWmouseposfun mousePosCallback;
GLFWmousewheelfun mouseWheelCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
// User selected window settings
int fullscreen; // Fullscreen flag
int mouseLock; // Mouse-lock flag
int sysKeysDisabled; // System keys disabled flag
int windowNoResize; // Resize- and maximize gadgets disabled flag
int refreshRate; // Vertical monitor refresh rate
// Window status & parameters
int opened; // Flag telling if window is opened or not
int active; // Application active flag
int iconified; // Window iconified flag
int width, height; // Window width and heigth
int accelerated; // GL_TRUE if window is HW accelerated
// Framebuffer attributes
int redBits;
int greenBits;
int blueBits;
int alphaBits;
int depthBits;
int stencilBits;
int accumRedBits;
int accumGreenBits;
int accumBlueBits;
int accumAlphaBits;
int auxBuffers;
int stereo;
int samples;
// OpenGL extensions and context attributes
int glMajor, glMinor, glRevision;
int glForward, glDebug, glProfile;
PFNGLGETSTRINGIPROC GetStringi;
// ========= PLATFORM SPECIFIC PART ======================================
typedef struct _GLFWwindowX11 {
// Platform specific window resources
Colormap colormap; // Window colormap
@ -238,6 +190,8 @@ struct _GLFWwin_struct {
Atom wmActiveWindow; // _NET_ACTIVE_WINDOW atom
Cursor cursor; // Invisible cursor for hidden cursor
int mouseMoved, cursorPosX, cursorPosY;
// GLX extensions
PFNGLXSWAPINTERVALSGIPROC SwapIntervalSGI;
PFNGLXGETFBCONFIGATTRIBSGIXPROC GetFBConfigAttribSGIX;
@ -258,6 +212,30 @@ struct _GLFWwin_struct {
GLboolean pointerGrabbed; // True if pointer is currently grabbed
GLboolean pointerHidden; // True if pointer is currently hidden
} _GLFWwindowX11;
//------------------------------------------------------------------------
// Platform-specific ibrary global data
//------------------------------------------------------------------------
typedef struct {
Display* display;
// Server-side GLX version
int glxMajor, glxMinor;
struct {
int available;
int eventBase;
int errorBase;
} XF86VidMode;
struct {
int available;
int eventBase;
int errorBase;
} XRandR;
// Screensaver data
struct {
int changed;
@ -280,69 +258,6 @@ struct _GLFWwin_struct {
Rotation oldRotation;
#endif
} FS;
};
GLFWGLOBAL _GLFWwin _glfwWin;
//------------------------------------------------------------------------
// User input status (most of this should go in _GLFWwin)
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Mouse status
int MousePosX, MousePosY;
int WheelPos;
char MouseButton[ GLFW_MOUSE_BUTTON_LAST+1 ];
// Keyboard status
char Key[ GLFW_KEY_LAST+1 ];
int LastChar;
// User selected settings
int StickyKeys;
int StickyMouseButtons;
int KeyRepeat;
// ========= PLATFORM SPECIFIC PART ======================================
// Platform specific internal variables
int MouseMoved, CursorPosX, CursorPosY;
} _glfwInput;
//------------------------------------------------------------------------
// Library global data
//------------------------------------------------------------------------
GLFWGLOBAL struct {
// ========= PLATFORM INDEPENDENT MANDATORY PART =========================
// Window opening hints
_GLFWhints hints;
// ========= PLATFORM SPECIFIC PART ======================================
Display* display;
// Server-side GLX version
int glxMajor, glxMinor;
struct {
int available;
int eventBase;
int errorBase;
} XF86VidMode;
struct {
int available;
int eventBase;
int errorBase;
} XRandR;
// Timer data
struct {
@ -355,7 +270,7 @@ GLFWGLOBAL struct {
void* libGL; // dlopen handle for libGL.so
} Libs;
#endif
} _glfwLibrary;
} _GLFWlibraryX11;
//------------------------------------------------------------------------
@ -382,7 +297,7 @@ void _glfwInitTimer(void);
int _glfwGetClosestVideoMode(int screen, int* width, int* height, int* rate);
void _glfwSetVideoModeMODE(int screen, int mode, int rate);
void _glfwSetVideoMode(int screen, int* width, int* height, int* rate);
void _glfwRestoreVideoMode(void);
void _glfwRestoreVideoMode(int screen);
// Joystick input
void _glfwInitJoysticks(void);

14
lib/x11/x11_enable.c
View File

@ -39,12 +39,12 @@
// Enable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys(void)
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
{
if (_glfwWin.keyboardGrabbed)
if (window->X11.keyboardGrabbed)
{
XUngrabKeyboard(_glfwLibrary.display, CurrentTime);
_glfwWin.keyboardGrabbed = GL_FALSE;
XUngrabKeyboard(_glfwLibrary.X11.display, CurrentTime);
window->X11.keyboardGrabbed = GL_FALSE;
}
}
@ -52,13 +52,13 @@ void _glfwPlatformEnableSystemKeys(void)
// Disable system keys
//========================================================================
void _glfwPlatformDisableSystemKeys(void)
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
{
if (XGrabKeyboard(_glfwLibrary.display, _glfwWin.window,
if (XGrabKeyboard(_glfwLibrary.X11.display, window->X11.window,
True, GrabModeAsync, GrabModeAsync, CurrentTime)
== GrabSuccess)
{
_glfwWin.keyboardGrabbed = GL_TRUE;
window->X11.keyboardGrabbed = GL_TRUE;
}
}

104
lib/x11/x11_fullscreen.c
View File

@ -75,10 +75,10 @@ int _glfwGetClosestVideoMode(int screen, int* width, int* height, int* rate)
XRRScreenConfiguration* sc;
XRRScreenSize* sizelist;
if (_glfwLibrary.XRandR.available)
if (_glfwLibrary.X11.XRandR.available)
{
sc = XRRGetScreenInfo(_glfwLibrary.display,
RootWindow(_glfwLibrary.display, screen));
sc = XRRGetScreenInfo(_glfwLibrary.X11.display,
RootWindow(_glfwLibrary.X11.display, screen));
sizelist = XRRConfigSizes(sc, &sizecount);
@ -174,8 +174,8 @@ int _glfwGetClosestVideoMode(int screen, int* width, int* height, int* rate)
#endif
// Default: Simply use the screen resolution
*width = DisplayWidth(_glfwLibrary.display, screen);
*height = DisplayHeight(_glfwLibrary.display, screen);
*width = DisplayWidth(_glfwLibrary.X11.display, screen);
*height = DisplayHeight(_glfwLibrary.X11.display, screen);
return 0;
}
@ -191,25 +191,25 @@ void _glfwSetVideoModeMODE(int screen, int mode, int rate)
XRRScreenConfiguration* sc;
Window root;
if (_glfwLibrary.XRandR.available)
if (_glfwLibrary.X11.XRandR.available)
{
root = RootWindow(_glfwLibrary.display, screen);
sc = XRRGetScreenInfo(_glfwLibrary.display, root);
root = RootWindow(_glfwLibrary.X11.display, screen);
sc = XRRGetScreenInfo(_glfwLibrary.X11.display, root);
// Remember old size and flag that we have changed the mode
if (!_glfwWin.FS.modeChanged)
if (!_glfwLibrary.X11.FS.modeChanged)
{
_glfwWin.FS.oldSizeID = XRRConfigCurrentConfiguration(sc, &_glfwWin.FS.oldRotation);
_glfwWin.FS.oldWidth = DisplayWidth(_glfwLibrary.display, screen);
_glfwWin.FS.oldHeight = DisplayHeight(_glfwLibrary.display, screen);
_glfwLibrary.X11.FS.oldSizeID = XRRConfigCurrentConfiguration(sc, &_glfwLibrary.X11.FS.oldRotation);
_glfwLibrary.X11.FS.oldWidth = DisplayWidth(_glfwLibrary.X11.display, screen);
_glfwLibrary.X11.FS.oldHeight = DisplayHeight(_glfwLibrary.X11.display, screen);
_glfwWin.FS.modeChanged = GL_TRUE;
_glfwLibrary.X11.FS.modeChanged = GL_TRUE;
}
if (rate > 0)
{
// Set desired configuration
XRRSetScreenConfigAndRate(_glfwLibrary.display,
XRRSetScreenConfigAndRate(_glfwLibrary.X11.display,
sc,
root,
mode,
@ -220,7 +220,7 @@ void _glfwSetVideoModeMODE(int screen, int mode, int rate)
else
{
// Set desired configuration
XRRSetScreenConfig(_glfwLibrary.display,
XRRSetScreenConfig(_glfwLibrary.X11.display,
sc,
root,
mode,
@ -235,31 +235,31 @@ void _glfwSetVideoModeMODE(int screen, int mode, int rate)
int modecount;
// Use the XF86VidMode extension to control video resolution
if (_glfwLibrary.XF86VidMode.available)
if (_glfwLibrary.X11.XF86VidMode.available)
{
// Get a list of all available display modes
XF86VidModeGetAllModeLines(_glfwLibrary.display, screen,
XF86VidModeGetAllModeLines(_glfwLibrary.X11.display, screen,
&modecount, &modelist);
// Unlock mode switch if necessary
if (_glfwWin.FS.modeChanged)
XF86VidModeLockModeSwitch(_glfwLibrary.display, screen, 0);
if (_glfwLibrary.X11.FS.modeChanged)
XF86VidModeLockModeSwitch(_glfwLibrary.X11.display, screen, 0);
// Change the video mode to the desired mode
XF86VidModeSwitchToMode(_glfwLibrary.display, screen,
XF86VidModeSwitchToMode(_glfwLibrary.X11.display, screen,
modelist[mode]);
// Set viewport to upper left corner (where our window will be)
XF86VidModeSetViewPort(_glfwLibrary.display, screen, 0, 0);
XF86VidModeSetViewPort(_glfwLibrary.X11.display, screen, 0, 0);
// Lock mode switch
XF86VidModeLockModeSwitch(_glfwLibrary.display, screen, 1);
XF86VidModeLockModeSwitch(_glfwLibrary.X11.display, screen, 1);
// Remember old mode and flag that we have changed the mode
if (!_glfwWin.FS.modeChanged)
if (!_glfwLibrary.X11.FS.modeChanged)
{
_glfwWin.FS.oldMode = *modelist[0];
_glfwWin.FS.modeChanged = GL_TRUE;
_glfwLibrary.X11.FS.oldMode = *modelist[0];
_glfwLibrary.X11.FS.modeChanged = GL_TRUE;
}
// Free mode list
@ -289,42 +289,44 @@ void _glfwSetVideoMode(int screen, int* width, int* height, int* rate)
// Restore the previously saved (original) video mode
//========================================================================
void _glfwRestoreVideoMode(void)
void _glfwRestoreVideoMode(int screen)
{
if (_glfwWin.FS.modeChanged)
if (_glfwLibrary.X11.FS.modeChanged)
{
#if defined(_GLFW_HAS_XRANDR)
if (_glfwLibrary.XRandR.available)
Window root = RootWindow(_glfwLibrary.X11.display, screen);
if (_glfwLibrary.X11.XRandR.available)
{
XRRScreenConfiguration* sc;
if (_glfwLibrary.XRandR.available)
if (_glfwLibrary.X11.XRandR.available)
{
sc = XRRGetScreenInfo(_glfwLibrary.display, _glfwWin.root);
sc = XRRGetScreenInfo(_glfwLibrary.X11.display, root);
XRRSetScreenConfig(_glfwLibrary.display,
XRRSetScreenConfig(_glfwLibrary.X11.display,
sc,
_glfwWin.root,
_glfwWin.FS.oldSizeID,
_glfwWin.FS.oldRotation,
root,
_glfwLibrary.X11.FS.oldSizeID,
_glfwLibrary.X11.FS.oldRotation,
CurrentTime);
XRRFreeScreenConfigInfo(sc);
}
}
#elif defined(_GLFW_HAS_XF86VIDMODE)
if (_glfwLibrary.XF86VidMode.available)
if (_glfwLibrary.X11.XF86VidMode.available)
{
// Unlock mode switch
XF86VidModeLockModeSwitch(_glfwLibrary.display, _glfwWin.screen, 0);
XF86VidModeLockModeSwitch(_glfwLibrary.X11.display, screen, 0);
// Change the video mode back to the old mode
XF86VidModeSwitchToMode(_glfwLibrary.display,
_glfwWin.screen,
&_glfwWin.FS.oldMode);
XF86VidModeSwitchToMode(_glfwLibrary.X11.display,
screen,
&_glfwLibrary.X11.FS.oldMode);
}
#endif
_glfwWin.FS.modeChanged = GL_FALSE;
_glfwLibrary.X11.FS.modeChanged = GL_FALSE;
}
}
@ -364,7 +366,7 @@ int _glfwPlatformGetVideoModes(GLFWvidmode* list, int maxcount)
#endif
// Get display and screen
dpy = _glfwLibrary.display;
dpy = _glfwLibrary.X11.display;
screen = DefaultScreen(dpy);
// Get list of visuals
@ -410,7 +412,7 @@ int _glfwPlatformGetVideoModes(GLFWvidmode* list, int maxcount)
// Build resolution array
#if defined(_GLFW_HAS_XRANDR)
if (_glfwLibrary.XRandR.available)
if (_glfwLibrary.X11.XRandR.available)
{
sc = XRRGetScreenInfo(dpy, RootWindow(dpy, screen));
sizelist = XRRConfigSizes(sc, &sizecount);
@ -505,7 +507,7 @@ void _glfwPlatformGetDesktopMode(GLFWvidmode* mode)
#endif
// Get display and screen
dpy = _glfwLibrary.display;
dpy = _glfwLibrary.X11.display;
screen = DefaultScreen(dpy);
// Get display depth
@ -515,23 +517,23 @@ void _glfwPlatformGetDesktopMode(GLFWvidmode* mode)
BPP2RGB(bpp, &mode->redBits, &mode->greenBits, &mode->blueBits);
#if defined(_GLFW_HAS_XRANDR)
if (_glfwLibrary.XRandR.available)
if (_glfwLibrary.X11.XRandR.available)
{
if (_glfwWin.FS.modeChanged)
if (_glfwLibrary.X11.FS.modeChanged)
{
mode->width = _glfwWin.FS.oldWidth;
mode->height = _glfwWin.FS.oldHeight;
mode->width = _glfwLibrary.X11.FS.oldWidth;
mode->height = _glfwLibrary.X11.FS.oldHeight;
return;
}
}
#elif defined(_GLFW_HAS_XF86VIDMODE)
if (_glfwLibrary.XF86VidMode.available)
if (_glfwLibrary.X11.XF86VidMode.available)
{
if (_glfwWin.FS.modeChanged)
if (_glfwLibrary.X11.FS.modeChanged)
{
// The old (desktop) mode is stored in _glfwWin.FS.oldMode
mode->width = _glfwWin.FS.oldMode.hdisplay;
mode->height = _glfwWin.FS.oldMode.vdisplay;
mode->width = _glfwLibrary.X11.FS.oldMode.hdisplay;
mode->height = _glfwLibrary.X11.FS.oldMode.vdisplay;
}
else
{

5
lib/x11/x11_glext.c
View File

@ -65,8 +65,9 @@ int _glfwPlatformExtensionSupported(const char* extension)
const GLubyte* extensions;
// Get list of GLX extensions
extensions = (const GLubyte*) glXQueryExtensionsString(_glfwLibrary.display,
_glfwWin.screen);
// Yuck
extensions = (const GLubyte*) glXQueryExtensionsString(_glfwLibrary.X11.display,
_glfwLibrary.window->X11.screen);
if (extensions != NULL)
{
if (_glfwStringInExtensionString(extension, extensions))

42
lib/x11/x11_init.c
View File

@ -82,8 +82,8 @@ static void glfw_atexit(void)
static int initDisplay(void)
{
// Open display
_glfwLibrary.display = XOpenDisplay(0);
if (!_glfwLibrary.display)
_glfwLibrary.X11.display = XOpenDisplay(0);
if (!_glfwLibrary.X11.display)
{
fprintf(stderr, "Failed to open X display\n");
return GL_FALSE;
@ -91,36 +91,36 @@ static int initDisplay(void)
// Check for XF86VidMode extension
#ifdef _GLFW_HAS_XF86VIDMODE
_glfwLibrary.XF86VidMode.available =
XF86VidModeQueryExtension(_glfwLibrary.display,
&_glfwLibrary.XF86VidMode.eventBase,
&_glfwLibrary.XF86VidMode.errorBase);
_glfwLibrary.X11.XF86VidMode.available =
XF86VidModeQueryExtension(_glfwLibrary.X11.display,
&_glfwLibrary.X11.XF86VidMode.eventBase,
&_glfwLibrary.X11.XF86VidMode.errorBase);
#else
_glfwLibrary.XF86VidMode.available = 0;
_glfwLibrary.X11.XF86VidMode.available = 0;
#endif
// Check for XRandR extension
#ifdef _GLFW_HAS_XRANDR
_glfwLibrary.XRandR.available =
XRRQueryExtension(_glfwLibrary.display,
&_glfwLibrary.XRandR.eventBase,
&_glfwLibrary.XRandR.errorBase);
_glfwLibrary.X11.XRandR.available =
XRRQueryExtension(_glfwLibrary.X11.display,
&_glfwLibrary.X11.XRandR.eventBase,
&_glfwLibrary.X11.XRandR.errorBase);
#else
_glfwLibrary.XRandR.available = 0;
_glfwLibrary.X11.XRandR.available = 0;
#endif
// Fullscreen & screen saver settings
// Check if GLX is supported on this display
if (!glXQueryExtension(_glfwLibrary.display, NULL, NULL))
if (!glXQueryExtension(_glfwLibrary.X11.display, NULL, NULL))
{
fprintf(stderr, "GLX not supported\n");
return GL_FALSE;
}
// Retrieve GLX version
if (!glXQueryVersion(_glfwLibrary.display,
&_glfwLibrary.glxMajor,
&_glfwLibrary.glxMinor))
if (!glXQueryVersion(_glfwLibrary.X11.display,
&_glfwLibrary.X11.glxMajor,
&_glfwLibrary.X11.glxMinor))
{
fprintf(stderr, "Unable to query GLX version\n");
return GL_FALSE;
@ -137,10 +137,10 @@ static int initDisplay(void)
static void terminateDisplay(void)
{
// Open display
if (_glfwLibrary.display)
if (_glfwLibrary.X11.display)
{
XCloseDisplay(_glfwLibrary.display);
_glfwLibrary.display = NULL;
XCloseDisplay(_glfwLibrary.X11.display);
_glfwLibrary.X11.display = NULL;
}
}
@ -180,8 +180,8 @@ int _glfwPlatformInit(void)
int _glfwPlatformTerminate(void)
{
// Close OpenGL window
glfwCloseWindow();
if (_glfwLibrary.window)
glfwCloseWindow(_glfwLibrary.window);
// Terminate display
terminateDisplay();

8
lib/x11/x11_time.c
View File

@ -40,11 +40,11 @@ void _glfwInitTimer(void)
struct timeval tv;
// "Resolution" is 1 us
_glfwLibrary.Timer.resolution = 1e-6;
_glfwLibrary.X11.Timer.resolution = 1e-6;
// Set start-time for timer
gettimeofday(&tv, NULL);
_glfwLibrary.Timer.t0 = (long long) tv.tv_sec * (long long) 1000000 +
_glfwLibrary.X11.Timer.t0 = (long long) tv.tv_sec * (long long) 1000000 +
(long long) tv.tv_usec;
}
@ -66,7 +66,7 @@ double _glfwPlatformGetTime(void)
t = (long long) tv.tv_sec * (long long) 1000000 +
(long long) tv.tv_usec;
return (double)(t - _glfwLibrary.Timer.t0) * _glfwLibrary.Timer.resolution;
return (double)(t - _glfwLibrary.X11.Timer.t0) * _glfwLibrary.X11.Timer.resolution;
}
@ -84,6 +84,6 @@ void _glfwPlatformSetTime(double t)
(long long) tv.tv_usec;
// Calulate new starting time
_glfwLibrary.Timer.t0 = t0 - (long long)(t / _glfwLibrary.Timer.resolution);
_glfwLibrary.X11.Timer.t0 = t0 - (long long)(t / _glfwLibrary.X11.Timer.resolution);
}

786
lib/x11/x11_window.c
View File

File diff suppressed because it is too large Load Diff