chromium/third_party/dawn/third_party/glfw/src/window.c

//========================================================================
// GLFW 3.5 - www.glfw.org
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-2019 Camilla Löwy <[email protected]>
// Copyright (c) 2012 Torsten Walluhn <[email protected]>
//
// 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"

#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <float.h>


//////////////////////////////////////////////////////////////////////////
//////                         GLFW event API                       //////
//////////////////////////////////////////////////////////////////////////

// Notifies shared code that a window has lost or received input focus
//
void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
{ … }

// Notifies shared code that a window has moved
// The position is specified in content area relative screen coordinates
//
void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
{ … }

// Notifies shared code that a window has been resized
// The size is specified in screen coordinates
//
void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
{ … }

// Notifies shared code that a window has been iconified or restored
//
void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified)
{ … }

// Notifies shared code that a window has been maximized or restored
//
void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized)
{ … }

// Notifies shared code that a window framebuffer has been resized
// The size is specified in pixels
//
void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
{ … }

// Notifies shared code that a window content scale has changed
// The scale is specified as the ratio between the current and default DPI
//
void _glfwInputWindowContentScale(_GLFWwindow* window, float xscale, float yscale)
{ … }

// Notifies shared code that the window contents needs updating
//
void _glfwInputWindowDamage(_GLFWwindow* window)
{ … }

// Notifies shared code that the user wishes to close a window
//
void _glfwInputWindowCloseRequest(_GLFWwindow* window)
{ … }

// Notifies shared code that a window has changed its desired monitor
//
void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor)
{ … }

//////////////////////////////////////////////////////////////////////////
//////                        GLFW public API                       //////
//////////////////////////////////////////////////////////////////////////

GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
                                     const char* title,
                                     GLFWmonitor* monitor,
                                     GLFWwindow* share)
{ … }

void glfwDefaultWindowHints(void)
{ … }

GLFWAPI void glfwWindowHint(int hint, int value)
{ … }

GLFWAPI void glfwWindowHintString(int hint, const char* value)
{ … }

GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
{ … }

GLFWAPI int glfwWindowShouldClose(GLFWwindow* handle)
{ … }

GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
{ … }

GLFWAPI const char* glfwGetWindowTitle(GLFWwindow* handle)
{ … }

GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
{ … }

GLFWAPI void glfwSetWindowIcon(GLFWwindow* handle,
                               int count, const GLFWimage* images)
{ … }

GLFWAPI void glfwGetWindowPos(GLFWwindow* handle, int* xpos, int* ypos)
{ … }

GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
{ … }

GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
{ … }

GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
{ … }

GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
                                     int minwidth, int minheight,
                                     int maxwidth, int maxheight)
{ … }

GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
{ … }

GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
{ … }

GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
                                    int* left, int* top,
                                    int* right, int* bottom)
{ … }

GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
                                       float* xscale, float* yscale)
{ … }

GLFWAPI float glfwGetWindowOpacity(GLFWwindow* handle)
{ … }

GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
{ … }

GLFWAPI void glfwIconifyWindow(GLFWwindow* handle)
{ … }

GLFWAPI void glfwRestoreWindow(GLFWwindow* handle)
{ … }

GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
{ … }

GLFWAPI void glfwShowWindow(GLFWwindow* handle)
{ … }

GLFWAPI void glfwRequestWindowAttention(GLFWwindow* handle)
{ … }

GLFWAPI void glfwHideWindow(GLFWwindow* handle)
{ … }

GLFWAPI void glfwFocusWindow(GLFWwindow* handle)
{ … }

GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
{ … }

GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
{ … }

GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* handle)
{ … }

GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
                                  GLFWmonitor* mh,
                                  int xpos, int ypos,
                                  int width, int height,
                                  int refreshRate)
{ … }

GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* handle, void* pointer)
{ … }

GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* handle)
{ … }

GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* handle,
                                                  GLFWwindowposfun cbfun)
{ … }

GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* handle,
                                                    GLFWwindowsizefun cbfun)
{ … }

GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* handle,
                                                      GLFWwindowclosefun cbfun)
{ … }

GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* handle,
                                                          GLFWwindowrefreshfun cbfun)
{ … }

GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
                                                      GLFWwindowfocusfun cbfun)
{ … }

GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
                                                          GLFWwindowiconifyfun cbfun)
{ … }

GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* handle,
                                                            GLFWwindowmaximizefun cbfun)
{ … }

GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
                                                              GLFWframebuffersizefun cbfun)
{ … }

GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* handle,
                                                                    GLFWwindowcontentscalefun cbfun)
{ … }

GLFWAPI void glfwPollEvents(void)
{ … }

GLFWAPI void glfwWaitEvents(void)
{ … }

GLFWAPI void glfwWaitEventsTimeout(double timeout)
{ … }

GLFWAPI void glfwPostEmptyEvent(void)
{ … }