Window guide

This guide introduces the window related functions of GLFW. For details on a specific function in this category, see the Window reference. There are also guides for the other areas of GLFW.

- Introduction to the API
- Context guide
- Vulkan guide
- Monitor guide
- Input guide

# Window objects

The GLFWwindow object encapsulates both a window and a context. They are created with glfwCreateWindow and destroyed with glfwDestroyWindow, or glfwTerminate, if any remain. As the window and context are inseparably linked, the object pointer is used as both a context and window handle.

To see the event stream provided to the various window related callbacks, run the `events` test program.

## Window creation

A window and its OpenGL or OpenGL ES context are created with glfwCreateWindow, which returns a handle to the created window object. For example, this creates a 640 by 480 windowed mode window:

GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", NULL, NULL);

If window creation fails, `NULL` will be returned, so it is necessary to check the return value.

The window handle is passed to all window related functions and is provided to along with all input events, so event handlers can tell which window received the event.

### Full screen windows

To create a full screen window, you need to specify which monitor the window should use. In most cases, the user's primary monitor is a good choice. For more information about retrieving monitors, see Retrieving monitors.

GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", glfwGetPrimaryMonitor(), NULL);

Full screen windows cover the entire display area of a monitor, have no border or decorations.

Windowed mode windows can be made full screen by setting a monitor with glfwSetWindowMonitor, and full screen ones can be made windowed by unsetting it with the same function.

Each field of the GLFWvidmode structure corresponds to a function parameter or window hint and combine to form the desired video mode for that window. The supported video mode most closely matching the desired video mode will be set for the chosen monitor as long as the window has input focus. For more information about retrieving video modes, see Video modes.

Video mode field | Corresponds to
--- | ---
GLFWvidmode.width | `width` parameter of glfwCreateWindow
GLFWvidmode.height | `height` parameter of glfwCreateWindow
GLFWvidmode.redBits | GLFW_RED_BITS hint
GLFWvidmode.greenBits | GLFW_GREEN_BITS hint
GLFWvidmode.blueBits | GLFW_BLUE_BITS hint
GLFWvidmode.refreshRate | GLFW_REFRESH_RATE hint

Once you have a full screen window, you can change its resolution, refresh rate and monitor with glfwSetWindowMonitor. If you only need change its resolution you can also call glfwSetWindowSize. In all cases, the new video mode will be selected the same way as the video mode chosen by glfwCreateWindow. If the window has an OpenGL or OpenGL ES context, it will be unaffected.

By default, the original video mode of the monitor will be restored and the window iconified if it loses input focus, to allow the user to switch back to the desktop. This behavior can be disabled with the GLFW_AUTO_ICONIFY window hint, for example if you wish to simultaneously cover multiple monitors with full screen windows.

If a monitor is disconnected, all windows that are full screen on that monitor will be switched to windowed mode. See Monitor configuration changes for more information.

### "Windowed full screen" windows

If the closest match for the desired video mode is the current one, the video mode will not be changed, making window creation faster and application switching much smoother. This is sometimes called windowed full screen or borderless full screen window and counts as a full screen window. To create such a window, request the current video mode.

const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwWindowHint(GLFW_RED_BITS, mode->redBits);
glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);
GLFWwindow* window = glfwCreateWindow(mode->width, mode->height, "My Title", monitor, NULL);

This also works for windowed mode windows that are made full screen.

const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);

Note that glfwGetVideoMode returns the current video mode of a monitor, so if you already have a full screen window on that monitor that you want to make windowed full screen, you need to have saved the desktop resolution before.

## Window destruction

When a window is no longer needed, destroy it with glfwDestroyWindow.

glfwDestroyWindow(window);

Window destruction always succeeds. Before the actual destruction, all callbacks are removed so no further events will be delivered for the window. All windows remaining when glfwTerminate is called are destroyed as well.

When a full screen window is destroyed, the original video mode of its monitor is restored, but the gamma ramp is left untouched.

## Window creation hints

There are a number of hints that can be set before the creation of a window and context. Some affect the window itself, others affect the framebuffer or context. These hints are set to their default values each time the library is initialized with glfwInit. Integer value hints can be set individually with glfwWindowHint and string value hints with glfwWindowHintString. You can reset all at once to their defaults with glfwDefaultWindowHints.

Some hints are platform specific. These are always valid to set on any platform but they will only affect their specific platform. Other platforms will ignore them. Setting these hints requires no platform specific headers or calls.

Note
  Window hints need to be set before the creation of the window and context you wish to have the specified attributes. They function as additional arguments to glfwCreateWindow.

### Hard and soft constraints

Some window hints are hard constraints. These must match the available capabilities exactly for window and context creation to succeed. Hints that are not hard constraints are matched as closely as possible, but the resulting context and framebuffer may differ from what these hints requested.

The following hints are always hard constraints:

- GLFW_STEREO
- GLFW_DOUBLEBUFFER
- GLFW_CLIENT_API
- GLFW_CONTEXT_CREATION_API

The following additional hints are hard constraints when requesting an OpenGL context, but are ignored when requesting an OpenGL ES context:

- GLFW_OPENGL_FORWARD_COMPAT
- GLFW_OPENGL_PROFILE

### Window related hints

GLFW_RESIZABLE specifies whether the windowed mode window will be resizable by the user. The window will still be resizable using the glfwSetWindowSize function. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for full screen and undecorated windows.

GLFW_VISIBLE specifies whether the windowed mode window will be initially visible. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for full screen windows.

GLFW_DECORATED specifies whether the windowed mode window will have window decorations such as a border, a close widget, etc. An undecorated window will not be resizable by the user but will still allow the user to generate close events on some platforms. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for full screen windows.

GLFW_FOCUSED specifies whether the windowed mode window will be given input focus when created. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for full screen and initially hidden windows.

GLFW_AUTO_ICONIFY specifies whether the full screen window will automatically iconify and restore the previous video mode on input focus loss. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for windowed mode windows.

GLFW_FLOATING specifies whether the windowed mode window will be floating above other regular windows, also called topmost or always-on-top. This is intended primarily for debugging purposes and cannot be used to implement proper full screen windows. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for full screen windows.

GLFW_MAXIMIZED specifies whether the windowed mode window will be maximized when created. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for full screen windows.

GLFW_CENTER_CURSOR specifies whether the cursor should be centered over newly created full screen windows. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This hint is ignored for windowed mode windows.

GLFW_TRANSPARENT_FRAMEBUFFER specifies whether the window framebuffer will be transparent. If enabled and supported by the system, the window framebuffer alpha channel will be used to combine the framebuffer with the background. This does not affect window decorations. Possible values are `GLFW_TRUE` and `GLFW_FALSE`.

  Windows: GLFW sets a color key for the window to work around repainting issues with a transparent framebuffer. The chosen color value is RGB 255,0,255 (magenta). This will make pixels with that exact color fully transparent regardless of their alpha values. If this is a problem, make these pixels any other color before buffer swap.

GLFW_FOCUS_ON_SHOW specifies whether the window will be given input focus when glfwShowWindow is called. Possible values are `GLFW_TRUE` and `GLFW_FALSE`.

GLFW_SCALE_TO_MONITOR specified whether the window content area should be resized based on the monitor content scale of any monitor it is placed on. This includes the initial placement when the window is created. Possible values are `GLFW_TRUE` and `GLFW_FALSE`.

This hint only has an effect on platforms where screen coordinates and pixels always map 1:1 such as Windows and X11. On platforms like macOS the resolution of the framebuffer is changed independently of the window size.

### Framebuffer related hints

GLFW_RED_BITS, GLFW_GREEN_BITS, GLFW_BLUE_BITS, GLFW_ALPHA_BITS, GLFW_DEPTH_BITS and GLFW_STENCIL_BITS specify the desired bit depths of the various components of the default framebuffer. A value of `GLFW_DONT_CARE` means the application has no preference.

GLFW_ACCUM_RED_BITS, GLFW_ACCUM_GREEN_BITS, GLFW_ACCUM_BLUE_BITS and GLFW_ACCUM_ALPHA_BITS specify the desired bit depths of the various components of the accumulation buffer. A value of `GLFW_DONT_CARE` means the application has no preference.

  Accumulation buffers are a legacy OpenGL feature and should not be used in new code.

GLFW_AUX_BUFFERS specifies the desired number of auxiliary buffers. A value of `GLFW_DONT_CARE` means the application has no preference.

  Auxiliary buffers are a legacy OpenGL feature and should not be used in new code.

GLFW_STEREO specifies whether to use OpenGL stereoscopic rendering. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This is a hard constraint.

GLFW_SAMPLES specifies the desired number of samples to use for multisampling. Zero disables multisampling. A value of `GLFW_DONT_CARE` means the application has no preference.

GLFW_SRGB_CAPABLE specifies whether the framebuffer should be sRGB capable. Possible values are `GLFW_TRUE` and `GLFW_FALSE`.

  OpenGL: If enabled and supported by the system, the `GL_FRAMEBUFFER_SRGB` enable will control sRGB rendering. By default, sRGB rendering will be disabled.

  OpenGL ES: If enabled and supported by the system, the context will always have sRGB rendering enabled.

GLFW_DOUBLEBUFFER specifies whether the framebuffer should be double buffered. You nearly always want to use double buffering. This is a hard constraint. Possible values are `GLFW_TRUE` and `GLFW_FALSE`.

### Monitor related hints

GLFW_REFRESH_RATE specifies the desired refresh rate for full screen windows. A value of `GLFW_DONT_CARE` means the highest available refresh rate will be used. This hint is ignored for windowed mode windows.

### Context related hints

GLFW_CLIENT_API specifies which client API to create the context for. Possible values are `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` and `GLFW_NO_API`. This is a hard constraint.

GLFW_CONTEXT_CREATION_API specifies which context creation API to use to create the context. Possible values are `GLFW_NATIVE_CONTEXT_API`, `GLFW_EGL_CONTEXT_API` and `GLFW_OSMESA_CONTEXT_API`. This is a hard constraint. If no client API is requested, this hint is ignored.

  macOS: The EGL API is not available on this platform and requests to use it will fail.

  Wayland: The EGL API is the native context creation API, so this hint will have no effect.

  OSMesa: As its name implies, an OpenGL context created with OSMesa does not update the window contents when its buffers are swapped. Use OpenGL functions or the OSMesa native access functions glfwGetOSMesaColorBuffer and glfwGetOSMesaDepthBuffer to retrieve the framebuffer contents.

Note
  An OpenGL extension loader library that assumes it knows which context creation API is used on a given platform may fail if you change this hint. This can be resolved by having it load via glfwGetProcAddress, which always uses the selected API.

Bug:
  On some Linux systems, creating contexts via both the native and EGL APIs in a single process will cause the application to segfault. Stick to one API or the other on Linux for now.

GLFW_CONTEXT_VERSION_MAJOR and GLFW_CONTEXT_VERSION_MINOR specify the client API version that the created context must be compatible with. The exact behavior of these hints depend on the requested client API.

Note
  Do not confuse these hints with `GLFW_VERSION_MAJOR` and `GLFW_VERSION_MINOR`, which provide the API version of the GLFW header.

  OpenGL: These hints are not hard constraints, but creation will fail if the OpenGL version of the created context is less than the one requested. It is therefore perfectly safe to use the default of version 1.0 for legacy code and you will still get backwards-compatible contexts of version 3.0 and above when available.

  While there is no way to ask the driver for a context of the highest supported version, GLFW will attempt to provide this when you ask for a version 1.0 context, which is the default for these hints.

  OpenGL ES: These hints are not hard constraints, but creation will fail if the OpenGL ES version of the created context is less than the one requested. Additionally, OpenGL ES 1.x cannot be returned if 2.0 or later was requested, and vice versa. This is because OpenGL ES 3.x is backward compatible with 2.0, but OpenGL ES 2.0 is not backward compatible with 1.x.

Note
  macOS: The OS only supports forward-compatible core profile contexts for OpenGL versions 3.2 and later. Before creating an OpenGL context of version 3.2 or later you must set the GLFW_OPENGL_FORWARD_COMPAT and GLFW_OPENGL_PROFILE hints accordingly. OpenGL 3.0 and 3.1 contexts are not supported at all on macOS.

GLFW_OPENGL_FORWARD_COMPAT specifies whether the OpenGL context should be forward-compatible, i.e. one where all functionality deprecated in the requested version of OpenGL is removed. This must only be used if the requested OpenGL version is 3.0 or above. If OpenGL ES is requested, this hint is ignored.

  Forward-compatibility is described in detail in the OpenGL Reference Manual.

GLFW_OPENGL_DEBUG_CONTEXT specifies whether to create a debug OpenGL context, which may have additional error and performance issue reporting functionality. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. If OpenGL ES is requested, this hint is ignored.

GLFW_OPENGL_PROFILE specifies which OpenGL profile to create the context for. Possible values are one of `GLFW_OPENGL_CORE_PROFILE` or `GLFW_OPENGL_COMPAT_PROFILE`, or `GLFW_OPENGL_ANY_PROFILE` to not request a specific profile. If requesting an OpenGL version below 3.2, `GLFW_OPENGL_ANY_PROFILE` must be used. If OpenGL ES is requested, this hint is ignored.

  OpenGL profiles are described in detail in the OpenGL Reference Manual.

GLFW_CONTEXT_ROBUSTNESS specifies the robustness strategy to be used by the context. This can be one of `GLFW_NO_RESET_NOTIFICATION` or `GLFW_LOSE_CONTEXT_ON_RESET`, or `GLFW_NO_ROBUSTNESS` to not request a robustness strategy.

GLFW_CONTEXT_RELEASE_BEHAVIOR specifies the release behavior to be used by the context. Possible values are one of `GLFW_ANY_RELEASE_BEHAVIOR`, `GLFW_RELEASE_BEHAVIOR_FLUSH` or `GLFW_RELEASE_BEHAVIOR_NONE`. If the behavior is `GLFW_ANY_RELEASE_BEHAVIOR`, the default behavior of the context creation API will be used. If the behavior is `GLFW_RELEASE_BEHAVIOR_FLUSH`, the pipeline will be flushed whenever the context is released from being the current one. If the behavior is `GLFW_RELEASE_BEHAVIOR_NONE`, the pipeline will not be flushed on release.

  Context release behaviors are described in detail by the GL_KHR_context_flush_control extension.

GLFW_CONTEXT_NO_ERROR specifies whether errors should be generated by the context. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. If enabled, situations that would have generated errors instead cause undefined behavior.

  The no error mode for OpenGL and OpenGL ES is described in detail by the GL_KHR_no_error extension.

### macOS specific window hints

GLFW_COCOA_RETINA_FRAMEBUFFER specifies whether to use full resolution framebuffers on Retina displays. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This is ignored on other platforms.

GLFW_COCOA_FRAME_NAME specifies the UTF-8 encoded name to use for autosaving the window frame, or if empty disables frame autosaving for the window. This is ignored on other platforms. This is set with glfwWindowHintString.

GLFW_COCOA_GRAPHICS_SWITCHING specifies whether to in Automatic Graphics Switching, i.e. to allow the system to choose the integrated GPU for the OpenGL context and move it between GPUs if necessary or whether to force it to always run on the discrete GPU. This only affects systems with both integrated and discrete GPUs. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. This is ignored on other platforms.

  Simpler programs and tools may want to enable this to save power, while games and other applications performing advanced rendering will want to leave it disabled.

  A bundled application that wishes to participate in Automatic Graphics Switching should also declare this in its `Info.plist` by setting the `NSSupportsAutomaticGraphicsSwitching` key to `true`.

### X11 specific window hints

GLFW_X11_CLASS_NAME and GLFW_X11_INSTANCE_NAME specifies the desired ASCII encoded class and instance parts of the ICCCM `WM_CLASS` window property. These are set with glfwWindowHintString.

### Supported and default values

Window hint | Default value | Supported values
--- | --- | ---
GLFW_RESIZABLE | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_VISIBLE | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_DECORATED | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_FOCUSED | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_AUTO_ICONIFY | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_FLOATING | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_MAXIMIZED | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_CENTER_CURSOR | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_TRANSPARENT_FRAMEBUFFER | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_FOCUS_ON_SHOW | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_SCALE_TO_MONITOR | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_RED_BITS | 8 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_GREEN_BITS | 8 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_BLUE_BITS | 8 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_ALPHA_BITS | 8 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_DEPTH_BITS | 24 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_STENCIL_BITS | 8 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_ACCUM_RED_BITS | 0 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_ACCUM_GREEN_BITS | 0 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_ACCUM_BLUE_BITS | 0 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_ACCUM_ALPHA_BITS | 0 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_AUX_BUFFERS | 0 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_SAMPLES | 0 | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_REFRESH_RATE | `GLFW_DONT_CARE` | 0 to `INT_MAX` or `GLFW_DONT_CARE`
GLFW_STEREO | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_SRGB_CAPABLE | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_DOUBLEBUFFER | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_CLIENT_API | `GLFW_OPENGL_API` | `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` or `GLFW_NO_API`
GLFW_CONTEXT_CREATION_API | `GLFW_NATIVE_CONTEXT_API` | `GLFW_NATIVE_CONTEXT_API`, `GLFW_EGL_CONTEXT_API` or `GLFW_OSMESA_CONTEXT_API`
GLFW_CONTEXT_VERSION_MAJOR | 1 | Any valid major version number of the chosen client API
GLFW_CONTEXT_VERSION_MINOR | 0 | Any valid minor version number of the chosen client API
GLFW_CONTEXT_ROBUSTNESS | `GLFW_NO_ROBUSTNESS` | `GLFW_NO_ROBUSTNESS`, `GLFW_NO_RESET_NOTIFICATION` or `GLFW_LOSE_CONTEXT_ON_RESET`
GLFW_CONTEXT_RELEASE_BEHAVIOR | `GLFW_ANY_RELEASE_BEHAVIOR` | `GLFW_ANY_RELEASE_BEHAVIOR`, `GLFW_RELEASE_BEHAVIOR_FLUSH` or `GLFW_RELEASE_BEHAVIOR_NONE`
GLFW_OPENGL_FORWARD_COMPAT | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_OPENGL_DEBUG_CONTEXT | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_OPENGL_PROFILE | `GLFW_OPENGL_ANY_PROFILE` | `GLFW_OPENGL_ANY_PROFILE`, `GLFW_OPENGL_COMPAT_PROFILE` or `GLFW_OPENGL_CORE_PROFILE`
GLFW_COCOA_RETINA_FRAMEBUFFER | `GLFW_TRUE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_COCOA_FRAME_NAME | `""` | A UTF-8 encoded frame autosave name
GLFW_COCOA_GRAPHICS_SWITCHING | `GLFW_FALSE` | `GLFW_TRUE` or `GLFW_FALSE`
GLFW_X11_CLASS_NAME | `""` | An ASCII encoded `WM_CLASS` class name
GLFW_X11_INSTANCE_NAME | `""` | An ASCII encoded `WM_CLASS` instance name

# Window event processing

See Event processing.

# Window properties and events

## User pointer

Each window has a user pointer that can be set with glfwSetWindowUserPointer and queried with glfwGetWindowUserPointer. This can be used for any purpose you need and will not be modified by GLFW throughout the life-time of the window.

The initial value of the pointer is `NULL`.

## Window closing and close flag

When the user attempts to close the window, for example by clicking the close widget or using a key chord like Alt+F4, the close flag of the window is set. The window is however not actually destroyed and, unless you watch for this state change, nothing further happens.

The current state of the close flag is returned by glfwWindowShouldClose and can be set or cleared directly with glfwSetWindowShouldClose. A common pattern is to use the close flag as a main loop condition.

while (!glfwWindowShouldClose(window))
{
render(window);
glfwSwapBuffers(window);
glfwPollEvents();
}

If you wish to be notified when the user attempts to close a window, set a close callback.

glfwSetWindowCloseCallback(window, window_close_callback);

The callback function is called directly after the close flag has been set. It can be used for example to filter close requests and clear the close flag again unless certain conditions are met.

void window_close_callback(GLFWwindow* window)
{
if (!time_to_close)
glfwSetWindowShouldClose(window, GLFW_FALSE);
}

## Window size

The size of a window can be changed with glfwSetWindowSize. For windowed mode windows, this sets the size, in screen coordinates of the content area or content area of the window. The window system may impose limits on window size.

glfwSetWindowSize(window, 640, 480);

For full screen windows, the specified size becomes the new resolution of the window's desired video mode. The video mode most closely matching the new desired video mode is set immediately. The window is resized to fit the resolution of the set video mode.

If you wish to be notified when a window is resized, whether by the user, the system or your own code, set a size callback.

glfwSetWindowSizeCallback(window, window_size_callback);

The callback function receives the new size, in screen coordinates, of the content area of the window when the window is resized.

void window_size_callback(GLFWwindow* window, int width, int height)
{
}

There is also glfwGetWindowSize for directly retrieving the current size of a window.

int width, height;
glfwGetWindowSize(window, &width, &height);

Note
  Do not pass the window size to `glViewport` or other pixel-based OpenGL calls. The window size is in screen coordinates, not pixels. Use the framebuffer size, which is in pixels, for pixel-based calls.

The above functions work with the size of the content area, but decorated windows typically have title bars and window frames around this rectangle. You can retrieve the extents of these with glfwGetWindowFrameSize.

int left, top, right, bottom;
glfwGetWindowFrameSize(window, &left, &top, &right, &bottom);

The returned values are the distances, in screen coordinates, from the edges of the content area to the corresponding edges of the full window. As they are distances and not coordinates, they are always zero or positive.

## Framebuffer size

While the size of a window is measured in screen coordinates, OpenGL works with pixels. The size you pass into `glViewport`, for example, should be in pixels. On some machines screen coordinates and pixels are the same, but on others they will not be. There is a second set of functions to retrieve the size, in pixels, of the framebuffer of a window.

If you wish to be notified when the framebuffer of a window is resized, whether by the user or the system, set a size callback.

glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

The callback function receives the new size of the framebuffer when it is resized, which can for example be used to update the OpenGL viewport.

void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
glViewport(0, 0, width, height);
}

There is also glfwGetFramebufferSize for directly retrieving the current size of the framebuffer of a window.

int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);

The size of a framebuffer may change independently of the size of a window, for example if the window is dragged between a regular monitor and a high-DPI one.

## Window content scale

The content scale for a window can be retrieved with glfwGetWindowContentScale.

float xscale, yscale;
glfwGetWindowContentScale(window, &xscale, &yscale);

The content scale is the ratio between the current DPI and the platform's default DPI. This is especially important for text and any UI elements. If the pixel dimensions of your UI scaled by this look appropriate on your machine then it should appear at a reasonable size on other machines regardless of their DPI and scaling settings. This relies on the system DPI and scaling settings being somewhat correct.

On systems where each monitors can have its own content scale, the window content scale will depend on which monitor the system considers the window to be on.

If you wish to be notified when the content scale of a window changes, whether because of a system setting change or because it was moved to a monitor with a different scale, set a content scale callback.

glfwSetWindowContentScaleCallback(window, window_content_scale_callback);

The callback function receives the new content scale of the window.

void window_content_scale_callback(GLFWwindow* window, float xscale, float yscale)
{
set_interface_scale(xscale, yscale);
}

On platforms where pixels and screen coordinates always map 1:1, the window will need to be resized to appear the same size when it is moved to a monitor with a different content scale. To have this done automatically both when the window is created and when its content scale later changes, set the GLFW_SCALE_TO_MONITOR window hint.

## Window size limits

The minimum and maximum size of the content area of a windowed mode window can be enforced with glfwSetWindowSizeLimits. The user may resize the window to any size and aspect ratio within the specified limits, unless the aspect ratio is also set.

glfwSetWindowSizeLimits(window, 200, 200, 400, 400);

To specify only a minimum size or only a maximum one, set the other pair to `GLFW_DONT_CARE`.

glfwSetWindowSizeLimits(window, 640, 480, GLFW_DONT_CARE, GLFW_DONT_CARE);

To disable size limits for a window, set them all to `GLFW_DONT_CARE`.

The aspect ratio of the content area of a windowed mode window can be enforced with glfwSetWindowAspectRatio. The user may resize the window freely unless size limits are also set, but the size will be constrained to maintain the aspect ratio.

glfwSetWindowAspectRatio(window, 16, 9);

The aspect ratio is specified as a numerator and denominator, corresponding to the width and height, respectively. If you want a window to maintain its current aspect ratio, use its current size as the ratio.

int width, height;
glfwGetWindowSize(window, &width, &height);
glfwSetWindowAspectRatio(window, width, height);

To disable the aspect ratio limit for a window, set both terms to `GLFW_DONT_CARE`.

You can have both size limits and aspect ratio set for a window, but the results are undefined if they conflict.

## Window position

The position of a windowed-mode window can be changed with glfwSetWindowPos. This moves the window so that the upper-left corner of its content area has the specified screen coordinates. The window system may put limitations on window placement.

glfwSetWindowPos(window, 100, 100);

If you wish to be notified when a window is moved, whether by the user, the system or your own code, set a position callback.

glfwSetWindowPosCallback(window, window_pos_callback);

The callback function receives the new position, in screen coordinates, of the upper-left corner of the content area when the window is moved.

void window_pos_callback(GLFWwindow* window, int xpos, int ypos)
{
}

There is also glfwGetWindowPos for directly retrieving the current position of the content area of the window.

int xpos, ypos;
glfwGetWindowPos(window, &xpos, &ypos);

## Window title

All GLFW windows have a title, although undecorated or full screen windows may not display it or only display it in a task bar or similar interface. You can set a UTF-8 encoded window title with glfwSetWindowTitle.

glfwSetWindowTitle(window, "My Window");

The specified string is copied before the function returns, so there is no need to keep it around.

As long as your source file is encoded as UTF-8, you can use any Unicode characters directly in the source.

glfwSetWindowTitle(window, "ラストエグザイル");

If you are using C++11 or C11, you can use a UTF-8 string literal.

glfwSetWindowTitle(window, u8"This is always a UTF-8 string");

## Window icon

Decorated windows have icons on some platforms. You can set this icon by specifying a list of candidate images with glfwSetWindowIcon.

GLFWimage images[2];
images[0] = load_icon("my_icon.png");
images[1] = load_icon("my_icon_small.png");
glfwSetWindowIcon(window, 2, images);

The image data is 32-bit, little-endian, non-premultiplied RGBA, i.e. eight bits per channel with the red channel first. The pixels are arranged canonically as sequential rows, starting from the top-left corner.

To revert to the default window icon, pass in an empty image array.

glfwSetWindowIcon(window, 0, NULL);

## Window monitor

Full screen windows are associated with a specific monitor. You can get the handle for this monitor with glfwGetWindowMonitor.

GLFWmonitor* monitor = glfwGetWindowMonitor(window);

This monitor handle is one of those returned by glfwGetMonitors.

For windowed mode windows, this function returns `NULL`. This is how to tell full screen windows from windowed mode windows.

You can move windows between monitors or between full screen and windowed mode with glfwSetWindowMonitor. When making a window full screen on the same or on a different monitor, specify the desired monitor, resolution and refresh rate. The position arguments are ignored.

const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);

When making the window windowed, specify the desired position and size. The refresh rate argument is ignored.

glfwSetWindowMonitor(window, NULL, xpos, ypos, width, height, 0);

This restores any previous window settings such as whether it is decorated, floating, resizable, has size or aspect ratio limits, etc.. To restore a window that was originally windowed to its original size and position, save these before making it full screen and then pass them in as above.

## Window iconification

Windows can be iconified (i.e. minimized) with glfwIconifyWindow.

glfwIconifyWindow(window);

When a full screen window is iconified, the original video mode of its monitor is restored until the user or application restores the window.

Iconified windows can be restored with glfwRestoreWindow. This function also restores windows from maximization.

glfwRestoreWindow(window);

When a full screen window is restored, the desired video mode is restored to its monitor as well.

If you wish to be notified when a window is iconified or restored, whether by the user, system or your own code, set an iconify callback.

glfwSetWindowIconifyCallback(window, window_iconify_callback);

The callback function receives changes in the iconification state of the window.

void window_iconify_callback(GLFWwindow* window, int iconified)
{
if (iconified)
{
// The window was iconified
}
else
{
// The window was restored
}
}

You can also get the current iconification state with glfwGetWindowAttrib.

int iconified = glfwGetWindowAttrib(window, GLFW_ICONIFIED);

## Window maximization

Windows can be maximized (i.e. zoomed) with glfwMaximizeWindow.

glfwMaximizeWindow(window);

Full screen windows cannot be maximized and passing a full screen window to this function does nothing.

Maximized windows can be restored with glfwRestoreWindow. This function also restores windows from iconification.

glfwRestoreWindow(window);

If you wish to be notified when a window is maximized or restored, whether by the user, system or your own code, set a maximize callback.

glfwSetWindowMaximizeCallback(window, window_maximize_callback);

The callback function receives changes in the maximization state of the window.

void window_maximize_callback(GLFWwindow* window, int maximized)
{
if (maximized)
{
// The window was maximized
}
else
{
// The window was restored
}
}

You can also get the current maximization state with glfwGetWindowAttrib.

int maximized = glfwGetWindowAttrib(window, GLFW_MAXIMIZED);

By default, newly created windows are not maximized. You can change this behavior by setting the GLFW_MAXIMIZED window hint before creating the window.

glfwWindowHint(GLFW_MAXIMIZED, GLFW_TRUE);

## Window visibility

Windowed mode windows can be hidden with glfwHideWindow.

glfwHideWindow(window);

This makes the window completely invisible to the user, including removing it from the task bar, dock or window list. Full screen windows cannot be hidden and calling glfwHideWindow on a full screen window does nothing.

Hidden windows can be shown with glfwShowWindow.

glfwShowWindow(window);

By default, this function will also set the input focus to that window. Set the GLFW_FOCUS_ON_SHOW window hint to change this behavior for all newly created windows, or change the behavior for an existing window with glfwSetWindowAttrib.

You can also get the current visibility state with glfwGetWindowAttrib.

int visible = glfwGetWindowAttrib(window, GLFW_VISIBLE);

By default, newly created windows are visible. You can change this behavior by setting the GLFW_VISIBLE window hint before creating the window.

glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);

Windows created hidden are completely invisible to the user until shown. This can be useful if you need to set up your window further before showing it, for example moving it to a specific location.

## Window input focus

Windows can be given input focus and brought to the front with glfwFocusWindow.

glfwFocusWindow(window);

Keep in mind that it can be very disruptive to the user when a window is forced to the top. For a less disruptive way of getting the user's attention, see attention requests.

If you wish to be notified when a window gains or loses input focus, whether by the user, system or your own code, set a focus callback.

glfwSetWindowFocusCallback(window, window_focus_callback);

The callback function receives changes in the input focus state of the window.

void window_focus_callback(GLFWwindow* window, int focused)
{
if (focused)
{
// The window gained input focus
}
else
{
// The window lost input focus
}
}

You can also get the current input focus state with glfwGetWindowAttrib.

int focused = glfwGetWindowAttrib(window, GLFW_FOCUSED);

By default, newly created windows are given input focus. You can change this behavior by setting the GLFW_FOCUSED window hint before creating the window.

glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);

## Window attention request

If you wish to notify the user of an event without interrupting, you can request attention with glfwRequestWindowAttention.

glfwRequestWindowAttention(window);

The system will highlight the specified window, or on platforms where this is not supported, the application as a whole. Once the user has given it attention, the system will automatically end the request.

## Window damage and refresh

If you wish to be notified when the contents of a window is damaged and needs to be refreshed, set a window refresh callback.

glfwSetWindowRefreshCallback(m_handle, window_refresh_callback);

The callback function is called when the contents of the window needs to be refreshed.

void window_refresh_callback(GLFWwindow* window)
{
draw_editor_ui(window);
glfwSwapBuffers(window);
}

Note
  On compositing window systems such as Aero, Compiz or Aqua, where the window contents are saved off-screen, this callback might only be called when the window or framebuffer is resized.

## Window transparency

GLFW supports two kinds of transparency for windows; framebuffer transparency and whole window transparency. A single window may not use both methods. The results of doing this are undefined.

Both methods require the platform to support it and not every version of every platform GLFW supports does this, so there are mechanisms to check whether the window really is transparent.

Window framebuffers can be made transparent on a per-pixel per-frame basis with the GLFW_TRANSPARENT_FRAMEBUFFER window hint.

glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);

If supported by the system, the window content area will be composited with the background using the framebuffer per-pixel alpha channel. This requires desktop compositing to be enabled on the system. It does not affect window decorations.

You can check whether the window framebuffer was successfully made transparent with the GLFW_TRANSPARENT_FRAMEBUFFER window attribute.

if (glfwGetWindowAttrib(window, GLFW_TRANSPARENT_FRAMEBUFFER))
{
// window framebuffer is currently transparent
}

GLFW comes with an example that enabled framebuffer transparency called `gears`.

The opacity of the whole window, including any decorations, can be set with glfwSetWindowOpacity.

glfwSetWindowOpacity(window, 0.5f);

The opacity (or alpha) value is a positive finite number between zero and one, where 0 (zero) is fully transparent and 1 (one) is fully opaque. The initial opacity value for newly created windows is 1.

The current opacity of a window can be queried with glfwGetWindowOpacity.

float opacity = glfwGetWindowOpacity(window);

If the system does not support whole window transparency, this function always returns one.

GLFW comes with a test program that lets you control whole window transparency at run-time called `opacity`.

## Window attributes

Windows have a number of attributes that can be returned using glfwGetWindowAttrib. Some reflect state that may change as a result of user interaction, (e.g. whether it has input focus), while others reflect inherent properties of the window (e.g. what kind of border it has). Some are related to the window and others to its OpenGL or OpenGL ES context.

if (glfwGetWindowAttrib(window, GLFW_FOCUSED))
{
// window has input focus
}

The GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING, GLFW_AUTO_ICONIFY and GLFW_FOCUS_ON_SHOW window attributes can be changed with glfwSetWindowAttrib.

glfwSetWindowAttrib(window, GLFW_RESIZABLE, GLFW_FALSE);

### Window related attributes

GLFW_FOCUSED indicates whether the specified window has input focus. See Window input focus for details.

GLFW_ICONIFIED indicates whether the specified window is iconified. See Window iconification for details.

GLFW_MAXIMIZED indicates whether the specified window is maximized. See Window maximization for details.

GLFW_HOVERED indicates whether the cursor is currently directly over the content area of the window, with no other windows between. See Cursor enter/leave events for details.

GLFW_VISIBLE indicates whether the specified window is visible. See Window visibility for details.

GLFW_RESIZABLE indicates whether the specified window is resizable by the user. This can be set before creation with the GLFW_RESIZABLE window hint or after with glfwSetWindowAttrib.

GLFW_DECORATED indicates whether the specified window has decorations such as a border, a close widget, etc. This can be set before creation with the GLFW_DECORATED window hint or after with glfwSetWindowAttrib.

GLFW_AUTO_ICONIFY indicates whether the specified full screen window is iconified on focus loss, a close widget, etc. This can be set before creation with the GLFW_AUTO_ICONIFY window hint or after with glfwSetWindowAttrib.

GLFW_FLOATING indicates whether the specified window is floating, also called topmost or always-on-top. This can be set before creation with the GLFW_FLOATING window hint or after with glfwSetWindowAttrib.

GLFW_TRANSPARENT_FRAMEBUFFER indicates whether the specified window has a transparent framebuffer, i.e. the window contents is composited with the background using the window framebuffer alpha channel. See Window transparency for details.

GLFW_FOCUS_ON_SHOW specifies whether the window will be given input focus when glfwShowWindow is called. This can be set before creation with the GLFW_FOCUS_ON_SHOW window hint or after with glfwSetWindowAttrib.

### Context related attributes

GLFW_CLIENT_API indicates the client API provided by the window's context; either `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` or `GLFW_NO_API`.

GLFW_CONTEXT_CREATION_API indicates the context creation API used to create the window's context; either `GLFW_NATIVE_CONTEXT_API`, `GLFW_EGL_CONTEXT_API` or `GLFW_OSMESA_CONTEXT_API`.

GLFW_CONTEXT_VERSION_MAJOR, GLFW_CONTEXT_VERSION_MINOR and GLFW_CONTEXT_REVISION indicate the client API version of the window's context.

Note
  Do not confuse these attributes with `GLFW_VERSION_MAJOR`, `GLFW_VERSION_MINOR` and `GLFW_VERSION_REVISION` which provide the API version of the GLFW header.

GLFW_OPENGL_FORWARD_COMPAT is `GLFW_TRUE` if the window's context is an OpenGL forward-compatible one, or `GLFW_FALSE` otherwise.

GLFW_OPENGL_DEBUG_CONTEXT is `GLFW_TRUE` if the window's context is an OpenGL debug context, or `GLFW_FALSE` otherwise.

GLFW_OPENGL_PROFILE indicates the OpenGL profile used by the context. This is `GLFW_OPENGL_CORE_PROFILE` or `GLFW_OPENGL_COMPAT_PROFILE` if the context uses a known profile, or `GLFW_OPENGL_ANY_PROFILE` if the OpenGL profile is unknown or the context is an OpenGL ES context. Note that the returned profile may not match the profile bits of the context flags, as GLFW will try other means of detecting the profile when no bits are set.

GLFW_CONTEXT_RELEASE_BEHAVIOR indicates the release used by the context. Possible values are one of `GLFW_ANY_RELEASE_BEHAVIOR`, `GLFW_RELEASE_BEHAVIOR_FLUSH` or `GLFW_RELEASE_BEHAVIOR_NONE`. If the behavior is `GLFW_ANY_RELEASE_BEHAVIOR`, the default behavior of the context creation API will be used. If the behavior is `GLFW_RELEASE_BEHAVIOR_FLUSH`, the pipeline will be flushed whenever the context is released from being the current one. If the behavior is `GLFW_RELEASE_BEHAVIOR_NONE`, the pipeline will not be flushed on release.

GLFW_CONTEXT_NO_ERROR indicates whether errors are generated by the context. Possible values are `GLFW_TRUE` and `GLFW_FALSE`. If enabled, situations that would have generated errors instead cause undefined behavior.

GLFW_CONTEXT_ROBUSTNESS indicates the robustness strategy used by the context. This is `GLFW_LOSE_CONTEXT_ON_RESET` or `GLFW_NO_RESET_NOTIFICATION` if the window's context supports robustness, or `GLFW_NO_ROBUSTNESS` otherwise.

### Framebuffer related attributes

GLFW does not expose attributes of the default framebuffer (i.e. the framebuffer attached to the window) as these can be queried directly with either OpenGL, OpenGL ES or Vulkan.

If you are using version 3.0 or later of OpenGL or OpenGL ES, the `glGetFramebufferAttachmentParameteriv` function can be used to retrieve the number of bits for the red, green, blue, alpha, depth and stencil buffer channels. Otherwise, the `glGetIntegerv` function can be used.

The number of MSAA samples are always retrieved with `glGetIntegerv`. For contexts supporting framebuffer objects, the number of samples of the currently bound framebuffer is returned.

Attribute | glGetIntegerv | glGetFramebufferAttachmentParameteriv
--- | --- | ---
Red bits | `GL_RED_BITS` | `GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE`
Green bits | `GL_GREEN_BITS` | `GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE`
Blue bits | `GL_BLUE_BITS` | `GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE`
Alpha bits | `GL_ALPHA_BITS` | `GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE`
Depth bits | `GL_DEPTH_BITS` | `GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE`
Stencil bits | `GL_STENCIL_BITS` | `GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE`
MSAA samples | `GL_SAMPLES` | Not provided by this function

When calling `glGetFramebufferAttachmentParameteriv`, the red, green, blue and alpha sizes are queried from the `GL_BACK_LEFT`, while the depth and stencil sizes are queried from the `GL_DEPTH` and `GL_STENCIL` attachments, respectively.

# Buffer swapping

GLFW windows are by default double buffered. That means that you have two rendering buffers; a front buffer and a back buffer. The front buffer is the one being displayed and the back buffer the one you render to.

When the entire frame has been rendered, it is time to swap the back and the front buffers in order to display what has been rendered and begin rendering a new frame. This is done with glfwSwapBuffers.

glfwSwapBuffers(window);

Sometimes it can be useful to select when the buffer swap will occur. With the function glfwSwapInterval it is possible to select the minimum number of monitor refreshes the driver should wait from the time glfwSwapBuffers was called before swapping the buffers:

glfwSwapInterval(1);

If the interval is zero, the swap will take place immediately when glfwSwapBuffers is called without waiting for a refresh. Otherwise at least interval retraces will pass between each buffer swap. Using a swap interval of zero can be useful for benchmarking purposes, when it is not desirable to measure the time it takes to wait for the vertical retrace. However, a swap interval of one lets you avoid tearing.

Note that this may not work on all machines, as some drivers have user-controlled settings that override any swap interval the application requests.

A context that supports either the `WGL_EXT_swap_control_tear` or the `GLX_EXT_swap_control_tear` extension also accepts negative swap intervals, which allows the driver to swap immediately even if a frame arrives a little bit late. This trades the risk of visible tears for greater framerate stability. You can check for these extensions with glfwExtensionSupported.

GLFW_TRANSPARENT_FRAMEBUFFER
#define GLFW_TRANSPARENT_FRAMEBUFFER
Window framebuffer transparency hint and attribute.
Definition: glfw3.h:818
glfwSetFramebufferSizeCallback
GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow *window, GLFWframebuffersizefun callback)
Sets the framebuffer resize callback for the specified window.
glfwSetWindowSize
void glfwSetWindowSize(GLFWwindow *window, int width, int height)
Sets the size of the content area of the specified window.
GLFW_RED_BITS
#define GLFW_RED_BITS
Framebuffer bit depth hint.
Definition: glfw3.h:835
glfwSetWindowPos
void glfwSetWindowPos(GLFWwindow *window, int xpos, int ypos)
Sets the position of the content area of the specified window.
glfwSetWindowAttrib
void glfwSetWindowAttrib(GLFWwindow *window, int attrib, int value)
Sets an attribute of the specified window.
glfwRestoreWindow
void glfwRestoreWindow(GLFWwindow *window)
Restores the specified window.
glfwGetWindowContentScale
void glfwGetWindowContentScale(GLFWwindow *window, float *xscale, float *yscale)
Retrieves the content scale for the specified window.
glfwSetWindowRefreshCallback
GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow *window, GLFWwindowrefreshfun callback)
Sets the refresh callback for the specified window.
glfwSetWindowSizeCallback
GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow *window, GLFWwindowsizefun callback)
Sets the size callback for the specified window.
glfwSetWindowMonitor
void glfwSetWindowMonitor(GLFWwindow *window, GLFWmonitor *monitor, int xpos, int ypos, int width, int height, int refreshRate)
Sets the mode, monitor, video mode and placement of a window.
glfwGetWindowPos
void glfwGetWindowPos(GLFWwindow *window, int *xpos, int *ypos)
Retrieves the position of the content area of the specified window.
glfwSetWindowMaximizeCallback
GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow *window, GLFWwindowmaximizefun callback)
Sets the maximize callback for the specified window.
glfwSetWindowTitle
void glfwSetWindowTitle(GLFWwindow *window, const char *title)
Sets the title of the specified window.
GLFWwindow
struct GLFWwindow GLFWwindow
Opaque window object.
Definition: glfw3.h:1152
glfwSwapBuffers
void glfwSwapBuffers(GLFWwindow *window)
Swaps the front and back buffers of the specified window.
glfwSwapInterval
void glfwSwapInterval(int interval)
Sets the swap interval for the current context.
GLFWvidmode::blueBits
int blueBits
Definition: glfw3.h:1640
glfwGetWindowFrameSize
void glfwGetWindowFrameSize(GLFWwindow *window, int *left, int *top, int *right, int *bottom)
Retrieves the size of the frame of the window.
GLFW_GREEN_BITS
#define GLFW_GREEN_BITS
Framebuffer bit depth hint.
Definition: glfw3.h:840
glfwWindowShouldClose
int glfwWindowShouldClose(GLFWwindow *window)
Checks the close flag of the specified window.
glfwPollEvents
void glfwPollEvents(void)
Processes all pending events.
glfwSetWindowSizeLimits
void glfwSetWindowSizeLimits(GLFWwindow *window, int minwidth, int minheight, int maxwidth, int maxheight)
Sets the size limits of the specified window.
glfwGetPrimaryMonitor
GLFWmonitor * glfwGetPrimaryMonitor(void)
Returns the primary monitor.
glfwSetWindowFocusCallback
GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow *window, GLFWwindowfocusfun callback)
Sets the focus callback for the specified window.
glfwSetWindowCloseCallback
GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow *window, GLFWwindowclosefun callback)
Sets the close callback for the specified window.
glfwFocusWindow
void glfwFocusWindow(GLFWwindow *window)
Brings the specified window to front and sets input focus.
GLFWvidmode::height
int height
Definition: glfw3.h:1631
glfwSetWindowContentScaleCallback
GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow *window, GLFWwindowcontentscalefun callback)
Sets the window content scale callback for the specified window.
glfwSetWindowPosCallback
GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow *window, GLFWwindowposfun callback)
Sets the position callback for the specified window.
GLFW_FALSE
#define GLFW_FALSE
Zero.
Definition: glfw3.h:289
GLFW_DONT_CARE
#define GLFW_DONT_CARE
Definition: glfw3.h:1096
glfwShowWindow
void glfwShowWindow(GLFWwindow *window)
Makes the specified window visible.
GLFW_TRUE
#define GLFW_TRUE
One.
Definition: glfw3.h:280
GLFW_ICONIFIED
#define GLFW_ICONIFIED
Window iconification window attribute.
Definition: glfw3.h:770
glfwRequestWindowAttention
void glfwRequestWindowAttention(GLFWwindow *window)
Requests user attention to the specified window.
GLFW_RESIZABLE
#define GLFW_RESIZABLE
Window resize-ability window hint and attribute.
Definition: glfw3.h:776
GLFW_FOCUSED
#define GLFW_FOCUSED
Input focus window hint and attribute.
Definition: glfw3.h:765
GLFW_BLUE_BITS
#define GLFW_BLUE_BITS
Framebuffer bit depth hint.
Definition: glfw3.h:845
glfwHideWindow
void glfwHideWindow(GLFWwindow *window)
Hides the specified window.
GLFWvidmode::width
int width
Definition: glfw3.h:1628
glfwMaximizeWindow
void glfwMaximizeWindow(GLFWwindow *window)
Maximizes the specified window.
glfwSetWindowIcon
void glfwSetWindowIcon(GLFWwindow *window, int count, const GLFWimage *images)
Sets the icon for the specified window.
glfwCreateWindow
GLFWwindow * glfwCreateWindow(int width, int height, const char *title, GLFWmonitor *monitor, GLFWwindow *share)
Creates a window and its associated context.
glfwSetWindowShouldClose
void glfwSetWindowShouldClose(GLFWwindow *window, int value)
Sets the close flag of the specified window.
glfwSetWindowAspectRatio
void glfwSetWindowAspectRatio(GLFWwindow *window, int numer, int denom)
Sets the aspect ratio of the specified window.
GLFWvidmode::greenBits
int greenBits
Definition: glfw3.h:1637
glfwGetWindowOpacity
float glfwGetWindowOpacity(GLFWwindow *window)
Returns the opacity of the whole window.
GLFWimage
Image data.
Definition: glfw3.h:1687
glfwSetWindowOpacity
void glfwSetWindowOpacity(GLFWwindow *window, float opacity)
Sets the opacity of the whole window.
glfwGetWindowMonitor
GLFWmonitor * glfwGetWindowMonitor(GLFWwindow *window)
Returns the monitor that the window uses for full screen mode.
glfwIconifyWindow
void glfwIconifyWindow(GLFWwindow *window)
Iconifies the specified window.
GLFW_MAXIMIZED
#define GLFW_MAXIMIZED
Window maximization window hint and attribute.
Definition: glfw3.h:806
glfwGetWindowAttrib
int glfwGetWindowAttrib(GLFWwindow *window, int attrib)
Returns an attribute of the specified window.
glfwSetWindowIconifyCallback
GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow *window, GLFWwindowiconifyfun callback)
Sets the iconify callback for the specified window.
glfwGetWindowSize
void glfwGetWindowSize(GLFWwindow *window, int *width, int *height)
Retrieves the size of the content area of the specified window.
GLFWvidmode
Video mode type.
Definition: glfw3.h:1624
glfwGetFramebufferSize
void glfwGetFramebufferSize(GLFWwindow *window, int *width, int *height)
Retrieves the size of the framebuffer of the specified window.
GLFWvidmode::redBits
int redBits
Definition: glfw3.h:1634
GLFW_REFRESH_RATE
#define GLFW_REFRESH_RATE
Monitor refresh rate hint.
Definition: glfw3.h:905
glfwWindowHint
void glfwWindowHint(int hint, int value)
Sets the specified window hint to the desired value.
GLFW_VISIBLE
#define GLFW_VISIBLE
Window visibility window hint and attribute.
Definition: glfw3.h:782
glfwGetVideoMode
const GLFWvidmode * glfwGetVideoMode(GLFWmonitor *monitor)
Returns the current mode of the specified monitor.
glfwDestroyWindow
void glfwDestroyWindow(GLFWwindow *window)
Destroys the specified window and its context.
GLFWmonitor
struct GLFWmonitor GLFWmonitor
Opaque monitor object.
Definition: glfw3.h:1140
GLFWvidmode::refreshRate
int refreshRate
Definition: glfw3.h:1643