Zengtudor
/
glfw
mirror of https://github.com/glfw/glfw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into multi-monitor 

Conflicts:
	include/GL/glfw3.h
	readme.html
	src/CMakeLists.txt
	src/win32_window.c
	src/window.c
	src/x11_window.c
	tests/clipboard.c
	tests/defaults.c
	tests/events.c
	tests/fsfocus.c
	tests/glfwinfo.c
	tests/joysticks.c
	tests/peter.c
	tests/sharing.c
	tests/tearing.c
	tests/title.c
	tests/windows.c
This commit is contained in:
Camilla Berglund 2012-11-27 16:55:04 +01:00
parent 0f93d24306 fc69721807
commit 41bc0d18f4
36 changed files with 1239 additions and 678 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/gears.c
View File

@ -359,8 +359,6 @@ int main(int argc, char *argv[])
glfwGetWindowSize(window, &width, &height);
reshape(window, width, height);
glfwSetInputMode( window, GLFW_KEY_REPEAT, GL_TRUE );
// Parse command-line options
init(argc, argv);

2
examples/wave.c
View File

@ -419,8 +419,6 @@ int main(int argc, char* argv[])
glfwGetWindowSize(window, &width, &height);
window_size_callback(window, width, height);
glfwSetInputMode(window, GLFW_KEY_REPEAT, GL_TRUE);
// Initialize OpenGL
init_opengl();

1128
include/GL/glfw3.h
View File

File diff suppressed because it is too large Load Diff

9
readme.html
View File

@ -285,7 +285,6 @@ version of GLFW.</p>
<li>Added <code>glfwSetWindowIconifyCallback</code> function and <code>GLFWwindowiconifyfun</code> type for receiving window iconification events</li>
<li>Added <code>glfwGetClipboardString</code> and <code>glfwSetClipboardString</code> functions for interacting with the system clipboard</li>
<li>Added <code>glfwGetCurrentContext</code> function for retrieving the window whose OpenGL context is current</li>
<li>Added <code>glfwCopyContext</code> function for copying OpenGL state categories between contexts</li>
<li>Added <code>GLFW_CLIENT_API</code>, <code>GLFW_OPENGL_API</code> and <code>GLFW_OPENGL_ES_API</code> for selecting client API</li>
<li>Added <code>GLFW_OPENGL_ROBUSTNESS</code> window hint and associated strategy tokens for <code>GL_ARB_robustness</code> support</li>
<li>Added <code>GLFW_OPENGL_REVISION</code> window parameter to make up for removal of <code>glfwGetGLVersion</code></li>
@ -304,6 +303,7 @@ version of GLFW.</p>
<li>Changed <code>glfwGetVideoModes</code> to return a dynamic, unlimited number of video modes for the specified monitor</li>
<li>Renamed <code>glfw.h</code> to <code>glfw3.h</code> to avoid conflicts with 2.x series</li>
<li>Renamed <code>glfwOpenWindowHint</code> to <code>glfwWindowHint</code></li>
<li>Renamed <code>GLFW_ACTIVE</code> to <code>GLFW_FOCUSED</code></li>
<li>Renamed <code>GLFW_WINDOW_NO_RESIZE</code> to <code>GLFW_RESIZABLE</code></li>
<li>Renamed <code>GLFW_BUILD_DLL</code> to <code>_GLFW_BUILD_DLL</code></li>
<li>Renamed <code>version</code> test to <code>glfwinfo</code></li>
@ -318,7 +318,7 @@ version of GLFW.</p>
<li>Replaced <code>glfwEnable</code> and <code>glfwDisable</code> with <code>glfwGetInputMode</code> and <code>glfwSetInputMode</code></li>
<li>Replaced <code>joystick</code> test with graphical version</li>
<li>Replaced automatic closing of windows with <code>GLFW_CLOSE_REQUESTED</code> window parameter</li>
<li>Made Unicode character input unaffected by <code>GLFW_KEY_REPEAT</code></li>
<li>Removed the <code>GLFW_KEY_REPEAT</code> input option</li>
<li>Removed event auto-polling and the <code>GLFW_AUTO_POLL_EVENTS</code> window enable</li>
<li>Removed the Win32 port .def files</li>
<li>Removed the entire threading API</li>
@ -944,8 +944,9 @@ their skills. Special thanks go out to:</p>
Leopard</li>
<li>Riku Salminen, for the initial implementation of
<code>glfwShowWindow</code> and <code>glfwHideWindow</code>, and for making
the X11 event processing able to support multi-threaded rendering</li>
<code>glfwShowWindow</code> and <code>glfwHideWindow</code>, for the idea of
<code>glfwDefaultWindowHints</code> and for making the X11 event processing
able to support multi-threaded rendering</li>
<li>Douglas C. Schmidt and Irfan Pyarali, for their excellent article
<a href="http://www.cs.wustl.edu/~schmidt/win32-cv-1.html">Strategies for Implementing POSIX Condition Variables on Win32</a></li>

8
src/CMakeLists.txt
View File

@ -14,7 +14,7 @@ set(common_SOURCES clipboard.c gamma.c init.c input.c joystick.c monitor.c
if (_GLFW_COCOA_NSGL)
set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h)
set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_gamma.c
cocoa_init.m cocoa_input.m cocoa_joystick.m cocoa_monitor.m
cocoa_init.m cocoa_joystick.m cocoa_monitor.m
cocoa_opengl.m cocoa_time.c cocoa_window.m)
if (GLFW_NATIVE_API)
@ -26,7 +26,7 @@ if (_GLFW_COCOA_NSGL)
elseif (_GLFW_WIN32_WGL)
set(glfw_HEADERS ${common_HEADERS} win32_platform.h)
set(glfw_SOURCES ${common_SOURCES} win32_clipboard.c win32_gamma.c
win32_init.c win32_input.c win32_joystick.c win32_monitor.c
win32_init.c win32_joystick.c win32_monitor.c
win32_opengl.c win32_time.c win32_window.c)
if (GLFW_NATIVE_API)
@ -35,8 +35,8 @@ elseif (_GLFW_WIN32_WGL)
elseif (_GLFW_X11_GLX)
set(glfw_HEADERS ${common_HEADERS} x11_platform.h)
set(glfw_SOURCES ${common_SOURCES} x11_clipboard.c x11_gamma.c x11_init.c
x11_input.c x11_joystick.c x11_keysym2unicode.c
x11_monitor.c x11_opengl.c x11_time.c x11_window.c)
x11_joystick.c x11_keysym2unicode.c x11_monitor.c
x11_opengl.c x11_time.c x11_window.c)
if (GLFW_NATIVE_API)
list(APPEND glfw_SOURCES x11_native.c)

53
src/cocoa_input.m
View File

@ -1,53 +0,0 @@
//========================================================================
// GLFW - An OpenGL library
// Platform: Cocoa
// API Version: 3.0
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2009-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"
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Enable and disable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
{
// This is checked in cocoa_window.m; no action needed here
}
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
{
// This is checked in cocoa_window.m; no action needed here
// Note that it may not be possible to disable things like Exposé
// except in full-screen mode.
}

10
src/cocoa_opengl.m
View File

@ -147,13 +147,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
return symbol;
}
//========================================================================
// Copies the specified OpenGL state categories from src to dst
//========================================================================
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask)
{
[dst->NSGL.context copyAttributesFromContext:src->NSGL.context withMask:mask];
}

26
src/cocoa_window.m
View File

@ -455,8 +455,7 @@ static int convertMacKeyCode(unsigned int macKeyCode)
if ([event modifierFlags] & NSCommandKeyMask)
{
if (window->systemKeys)
[super keyDown:event];
[super keyDown:event];
}
else
{
@ -686,7 +685,7 @@ static GLboolean createWindow(_GLFWwindow* window,
}
window->NS.object = [[NSWindow alloc]
initWithContentRect:NSMakeRect(0, 0, window->width, window->height)
initWithContentRect:NSMakeRect(wndconfig->positionX, wndconfig->positionY, window->width, window->height)
styleMask:styleMask
backing:NSBackingStoreBuffered
defer:NO];
@ -1006,27 +1005,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
}
//========================================================================
// Set the window position
//========================================================================
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
{
NSRect contentRect =
[window->NS.object contentRectForFrameRect:[window->NS.object frame]];
// We assume here that the client code wants to position the window within the
// screen the window currently occupies
NSRect screenRect = [[window->NS.object screen] visibleFrame];
contentRect.origin = NSMakePoint(screenRect.origin.x + x,
screenRect.origin.y + screenRect.size.height -
y - contentRect.size.height);
[window->NS.object setFrame:[window->NS.object frameRectForContentRect:contentRect]
display:YES];
}
//========================================================================
// Iconify the window
//========================================================================

10
src/init.c
View File

@ -221,21 +221,19 @@ GLFWAPI const char* glfwErrorString(int error)
case GLFW_NOT_INITIALIZED:
return "The GLFW library is not initialized";
case GLFW_NO_CURRENT_CONTEXT:
return "There is no current OpenGL context";
return "There is no current context";
case GLFW_INVALID_ENUM:
return "Invalid argument for enum parameter";
case GLFW_INVALID_VALUE:
return "Invalid value for parameter";
case GLFW_OUT_OF_MEMORY:
return "Out of memory";
case GLFW_OPENGL_UNAVAILABLE:
return "OpenGL is not available on this machine";
case GLFW_API_UNAVAILABLE:
return "The requested client API is unavailable";
case GLFW_VERSION_UNAVAILABLE:
return "The requested OpenGL version is unavailable";
return "The requested client API version is unavailable";
case GLFW_PLATFORM_ERROR:
return "A platform-specific error occurred";
case GLFW_WINDOW_NOT_ACTIVE:
return "The specified window is not active";
case GLFW_FORMAT_UNAVAILABLE:
return "The requested format is unavailable";
}

45
src/input.c
View File

@ -115,34 +115,6 @@ static void setStickyMouseButtons(_GLFWwindow* window, int enabled)
}
//========================================================================
// Set system keys for the specified window
//========================================================================
static void setSystemKeys(_GLFWwindow* window, int enabled)
{
if (window->systemKeys == enabled)
return;
if (enabled)
_glfwPlatformEnableSystemKeys(window);
else
_glfwPlatformDisableSystemKeys(window);
window->systemKeys = enabled;
}
//========================================================================
// Set key repeat for the specified window
//========================================================================
static void setKeyRepeat(_GLFWwindow* window, int enabled)
{
window->keyRepeat = enabled;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
@ -172,7 +144,7 @@ void _glfwInputKey(_GLFWwindow* window, int key, int action)
}
// Call user callback function
if (window->keyCallback && (window->keyRepeat || !repeated))
if (window->keyCallback && !repeated)
window->keyCallback(window, key, action);
}
@ -295,10 +267,6 @@ GLFWAPI int glfwGetInputMode(GLFWwindow handle, int mode)
return window->stickyKeys;
case GLFW_STICKY_MOUSE_BUTTONS:
return window->stickyMouseButtons;
case GLFW_SYSTEM_KEYS:
return window->systemKeys;
case GLFW_KEY_REPEAT:
return window->keyRepeat;
default:
_glfwSetError(GLFW_INVALID_ENUM, NULL);
return 0;
@ -331,12 +299,6 @@ GLFWAPI void glfwSetInputMode(GLFWwindow handle, int mode, int value)
case GLFW_STICKY_MOUSE_BUTTONS:
setStickyMouseButtons(window, value ? GL_TRUE : GL_FALSE);
break;
case GLFW_SYSTEM_KEYS:
setSystemKeys(window, value ? GL_TRUE : GL_FALSE);
break;
case GLFW_KEY_REPEAT:
setKeyRepeat(window, value ? GL_TRUE : GL_FALSE);
break;
default:
_glfwSetError(GLFW_INVALID_ENUM, NULL);
break;
@ -445,11 +407,8 @@ GLFWAPI void glfwSetCursorPos(GLFWwindow handle, int xpos, int ypos)
return;
}
if (_glfwLibrary.activeWindow != window)
{
_glfwSetError(GLFW_WINDOW_NOT_ACTIVE, NULL);
if (_glfwLibrary.focusedWindow != window)
return;
}
// Don't do anything if the cursor position did not change
if (xpos == window->cursorPosX && ypos == window->cursorPosY)

12
src/internal.h
View File

@ -108,6 +108,8 @@ struct _GLFWhints
GLboolean glDebug;
int glProfile;
int glRobustness;
int positionX;
int positionY;
};
@ -123,6 +125,8 @@ struct _GLFWwndconfig
int refreshRate;
GLboolean resizable;
GLboolean visible;
int positionX;
int positionY;
int clientAPI;
int glMajor;
int glMinor;
@ -183,8 +187,6 @@ struct _GLFWwindow
// Window input state
GLboolean stickyKeys;
GLboolean stickyMouseButtons;
GLboolean keyRepeat;
GLboolean systemKeys; // system keys enabled flag
int cursorPosX, cursorPosY;
int cursorMode;
double scrollX, scrollY;
@ -249,7 +251,7 @@ struct _GLFWlibrary
_GLFWhints hints;
_GLFWwindow* windowListHead;
_GLFWwindow* activeWindow;
_GLFWwindow* focusedWindow;
_GLFWmonitor** monitors;
int monitorCount;
@ -322,7 +324,6 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window, const _GLFWwndconfig* wndcon
void _glfwPlatformDestroyWindow(_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 _glfwPlatformShowWindow(_GLFWwindow* window);
@ -340,7 +341,6 @@ void _glfwPlatformSwapInterval(int interval);
void _glfwPlatformRefreshWindowParams(_GLFWwindow* window);
int _glfwPlatformExtensionSupported(const char* extension);
GLFWglproc _glfwPlatformGetProcAddress(const char* procname);
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask);
//========================================================================
@ -351,7 +351,7 @@ void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long
//========================================================================
// Window event notification (window.c)
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated);
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused);
void _glfwInputWindowPos(_GLFWwindow* window, int x, int y);
void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
void _glfwInputWindowIconify(_GLFWwindow* window, int iconified);

29
src/opengl.c
View File

@ -682,32 +682,3 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
return _glfwPlatformGetProcAddress(procname);
}
//========================================================================
// Copies the specified OpenGL state categories from src to dst
//========================================================================
GLFWAPI void glfwCopyContext(GLFWwindow hsrc, GLFWwindow hdst, unsigned long mask)
{
_GLFWwindow* src;
_GLFWwindow* dst;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return;
}
src = (_GLFWwindow*) hsrc;
dst = (_GLFWwindow*) hdst;
if (_glfwPlatformGetCurrentContext() == dst)
{
_glfwSetError(GLFW_INVALID_VALUE,
"glfwCopyContext: Cannot copy OpenGL state to a current context");
return;
}
_glfwPlatformCopyContext(src, dst, mask);
}

132
src/win32_input.c
View File

@ -1,132 +0,0 @@
//========================================================================
// GLFW - An OpenGL library
// Platform: Win32
// API version: 3.0
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-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"
//========================================================================
// Low level keyboard hook (system callback) function
// Used to disable system keys under Windows NT
//========================================================================
static LRESULT CALLBACK keyboardHook(int nCode, WPARAM wParam, LPARAM lParam)
{
BOOL syskeys = FALSE;
PKBDLLHOOKSTRUCT p;
// We are only looking for keyboard events - interpret lParam as a
// pointer to a KBDLLHOOKSTRUCT
p = (PKBDLLHOOKSTRUCT) lParam;
if (nCode == HC_ACTION)
{
// We have a keyboard event
switch (wParam)
{
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_SYSKEYUP:
// Detect: ALT+TAB, ALT+ESC, ALT+F4, CTRL+ESC,
// LWIN, RWIN, APPS (mysterious menu key)
syskeys = (p->vkCode == VK_TAB &&
p->flags & LLKHF_ALTDOWN) ||
(p->vkCode == VK_ESCAPE &&
p->flags & LLKHF_ALTDOWN) ||
(p->vkCode == VK_F4 &&
p->flags & LLKHF_ALTDOWN) ||
(p->vkCode == VK_ESCAPE &&
(GetKeyState(VK_CONTROL) & 0x8000)) ||
p->vkCode == VK_LWIN ||
p->vkCode == VK_RWIN ||
p->vkCode == VK_APPS;
break;
default:
break;
}
}
// Was it a system key combination (e.g. ALT+TAB)?
if (syskeys)
{
_GLFWwindow* window = _glfwLibrary.activeWindow;
// Pass the key event to our window message loop
if (window)
PostMessage(window->Win32.handle, (UINT) wParam, p->vkCode, 0);
// We've taken care of it - don't let the system know about this
// key event
return 1;
}
else
{
// It's a harmless key press, let the system deal with it
return CallNextHookEx(_glfwLibrary.Win32.keyboardHook, nCode, wParam, lParam);
}
}
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Enable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
{
UNREFERENCED_PARAMETER(window);
if (_glfwLibrary.Win32.keyboardHook != NULL)
{
UnhookWindowsHookEx(_glfwLibrary.Win32.keyboardHook);
_glfwLibrary.Win32.keyboardHook = NULL;
}
}
//========================================================================
// Disable system keys
//========================================================================
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
{
UNREFERENCED_PARAMETER(window);
_glfwLibrary.Win32.keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL,
keyboardHook,
_glfwLibrary.Win32.instance,
0);
}

16
src/win32_opengl.c
View File

@ -189,7 +189,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
if (!available)
{
_glfwSetError(GLFW_OPENGL_UNAVAILABLE, "WGL: No pixel formats found");
_glfwSetError(GLFW_API_UNAVAILABLE, "WGL: No pixel formats found");
return NULL;
}
@ -637,17 +637,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
return (GLFWglproc) wglGetProcAddress(procname);
}
//========================================================================
// Copies the specified OpenGL state categories from src to dst
//========================================================================
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask)
{
if (!wglCopyContext(src->WGL.context, dst->WGL.context, mask))
{
_glfwSetError(GLFW_PLATFORM_ERROR,
"WGL: Failed to copy OpenGL context attributes");
}
}

1
src/win32_platform.h
View File

@ -180,7 +180,6 @@ typedef struct _GLFWlibraryWin32
{
HINSTANCE instance; // Instance of the application
ATOM classAtom; // Window class atom
HHOOK keyboardHook; // Keyboard hook handle
DWORD foregroundLockTimeout;
char* clipboardString;

57
src/win32_window.c
View File

@ -327,22 +327,22 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
case WM_ACTIVATE:
{
// Window was (de)activated and/or (de)iconified
// Window was (de)focused and/or (de)iconified
BOOL active = LOWORD(wParam) != WA_INACTIVE;
BOOL focused = LOWORD(wParam) != WA_INACTIVE;
BOOL iconified = HIWORD(wParam) ? TRUE : FALSE;
if (active && iconified)
if (focused && iconified)
{
// This is a workaround for window iconification using the
// taskbar leading to windows being told they're active and
// iconified and then never told they're deactivated
active = FALSE;
// taskbar leading to windows being told they're focused and
// iconified and then never told they're defocused
focused = FALSE;
}
if (!active && _glfwLibrary.activeWindow == window)
if (!focused && _glfwLibrary.focusedWindow == window)
{
// The window was deactivated (or iconified, see above)
// The window was defocused (or iconified, see above)
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
showCursor(window);
@ -363,9 +363,9 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
}
}
}
else if (active && _glfwLibrary.activeWindow != window)
else if (focused && _glfwLibrary.focusedWindow != window)
{
// The window was activated
// The window was focused
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
captureCursor(window);
@ -385,7 +385,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
}
}
_glfwInputWindowFocus(window, active);
_glfwInputWindowFocus(window, focused);
_glfwInputWindowIconify(window, iconified);
return 0;
}
@ -543,7 +543,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
{
if (_glfwLibrary.activeWindow != window)
if (_glfwLibrary.focusedWindow != window)
return 0;
x = newCursorX - window->Win32.oldCursorX;
@ -787,8 +787,8 @@ static int createWindow(_GLFWwindow* window,
SystemParametersInfo(SPI_GETWORKAREA, 0, &wa, 0);
// Adjust window position to working area
positionX = wa.left;
positionY = wa.top;
positionX = wndconfig->positionX + wa.left;
positionY = wndconfig->positionY + wa.top;
}
wideTitle = _glfwCreateWideStringFromUTF8(wndconfig->title);
@ -842,8 +842,8 @@ static void destroyWindow(_GLFWwindow* window)
// This is duplicated from glfwDestroyWindow
// TODO: Stop duplicating code
if (window == _glfwLibrary.activeWindow)
_glfwLibrary.activeWindow = NULL;
if (window == _glfwLibrary.focusedWindow)
_glfwLibrary.focusedWindow = NULL;
if (window->Win32.handle)
{
@ -1071,23 +1071,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
}
//========================================================================
// Set the window position
//========================================================================
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
{
RECT rect;
GetClientRect(window->Win32.handle, &rect);
AdjustWindowRectEx(&rect, window->Win32.dwStyle, FALSE, window->Win32.dwExStyle);
SetWindowPos(window->Win32.handle, HWND_TOP,
x + rect.left, y + rect.top, 0, 0,
SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
}
//========================================================================
// Window iconification
//========================================================================
@ -1162,7 +1145,7 @@ void _glfwPlatformPollEvents(void)
MSG msg;
_GLFWwindow* window;
window = _glfwLibrary.activeWindow;
window = _glfwLibrary.focusedWindow;
if (window)
{
window->Win32.cursorCentered = GL_FALSE;
@ -1198,7 +1181,7 @@ void _glfwPlatformPollEvents(void)
// LSHIFT/RSHIFT fixup (keys tend to "stick" without this fix)
// This is the only async event handling in GLFW, but it solves some
// nasty problems.
window = _glfwLibrary.activeWindow;
window = _glfwLibrary.focusedWindow;
if (window)
{
int lshift_down, rshift_down;
@ -1216,8 +1199,8 @@ void _glfwPlatformPollEvents(void)
_glfwInputKey(window, GLFW_KEY_RIGHT_SHIFT, GLFW_RELEASE);
}
// Did the cursor move in an active window that has captured the cursor
window = _glfwLibrary.activeWindow;
// Did the cursor move in an focused window that has captured the cursor
window = _glfwLibrary.focusedWindow;
if (window)
{
if (window->cursorMode == GLFW_CURSOR_CAPTURED &&

150
src/window.c
View File

@ -72,43 +72,43 @@ static void clearScrollOffsets(void)
// Register window focus events
//========================================================================
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
{
if (activated)
if (focused)
{
if (_glfwLibrary.activeWindow == window)
return;
if (_glfwLibrary.focusedWindow != window)
{
_glfwLibrary.focusedWindow = window;
_glfwLibrary.activeWindow = window;
if (window->windowFocusCallback)
window->windowFocusCallback(window, activated);
if (window->windowFocusCallback)
window->windowFocusCallback(window, focused);
}
}
else
{
int i;
if (_glfwLibrary.activeWindow != window)
return;
// Release all pressed keyboard keys
for (i = 0; i <= GLFW_KEY_LAST; i++)
if (_glfwLibrary.focusedWindow == window)
{
if (window->key[i] == GLFW_PRESS)
_glfwInputKey(window, i, GLFW_RELEASE);
int i;
// Release all pressed keyboard keys
for (i = 0; i <= GLFW_KEY_LAST; i++)
{
if (window->key[i] == GLFW_PRESS)
_glfwInputKey(window, i, GLFW_RELEASE);
}
// Release all pressed mouse buttons
for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
{
if (window->mouseButton[i] == GLFW_PRESS)
_glfwInputMouseClick(window, i, GLFW_RELEASE);
}
_glfwLibrary.focusedWindow = NULL;
if (window->windowFocusCallback)
window->windowFocusCallback(window, focused);
}
// Release all pressed mouse buttons
for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
{
if (window->mouseButton[i] == GLFW_PRESS)
_glfwInputMouseClick(window, i, GLFW_RELEASE);
}
_glfwLibrary.activeWindow = NULL;
if (window->windowFocusCallback)
window->windowFocusCallback(window, activated);
}
}
@ -238,6 +238,8 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
wndconfig.refreshRate = Max(_glfwLibrary.hints.refreshRate, 0);
wndconfig.resizable = _glfwLibrary.hints.resizable ? GL_TRUE : GL_FALSE;
wndconfig.visible = _glfwLibrary.hints.visible ? GL_TRUE : GL_FALSE;
wndconfig.positionX = _glfwLibrary.hints.positionX;
wndconfig.positionY = _glfwLibrary.hints.positionY;
wndconfig.clientAPI = _glfwLibrary.hints.clientAPI;
wndconfig.glMajor = _glfwLibrary.hints.glMajor;
wndconfig.glMinor = _glfwLibrary.hints.glMinor;
@ -255,22 +257,11 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
// Save the currently current context so it can be restored later
previous = glfwGetCurrentContext();
// Check width & height
if (width > 0 && height <= 0)
if (width <= 0 || height <= 0)
{
// Set the window aspect ratio to 4:3
height = (width * 3) / 4;
}
else if (width <= 0 && height > 0)
{
// Set the window aspect ratio to 4:3
width = (height * 4) / 3;
}
else if (width <= 0 && height <= 0)
{
// Default window size
width = 640;
height = 480;
_glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid window size");
return GL_FALSE;
}
window = (_GLFWwindow*) calloc(1, sizeof(_GLFWwindow));
@ -288,7 +279,6 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
window->height = height;
window->resizable = wndconfig.resizable;
window->cursorMode = GLFW_CURSOR_NORMAL;
window->systemKeys = GL_TRUE;
window->monitor = (_GLFWmonitor*) monitor;
// Open the actual window and create its context
@ -363,6 +353,10 @@ void glfwDefaultWindowHints(void)
_glfwLibrary.hints.resizable = GL_TRUE;
_glfwLibrary.hints.visible = GL_TRUE;
// The default window position is the upper left corner of the screen
_glfwLibrary.hints.positionX = 0;
_glfwLibrary.hints.positionY = 0;
// The default is 24 bits of color, 24 bits of depth and 8 bits of stencil
_glfwLibrary.hints.redBits = 8;
_glfwLibrary.hints.greenBits = 8;
@ -431,6 +425,12 @@ GLFWAPI void glfwWindowHint(int target, int hint)
case GLFW_VISIBLE:
_glfwLibrary.hints.visible = hint;
break;
case GLFW_POSITION_X:
_glfwLibrary.hints.positionX = hint;
break;
case GLFW_POSITION_Y:
_glfwLibrary.hints.positionY = hint;
break;
case GLFW_FSAA_SAMPLES:
_glfwLibrary.hints.samples = hint;
break;
@ -485,9 +485,9 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow handle)
if (window == _glfwPlatformGetCurrentContext())
_glfwPlatformMakeContextCurrent(NULL);
// Clear the active window pointer if this is the active window
if (window == _glfwLibrary.activeWindow)
_glfwLibrary.activeWindow = NULL;
// Clear the focused window pointer if this is the focused window
if (window == _glfwLibrary.focusedWindow)
_glfwLibrary.focusedWindow = NULL;
_glfwPlatformDestroyWindow(window);
@ -580,52 +580,6 @@ GLFWAPI void glfwSetWindowSize(GLFWwindow handle, int width, int height)
}
//========================================================================
// Get the window position
//========================================================================
GLFWAPI void glfwGetWindowPos(GLFWwindow handle, int* xpos, int* ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return;
}
if (xpos != NULL)
*xpos = window->positionX;
if (ypos != NULL)
*ypos = window->positionY;
}
//========================================================================
// Set the window position
//========================================================================
GLFWAPI void glfwSetWindowPos(GLFWwindow handle, int xpos, int ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return;
}
if (window->monitor || window->iconified)
{
// TODO: Figure out if this is an error
return;
}
_glfwPlatformSetWindowPos(window, xpos, ypos);
}
//========================================================================
// Window iconification
//========================================================================
@ -729,8 +683,8 @@ GLFWAPI int glfwGetWindowParam(GLFWwindow handle, int param)
switch (param)
{
case GLFW_ACTIVE:
return window == _glfwLibrary.activeWindow;
case GLFW_FOCUSED:
return window == _glfwLibrary.focusedWindow;
case GLFW_ICONIFIED:
return window->iconified;
case GLFW_CLOSE_REQUESTED:
@ -741,6 +695,10 @@ GLFWAPI int glfwGetWindowParam(GLFWwindow handle, int param)
return window->resizable;
case GLFW_VISIBLE:
return window->visible;
case GLFW_POSITION_X:
return window->positionX;
case GLFW_POSITION_Y:
return window->positionY;
case GLFW_CLIENT_API:
return window->clientAPI;
case GLFW_OPENGL_VERSION_MAJOR:

2
src/x11_init.c
View File

@ -491,7 +491,7 @@ static GLboolean initDisplay(void)
_glfwLibrary.X11.display = XOpenDisplay(NULL);
if (!_glfwLibrary.X11.display)
{
_glfwSetError(GLFW_OPENGL_UNAVAILABLE, "X11: Failed to open X display");
_glfwSetError(GLFW_API_UNAVAILABLE, "X11: Failed to open X display");
return GL_FALSE;
}

65
src/x11_input.c
View File

@ -1,65 +0,0 @@
//========================================================================
// GLFW - An OpenGL library
// Platform: X11
// API version: 3.0
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-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"
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Enable system keys
//========================================================================
void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
{
if (window->X11.keyboardGrabbed)
{
XUngrabKeyboard(_glfwLibrary.X11.display, CurrentTime);
window->X11.keyboardGrabbed = GL_FALSE;
}
}
//========================================================================
// Disable system keys
//========================================================================
void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
{
if (XGrabKeyboard(_glfwLibrary.X11.display, window->X11.handle,
True, GrabModeAsync, GrabModeAsync, CurrentTime)
== GrabSuccess)
{
window->X11.keyboardGrabbed = GL_TRUE;
}
}

28
src/x11_opengl.c
View File

@ -93,7 +93,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
{
if (!_glfwLibrary.GLX.SGIX_fbconfig)
{
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
_glfwSetError(GLFW_API_UNAVAILABLE,
"GLX: GLXFBConfig support not found");
return NULL;
}
@ -103,8 +103,8 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
if (strcmp(vendor, "Chromium") == 0)
{
// This is a (hopefully temporary) workaround for Chromium (VirtualBox
// GL) not setting the window bit on any GLXFBConfigs
// HACK: This is a (hopefully temporary) workaround for Chromium
// (VirtualBox GL) not setting the window bit on any GLXFBConfigs
trustWindowBit = GL_FALSE;
}
@ -116,7 +116,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
&count);
if (!count)
{
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
_glfwSetError(GLFW_API_UNAVAILABLE,
"GLX: No GLXFBConfigs returned");
return NULL;
}
@ -128,7 +128,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
&count);
if (!count)
{
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
_glfwSetError(GLFW_API_UNAVAILABLE,
"GLX: No GLXFBConfigs returned");
return NULL;
}
@ -465,7 +465,7 @@ int _glfwInitOpenGL(void)
// Check if GLX is supported on this display
if (!glXQueryExtension(_glfwLibrary.X11.display, NULL, NULL))
{
_glfwSetError(GLFW_OPENGL_UNAVAILABLE, "GLX: GLX support not found");
_glfwSetError(GLFW_API_UNAVAILABLE, "GLX: GLX support not found");
return GL_FALSE;
}
@ -473,8 +473,7 @@ int _glfwInitOpenGL(void)
&_glfwLibrary.GLX.majorVersion,
&_glfwLibrary.GLX.minorVersion))
{
_glfwSetError(GLFW_OPENGL_UNAVAILABLE,
"GLX: Failed to query GLX version");
_glfwSetError(GLFW_API_UNAVAILABLE, "GLX: Failed to query GLX version");
return GL_FALSE;
}
@ -732,16 +731,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
return _glfw_glXGetProcAddress((const GLubyte*) procname);
}
//========================================================================
// Copies the specified OpenGL state categories from src to dst
//========================================================================
void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask)
{
glXCopyContext(_glfwLibrary.X11.display,
src->GLX.context,
dst->GLX.context,
mask);
}

7
src/x11_platform.h
View File

@ -138,12 +138,17 @@ typedef struct _GLFWwindowX11
// Various platform specific internal variables
GLboolean overrideRedirect; // True if window is OverrideRedirect
GLboolean keyboardGrabbed; // True if keyboard is currently grabbed
GLboolean cursorGrabbed; // True if cursor is currently grabbed
GLboolean cursorHidden; // True if cursor is currently hidden
GLboolean cursorCentered; // True if cursor was moved since last poll
int cursorPosX, cursorPosY;
// Window position hint (commited the first time the window is shown)
GLboolean windowPosSet; // False until the window position has
// been set
int positionX; // The window position to be set the
int positionY; // first time the window is shown
} _GLFWwindowX11;

33
src/x11_window.c
View File

@ -119,7 +119,7 @@ static GLboolean createWindow(_GLFWwindow* window,
window->X11.handle = XCreateWindow(_glfwLibrary.X11.display,
_glfwLibrary.X11.root,
0, 0,
wndconfig->positionX, wndconfig->positionY,
window->width, window->height,
0, // Border width
visual->depth, // Color depth
@ -136,6 +136,12 @@ static GLboolean createWindow(_GLFWwindow* window,
_glfwSetError(GLFW_PLATFORM_ERROR, "X11: Failed to create window");
return GL_FALSE;
}
// Request a window position to be set once the window is shown
// (see _glfwPlatformShowWindow)
window->X11.windowPosSet = GL_FALSE;
window->X11.positionX = wndconfig->positionX;
window->X11.positionY = wndconfig->positionY;
}
if (window->monitor && !_glfwLibrary.X11.hasEWMH)
@ -633,7 +639,7 @@ static void processEvent(XEvent *event)
if (window->cursorMode == GLFW_CURSOR_CAPTURED)
{
if (_glfwLibrary.activeWindow != window)
if (_glfwLibrary.focusedWindow != window)
break;
x = event->xmotion.x - window->X11.cursorPosX;
@ -1016,16 +1022,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
}
//========================================================================
// Set the window position.
//========================================================================
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
{
XMoveWindow(_glfwLibrary.X11.display, window->X11.handle, x, y);
}
//========================================================================
// Window iconification
//========================================================================
@ -1070,6 +1066,15 @@ void _glfwPlatformShowWindow(_GLFWwindow* window)
{
XMapRaised(_glfwLibrary.X11.display, window->X11.handle);
XFlush(_glfwLibrary.X11.display);
// Set the window position the first time the window is shown
// Note: XMoveWindow has no effect before the window has been mapped.
if (!window->X11.windowPosSet)
{
XMoveWindow(_glfwLibrary.X11.display, window->X11.handle,
window->X11.positionX, window->X11.positionY);
window->X11.windowPosSet = GL_TRUE;
}
}
@ -1123,11 +1128,11 @@ void _glfwPlatformPollEvents(void)
processEvent(&event);
}
// Check whether the cursor has moved inside an active window that has
// Check whether the cursor has moved inside an focused window that has
// captured the cursor (because then it needs to be re-centered)
_GLFWwindow* window;
window = _glfwLibrary.activeWindow;
window = _glfwLibrary.focusedWindow;
if (window)
{
if (window->cursorMode == GLFW_CURSOR_CAPTURED &&

2
tests/clipboard.c
View File

@ -125,7 +125,7 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
window = glfwCreateWindow(0, 0, "Clipboard Test", NULL, NULL);
window = glfwCreateWindow(200, 200, "Clipboard Test", NULL, NULL);
if (!window)
{
glfwTerminate();

2
tests/defaults.c
View File

@ -85,7 +85,7 @@ int main(void)
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
window = glfwCreateWindow(0, 0, "Defaults", NULL, NULL);
window = glfwCreateWindow(640, 480, "Defaults", NULL, NULL);
if (!window)
{
glfwTerminate();

29
tests/events.c
View File

@ -41,8 +41,6 @@
#include <locale.h>
// These must match the input mode defaults
static GLboolean keyrepeat = GL_FALSE;
static GLboolean systemkeys = GL_TRUE;
static GLboolean closeable = GL_TRUE;
// Event index
@ -249,12 +247,12 @@ static void window_refresh_callback(GLFWwindow window)
}
}
static void window_focus_callback(GLFWwindow window, int activated)
static void window_focus_callback(GLFWwindow window, int focused)
{
printf("%08x at %0.3f: Window %s\n",
counter++,
glfwGetTime(),
activated ? "activated" : "deactivated");
focused ? "focused" : "defocused");
}
static void window_iconify_callback(GLFWwindow window, int iconified)
@ -311,24 +309,6 @@ static void key_callback(GLFWwindow window, int key, int action)
switch (key)
{
case GLFW_KEY_R:
{
keyrepeat = !keyrepeat;
glfwSetInputMode(window, GLFW_KEY_REPEAT, keyrepeat);
printf("(( key repeat %s ))\n", keyrepeat ? "enabled" : "disabled");
break;
}
case GLFW_KEY_S:
{
systemkeys = !systemkeys;
glfwSetInputMode(window, GLFW_SYSTEM_KEYS, systemkeys);
printf("(( system keys %s ))\n", systemkeys ? "enabled" : "disabled");
break;
}
case GLFW_KEY_C:
{
closeable = !closeable;
@ -389,7 +369,7 @@ int main(void)
printf("Library initialized\n");
window = glfwCreateWindow(0, 0, "Event Linter", NULL, NULL);
window = glfwCreateWindow(640, 480, "Event Linter", NULL, NULL);
if (!window)
{
glfwTerminate();
@ -420,9 +400,6 @@ int main(void)
glfwGetWindowSize(window, &width, &height);
printf("Window size should be %ix%i\n", width, height);
printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled");
printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled");
printf("Main loop starting\n");
while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))

8
tests/fsfocus.c
View File

@ -23,8 +23,8 @@
//
//========================================================================
//
// This test is used to test window activation and iconfication for
// fullscreen windows with a video mode differing from the current mode
// This test is used to test window focusing and iconfication for
// fullscreen windows with a video mode differing from the desktop mode
//
//========================================================================
@ -35,11 +35,11 @@
static GLboolean running = GL_TRUE;
static void window_focus_callback(GLFWwindow window, int activated)
static void window_focus_callback(GLFWwindow window, int focused)
{
printf("%0.3f: Window %s\n",
glfwGetTime(),
activated ? "activated" : "deactivated");
focused ? "focused" : "defocused");
}
static void window_key_callback(GLFWwindow window, int key, int action)

4
tests/gamma.c
View File

@ -133,8 +133,8 @@ int main(int argc, char** argv)
}
else
{
width = 0;
height = 0;
width = 200;
height = 200;
}
window = glfwCreateWindow(width, height, "Gamma Test", monitor, NULL);

2
tests/glfwinfo.c
View File

@ -268,7 +268,7 @@ int main(int argc, char** argv)
// We assume here that we stand a better chance of success by leaving all
// possible details of pixel format selection to GLFW
window = glfwCreateWindow(0, 0, "Version", NULL, NULL);
window = glfwCreateWindow(200, 200, "Version", NULL, NULL);
if (!window)
{
glfwTerminate();

10
tests/iconify.c
View File

@ -75,11 +75,11 @@ static void window_size_callback(GLFWwindow window, int width, int height)
glViewport(0, 0, width, height);
}
static void window_focus_callback(GLFWwindow window, int activated)
static void window_focus_callback(GLFWwindow window, int focused)
{
printf("%0.2f Window %s\n",
glfwGetTime(),
activated ? "activated" : "deactivated");
focused ? "focused" : "defocused");
}
static void window_iconify_callback(GLFWwindow window, int iconified)
@ -128,8 +128,8 @@ int main(int argc, char** argv)
}
else
{
width = 0;
height = 0;
width = 640;
height = 480;
}
window = glfwCreateWindow(width, height, "Iconify", monitor, NULL);
@ -152,7 +152,7 @@ int main(int argc, char** argv)
printf("Window is %s and %s\n",
glfwGetWindowParam(window, GLFW_ICONIFIED) ? "iconified" : "restored",
glfwGetWindowParam(window, GLFW_ACTIVE) ? "active" : "inactive");
glfwGetWindowParam(window, GLFW_FOCUSED) ? "focused" : "defocused");
glEnable(GL_SCISSOR_TEST);

2
tests/joysticks.c
View File

@ -186,7 +186,7 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwCreateWindow(0, 0, "Joystick Test", NULL, NULL);
window = glfwCreateWindow(640, 480, "Joystick Test", NULL, NULL);
if (!window)
{
glfwTerminate();

2
tests/peter.c
View File

@ -92,7 +92,7 @@ static void window_size_callback(GLFWwindow window, int width, int height)
static GLboolean open_window(void)
{
window_handle = glfwCreateWindow(0, 0, "Peter Detector", NULL, NULL);
window_handle = glfwCreateWindow(640, 480, "Peter Detector", NULL, NULL);
if (!window_handle)
return GL_FALSE;

19
tests/sharing.c
View File

@ -51,10 +51,12 @@ static int window_close_callback(GLFWwindow window)
return GL_FALSE;
}
static GLFWwindow open_window(const char* title, GLFWwindow share)
static GLFWwindow open_window(const char* title, GLFWwindow share, int posX, int posY)
{
GLFWwindow window;
glfwWindowHint(GLFW_POSITION_X, posX);
glfwWindowHint(GLFW_POSITION_Y, posY);
window = glfwCreateWindow(WIDTH, HEIGHT, title, NULL, share);
if (!window)
return NULL;
@ -125,7 +127,6 @@ static void draw_quad(GLuint texture)
int main(int argc, char** argv)
{
GLuint texture;
int x, y;
if (!glfwInit())
{
@ -133,7 +134,7 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
windows[0] = open_window("First", NULL);
windows[0] = open_window("First", NULL, 0, 0);
if (!windows[0])
{
fprintf(stderr, "Failed to open first GLFW window: %s\n", glfwErrorString(glfwGetError()));
@ -147,7 +148,8 @@ int main(int argc, char** argv)
// It will then be shared with the second context, created below
texture = create_texture();
windows[1] = open_window("Second", windows[0]);
// Put the second window to the right of the first one
windows[1] = open_window("Second", windows[0], WIDTH + 50, 0);
if (!windows[1])
{
fprintf(stderr, "Failed to open second GLFW window: %s\n", glfwErrorString(glfwGetError()));
@ -156,14 +158,13 @@ int main(int argc, char** argv)
exit(EXIT_FAILURE);
}
// Set drawing color for the first context and copy it to the second
// Set drawing color for both contexts
glfwMakeContextCurrent(windows[0]);
glColor3f(0.6f, 0.f, 0.6f);
glfwCopyContext(windows[0], windows[1], GL_CURRENT_BIT);
glfwMakeContextCurrent(windows[1]);
glColor3f(0.6f, 0.6f, 0.f);
// Put the second window to the right of the first one
glfwGetWindowPos(windows[0], &x, &y);
glfwSetWindowPos(windows[1], x + WIDTH + 50, y);
glfwMakeContextCurrent(windows[0]);
while (!closed)
{

2
tests/tearing.c
View File

@ -70,7 +70,7 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwCreateWindow(0, 0, "", NULL, NULL);
window = glfwCreateWindow(640, 480, "", NULL, NULL);
if (!window)
{
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));

4
tests/threads.c
View File

@ -89,6 +89,8 @@ int main(void)
for (i = 0; i < count; i++)
{
glfwWindowHint(GLFW_POSITION_X, 200 + 250 * i);
glfwWindowHint(GLFW_POSITION_Y, 200);
threads[i].window = glfwCreateWindow(200, 200,
threads[i].title,
NULL, NULL);
@ -99,8 +101,6 @@ int main(void)
exit(EXIT_FAILURE);
}
glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200);
if (thrd_create(&threads[i].id, thread_main, threads + i) !=
thrd_success)
{

2
tests/title.c
View File

@ -47,7 +47,7 @@ int main(void)
exit(EXIT_FAILURE);
}
window = glfwCreateWindow(0, 0, "English 日本語 русский язык 官話", NULL, NULL);
window = glfwCreateWindow(400, 400, "English 日本語 русский язык 官話", NULL, NULL);
if (!window)
{
fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));

4
tests/windows.c
View File

@ -55,6 +55,8 @@ int main(void)
for (i = 0; i < 4; i++)
{
glfwWindowHint(GLFW_POSITION_X, 100 + (i & 1) * 300);
glfwWindowHint(GLFW_POSITION_Y, 100 + (i >> 1) * 300);
windows[i] = glfwCreateWindow(200, 200, titles[i], NULL, NULL);
if (!windows[i])
{
@ -70,8 +72,6 @@ int main(void)
(GLclampf) (i >> 1),
i ? 0.f : 1.f,
0.f);
glfwSetWindowPos(windows[i], 100 + (i & 1) * 300, 100 + (i >> 1) * 300);
}
while (running)