Convert Doxygen code sections to Markdown

docs/window.md

@@ -30,9 +30,9 @@ A window and its OpenGL or OpenGL ES context are created with @ref
 glfwCreateWindow, which returns a handle to the created window object.  For
 example, this creates a 640 by 480 windowed mode window:
 
-@code{.c}
+```c
 GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", NULL, NULL);
-@endcode
+```
 
 If window creation fails, `NULL` will be returned, so it is necessary to check
 the return value.
@@ -48,9 +48,9 @@ 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 @ref monitor_monitors.
 
-@code{.c}
+```c
 GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", glfwGetPrimaryMonitor(), NULL);
-@endcode
+```
 
 Full screen windows cover the entire display area of a monitor, have no border
 or decorations.
@@ -99,7 +99,7 @@ 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.
 
-@code{.c}
+```c
 const GLFWvidmode* mode = glfwGetVideoMode(monitor);
 
 glfwWindowHint(GLFW_RED_BITS, mode->redBits);
@@ -108,15 +108,15 @@ glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
 glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);
 
 GLFWwindow* window = glfwCreateWindow(mode->width, mode->height, "My Title", monitor, NULL);
-@endcode
+```
 
 This also works for windowed mode windows that are made full screen.
 
-@code{.c}
+```c
 const GLFWvidmode* mode = glfwGetVideoMode(monitor);
 
 glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
-@endcode
+```
 
 Note that @ref 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
@@ -127,9 +127,9 @@ make windowed full screen, you need to have saved the desktop resolution before.
 
 When a window is no longer needed, destroy it with @ref glfwDestroyWindow.
 
-@code{.c}
+```c
 glfwDestroyWindow(window);
-@endcode
+```
 
 Window destruction always succeeds.  Before the actual destruction, all
 callbacks are removed so no further events will be delivered for the window.
@@ -596,7 +596,7 @@ The current state of the close flag is returned by @ref glfwWindowShouldClose
 and can be set or cleared directly with @ref glfwSetWindowShouldClose.  A common
 pattern is to use the close flag as a main loop condition.
 
-@code{.c}
+```c
 while (!glfwWindowShouldClose(window))
 {
     render(window);
@@ -604,26 +604,26 @@ while (!glfwWindowShouldClose(window))
     glfwSwapBuffers(window);
     glfwPollEvents();
 }
-@endcode
+```
 
 If you wish to be notified when the user attempts to close a window, set a close
 callback.
 
-@code{.c}
+```c
 glfwSetWindowCloseCallback(window, window_close_callback);
-@endcode
+```
 
 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.
 
-@code{.c}
+```c
 void window_close_callback(GLFWwindow* window)
 {
     if (!time_to_close)
         glfwSetWindowShouldClose(window, GLFW_FALSE);
 }
-@endcode
+```
 
 
 ### Window size {#window_size}
@@ -633,9 +633,9 @@ mode windows, this sets the size, in
 [screen coordinates](@ref coordinate_systems) of the _content area_ or _content
 area_ of the window.  The window system may impose limits on window size.
 
-@code{.c}
+```c
 glfwSetWindowSize(window, 640, 480);
-@endcode
+```
 
 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
@@ -645,26 +645,26 @@ 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.
 
-@code{.c}
+```c
 glfwSetWindowSizeCallback(window, window_size_callback);
-@endcode
+```
 
 The callback function receives the new size, in screen coordinates, of the
 content area of the window when the window is resized.
 
-@code{.c}
+```c
 void window_size_callback(GLFWwindow* window, int width, int height)
 {
 }
-@endcode
+```
 
 There is also @ref glfwGetWindowSize for directly retrieving the current size of
 a window.
 
-@code{.c}
+```c
 int width, height;
 glfwGetWindowSize(window, &width, &height);
-@endcode
+```
 
 @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
@@ -675,10 +675,10 @@ 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 @ref glfwGetWindowFrameSize.
 
-@code{.c}
+```c
 int left, top, right, bottom;
 glfwGetWindowFrameSize(window, &left, &top, &right, &bottom);
-@endcode
+```
 
 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
@@ -696,28 +696,28 @@ 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.
 
-@code{.c}
+```c
 glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
-@endcode
+```
 
 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.
 
-@code{.c}
+```c
 void framebuffer_size_callback(GLFWwindow* window, int width, int height)
 {
     glViewport(0, 0, width, height);
 }
-@endcode
+```
 
 There is also @ref glfwGetFramebufferSize for directly retrieving the current
 size of the framebuffer of a window.
 
-@code{.c}
+```c
 int width, height;
 glfwGetFramebufferSize(window, &width, &height);
 glViewport(0, 0, width, height);
-@endcode
+```
 
 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.
@@ -728,10 +728,10 @@ example if the window is dragged between a regular monitor and a high-DPI one.
 The content scale for a window can be retrieved with @ref
 glfwGetWindowContentScale.
 
-@code{.c}
+```c
 float xscale, yscale;
 glfwGetWindowContentScale(window, &xscale, &yscale);
-@endcode
+```
 
 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
@@ -748,18 +748,18 @@ 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.
 
-@code{.c}
+```c
 glfwSetWindowContentScaleCallback(window, window_content_scale_callback);
-@endcode
+```
 
 The callback function receives the new content scale of the window.
 
-@code{.c}
+```c
 void window_content_scale_callback(GLFWwindow* window, float xscale, float yscale)
 {
     set_interface_scale(xscale, yscale);
 }
-@endcode
+```
 
 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
@@ -775,16 +775,16 @@ be enforced with @ref glfwSetWindowSizeLimits.  The user may resize the window
 to any size and aspect ratio within the specified limits, unless the aspect
 ratio is also set.
 
-@code{.c}
+```c
 glfwSetWindowSizeLimits(window, 200, 200, 400, 400);
-@endcode
+```
 
 To specify only a minimum size or only a maximum one, set the other pair to
 `GLFW_DONT_CARE`.
 
-@code{.c}
+```c
 glfwSetWindowSizeLimits(window, 640, 480, GLFW_DONT_CARE, GLFW_DONT_CARE);
-@endcode
+```
 
 To disable size limits for a window, set them all to `GLFW_DONT_CARE`.
 
@@ -793,19 +793,19 @@ with @ref 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.
 
-@code{.c}
+```c
 glfwSetWindowAspectRatio(window, 16, 9);
-@endcode
+```
 
 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.
 
-@code{.c}
+```c
 int width, height;
 glfwGetWindowSize(window, &width, &height);
 glfwSetWindowAspectRatio(window, width, height);
-@endcode
+```
 
 To disable the aspect ratio limit for a window, set both terms to
 `GLFW_DONT_CARE`.
@@ -822,10 +822,10 @@ This is most often the right choice.  If you need to create a window at
 a specific position, you can set the desired position with the @ref
 GLFW_POSITION_X and @ref GLFW_POSITION_Y window hints.
 
-@code{.c}
+```c
 glfwWindowHint(GLFW_POSITION_X, 70);
 glfwWindowHint(GLFW_POSITION_Y, 83);
-@endcode
+```
 
 To restore the previous behavior, set these hints to `GLFW_ANY_POSITION`.
 
@@ -834,33 +834,33 @@ glfwSetWindowPos.  This moves the window so that the upper-left corner of its
 content area has the specified [screen coordinates](@ref coordinate_systems).
 The window system may put limitations on window placement.
 
-@code{.c}
+```c
 glfwSetWindowPos(window, 100, 100);
-@endcode
+```
 
 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.
 
-@code{.c}
+```c
 glfwSetWindowPosCallback(window, window_pos_callback);
-@endcode
+```
 
 The callback function receives the new position, in screen coordinates, of the
 upper-left corner of the content area when the window is moved.
 
-@code{.c}
+```c
 void window_pos_callback(GLFWwindow* window, int xpos, int ypos)
 {
 }
-@endcode
+```
 
 There is also @ref glfwGetWindowPos for directly retrieving the current position
 of the content area of the window.
 
-@code{.c}
+```c
 int xpos, ypos;
 glfwGetWindowPos(window, &xpos, &ypos);
-@endcode
+```
 
 
 ### Window title {#window_title}
@@ -869,9 +869,9 @@ 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 @ref glfwSetWindowTitle.
 
-@code{.c}
+```c
 glfwSetWindowTitle(window, "My Window");
-@endcode
+```
 
 The specified string is copied before the function returns, so there is no need
 to keep it around.
@@ -879,15 +879,15 @@ 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.
 
-@code{.c}
+```c
 glfwSetWindowTitle(window, "ラストエグザイル");
-@endcode
+```
 
 If you are using C++11 or C11, you can use a UTF-8 string literal.
 
-@code{.c}
+```c
 glfwSetWindowTitle(window, u8"This is always a UTF-8 string");
-@endcode
+```
 
 
 ### Window icon {#window_icon}
@@ -895,13 +895,13 @@ glfwSetWindowTitle(window, u8"This is always a UTF-8 string");
 Decorated windows have icons on some platforms.  You can set this icon by
 specifying a list of candidate images with @ref glfwSetWindowIcon.
 
-@code{.c}
+```c
 GLFWimage images[2];
 images[0] = load_icon("my_icon.png");
 images[1] = load_icon("my_icon_small.png");
 
 glfwSetWindowIcon(window, 2, images);
-@endcode
+```
 
 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
@@ -909,9 +909,9 @@ sequential rows, starting from the top-left corner.
 
 To revert to the default window icon, pass in an empty image array.
 
-@code{.c}
+```c
 glfwSetWindowIcon(window, 0, NULL);
-@endcode
+```
 
 
 ### Window monitor {#window_monitor}
@@ -919,9 +919,9 @@ glfwSetWindowIcon(window, 0, NULL);
 Full screen windows are associated with a specific monitor.  You can get the
 handle for this monitor with @ref glfwGetWindowMonitor.
 
-@code{.c}
+```c
 GLFWmonitor* monitor = glfwGetWindowMonitor(window);
-@endcode
+```
 
 This monitor handle is one of those returned by @ref glfwGetMonitors.
 
@@ -933,18 +933,18 @@ with @ref 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.
 
-@code{.c}
+```c
 const GLFWvidmode* mode = glfwGetVideoMode(monitor);
 
 glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
-@endcode
+```
 
 When making the window windowed, specify the desired position and size.  The
 refresh rate argument is ignored.
 
-@code{.c}
+```c
 glfwSetWindowMonitor(window, NULL, xpos, ypos, width, height, 0);
-@endcode
+```
 
 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
@@ -956,9 +956,9 @@ before making it full screen and then pass them in as above.
 
 Windows can be iconified (i.e. minimized) with @ref glfwIconifyWindow.
 
-@code{.c}
+```c
 glfwIconifyWindow(window);
-@endcode
+```
 
 When a full screen window is iconified, the original video mode of its monitor
 is restored until the user or application restores the window.
@@ -966,9 +966,9 @@ is restored until the user or application restores the window.
 Iconified windows can be restored with @ref glfwRestoreWindow.  This function
 also restores windows from maximization.
 
-@code{.c}
+```c
 glfwRestoreWindow(window);
-@endcode
+```
 
 When a full screen window is restored, the desired video mode is restored to its
 monitor as well.
@@ -976,13 +976,13 @@ 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.
 
-@code{.c}
+```c
 glfwSetWindowIconifyCallback(window, window_iconify_callback);
-@endcode
+```
 
 The callback function receives changes in the iconification state of the window.
 
-@code{.c}
+```c
 void window_iconify_callback(GLFWwindow* window, int iconified)
 {
     if (iconified)
@@ -994,22 +994,22 @@ void window_iconify_callback(GLFWwindow* window, int iconified)
         // The window was restored
     }
 }
-@endcode
+```
 
 You can also get the current iconification state with @ref glfwGetWindowAttrib.
 
-@code{.c}
+```c
 int iconified = glfwGetWindowAttrib(window, GLFW_ICONIFIED);
-@endcode
+```
 
 
 ### Window maximization {#window_maximize}
 
 Windows can be maximized (i.e. zoomed) with @ref glfwMaximizeWindow.
 
-@code{.c}
+```c
 glfwMaximizeWindow(window);
-@endcode
+```
 
 Full screen windows cannot be maximized and passing a full screen window to this
 function does nothing.
@@ -1017,20 +1017,20 @@ function does nothing.
 Maximized windows can be restored with @ref glfwRestoreWindow.  This function
 also restores windows from iconification.
 
-@code{.c}
+```c
 glfwRestoreWindow(window);
-@endcode
+```
 
 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.
 
-@code{.c}
+```c
 glfwSetWindowMaximizeCallback(window, window_maximize_callback);
-@endcode
+```
 
 The callback function receives changes in the maximization state of the window.
 
-@code{.c}
+```c
 void window_maximize_callback(GLFWwindow* window, int maximized)
 {
     if (maximized)
@@ -1042,30 +1042,30 @@ void window_maximize_callback(GLFWwindow* window, int maximized)
         // The window was restored
     }
 }
-@endcode
+```
 
 You can also get the current maximization state with @ref glfwGetWindowAttrib.
 
-@code{.c}
+```c
 int maximized = glfwGetWindowAttrib(window, GLFW_MAXIMIZED);
-@endcode
+```
 
 By default, newly created windows are not maximized.  You can change this
 behavior by setting the [GLFW_MAXIMIZED](@ref GLFW_MAXIMIZED_hint) window hint
 before creating the window.
 
-@code{.c}
+```c
 glfwWindowHint(GLFW_MAXIMIZED, GLFW_TRUE);
-@endcode
+```
 
 
 ### Window visibility {#window_hide}
 
 Windowed mode windows can be hidden with @ref glfwHideWindow.
 
-@code{.c}
+```c
 glfwHideWindow(window);
-@endcode
+```
 
 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
@@ -1073,9 +1073,9 @@ and calling @ref glfwHideWindow on a full screen window does nothing.
 
 Hidden windows can be shown with @ref glfwShowWindow.
 
-@code{.c}
+```c
 glfwShowWindow(window);
-@endcode
+```
 
 By default, this function will also set the input focus to that window. Set
 the [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) window hint to change
@@ -1084,17 +1084,17 @@ existing window with @ref glfwSetWindowAttrib.
 
 You can also get the current visibility state with @ref glfwGetWindowAttrib.
 
-@code{.c}
+```c
 int visible = glfwGetWindowAttrib(window, GLFW_VISIBLE);
-@endcode
+```
 
 By default, newly created windows are visible.  You can change this behavior by
 setting the [GLFW_VISIBLE](@ref GLFW_VISIBLE_hint) window hint before creating
 the window.
 
-@code{.c}
+```c
 glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
-@endcode
+```
 
 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
@@ -1106,9 +1106,9 @@ example moving it to a specific location.
 Windows can be given input focus and brought to the front with @ref
 glfwFocusWindow.
 
-@code{.c}
+```c
 glfwFocusWindow(window);
-@endcode
+```
 
 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
@@ -1117,13 +1117,13 @@ to the top.  For a less disruptive way of getting the user's attention, see
 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.
 
-@code{.c}
+```c
 glfwSetWindowFocusCallback(window, window_focus_callback);
-@endcode
+```
 
 The callback function receives changes in the input focus state of the window.
 
-@code{.c}
+```c
 void window_focus_callback(GLFWwindow* window, int focused)
 {
     if (focused)
@@ -1135,21 +1135,21 @@ void window_focus_callback(GLFWwindow* window, int focused)
         // The window lost input focus
     }
 }
-@endcode
+```
 
 You can also get the current input focus state with @ref glfwGetWindowAttrib.
 
-@code{.c}
+```c
 int focused = glfwGetWindowAttrib(window, GLFW_FOCUSED);
-@endcode
+```
 
 By default, newly created windows are given input focus.  You can change this
 behavior by setting the [GLFW_FOCUSED](@ref GLFW_FOCUSED_hint) window hint
 before creating the window.
 
-@code{.c}
+```c
 glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
-@endcode
+```
 
 
 ### Window attention request {#window_attention}
@@ -1157,9 +1157,9 @@ glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
 If you wish to notify the user of an event without interrupting, you can request
 attention with @ref glfwRequestWindowAttention.
 
-@code{.c}
+```c
 glfwRequestWindowAttention(window);
-@endcode
+```
 
 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
@@ -1171,20 +1171,20 @@ attention, the system will automatically end the request.
 If you wish to be notified when the contents of a window is damaged and needs
 to be refreshed, set a window refresh callback.
 
-@code{.c}
+```c
 glfwSetWindowRefreshCallback(m_handle, window_refresh_callback);
-@endcode
+```
 
 The callback function is called when the contents of the window needs to be
 refreshed.
 
-@code{.c}
+```c
 void window_refresh_callback(GLFWwindow* window)
 {
     draw_editor_ui(window);
     glfwSwapBuffers(window);
 }
-@endcode
+```
 
 @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
@@ -1205,9 +1205,9 @@ Window framebuffers can be made transparent on a per-pixel per-frame basis with
 the [GLFW_TRANSPARENT_FRAMEBUFFER](@ref GLFW_TRANSPARENT_FRAMEBUFFER_hint)
 window hint.
 
-@code{.c}
+```c
 glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);
-@endcode
+```
 
 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
@@ -1218,21 +1218,21 @@ with the
 [GLFW_TRANSPARENT_FRAMEBUFFER](@ref GLFW_TRANSPARENT_FRAMEBUFFER_attrib)
 window attribute.
 
-@code{.c}
+```c
 if (glfwGetWindowAttrib(window, GLFW_TRANSPARENT_FRAMEBUFFER))
 {
     // window framebuffer is currently transparent
 }
-@endcode
+```
 
 GLFW comes with an example that enabled framebuffer transparency called `gears`.
 
 The opacity of the whole window, including any decorations, can be set with @ref
 glfwSetWindowOpacity.
 
-@code{.c}
+```c
 glfwSetWindowOpacity(window, 0.5f);
-@endcode
+```
 
 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
@@ -1240,9 +1240,9 @@ opacity value for newly created windows is 1.
 
 The current opacity of a window can be queried with @ref glfwGetWindowOpacity.
 
-@code{.c}
+```c
 float opacity = glfwGetWindowOpacity(window);
-@endcode
+```
 
 If the system does not support whole window transparency, this function always
 returns one.
@@ -1263,12 +1263,12 @@ 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.
 
-@code{.c}
+```c
 if (glfwGetWindowAttrib(window, GLFW_FOCUSED))
 {
     // window has input focus
 }
-@endcode
+```
 
 The [GLFW_DECORATED](@ref GLFW_DECORATED_attrib),
 [GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib),
@@ -1277,9 +1277,9 @@ The [GLFW_DECORATED](@ref GLFW_DECORATED_attrib),
 [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_attrib) window attributes can be
 changed with @ref glfwSetWindowAttrib.
 
-@code{.c}
+```c
 glfwSetWindowAttrib(window, GLFW_RESIZABLE, GLFW_FALSE);
-@endcode
+```
 
 
 
@@ -1463,18 +1463,18 @@ 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 @ref glfwSwapBuffers.
 
-@code{.c}
+```c
 glfwSwapBuffers(window);
-@endcode
+```
 
 Sometimes it can be useful to select when the buffer swap will occur.  With the
 function @ref glfwSwapInterval it is possible to select the minimum number of
 monitor refreshes the driver should wait from the time @ref glfwSwapBuffers was
 called before swapping the buffers:
 
-@code{.c}
+```c
 glfwSwapInterval(1);
-@endcode
+```
 
 If the interval is zero, the swap will take place immediately when @ref
 glfwSwapBuffers is called without waiting for a refresh.  Otherwise at least