ruby-glfw 0.9

data/glfw-src/docs/Makefile

@@ -0,0 +1,57 @@
+##########################################################################
+# Makefile for the GLFW documentation.
+##########################################################################
+
+PDFDOCS = glfwrm.pdf glfwug.pdf
+DVIDOCS = glfwrm.dvi glfwug.dvi
+
+
+##########################################################################
+# Build macros
+##########################################################################
+default: pdf
+pdf:     $(PDFDOCS)
+dvi:     $(DVIDOCS)
+
+
+##########################################################################
+# Clean macros
+##########################################################################
+clean:
+	rm -f glfwrm.dvi glfwrm.aux glfwrm.log glfwrm.out glfwrm.pdf glfwrm.toc glfwrm.lot
+	rm -f glfwug.dvi glfwug.aux glfwug.log glfwug.out glfwug.pdf glfwug.toc
+
+clean-win:
+	@.\\cleanup.bat
+
+
+##########################################################################
+# Rules for building the GLFW Reference Manual
+##########################################################################
+
+glfwrm.pdf: glfwrm.tex glfwrm.toc glfwrm.lot glfwdoc.sty
+	pdflatex glfwrm.tex
+
+glfwrm.dvi: glfwrm.tex glfwrm.toc glfwrm.lot glfwdoc.sty
+	latex glfwrm.tex
+
+glfwrm.toc: glfwrm.tex glfwdoc.sty
+	latex glfwrm.tex
+
+glfwrm.lot: glfwrm.tex glfwdoc.sty
+	latex glfwrm.tex
+
+
+##########################################################################
+# Rules for building the GLFW Users Guide
+##########################################################################
+
+glfwug.pdf: glfwug.tex glfwug.toc glfwdoc.sty
+	pdflatex glfwug.tex
+
+glfwug.dvi: glfwug.tex glfwug.toc glfwdoc.sty
+	latex glfwug.tex
+
+glfwug.toc: glfwug.tex glfwdoc.sty
+	latex glfwug.tex
+

data/glfw-src/docs/cleanup.bat

@@ -0,0 +1,22 @@
+@echo off
+
+REM ----------------------------------------------------------------------
+REM Windows cleanup batch file for the GLFW documentation.
+REM ----------------------------------------------------------------------
+
+REM GLFW Reference Manual
+if exist glfwrm.dvi del glfwrm.dvi
+if exist glfwrm.aux del glfwrm.aux
+if exist glfwrm.log del glfwrm.log
+if exist glfwrm.out del glfwrm.out
+if exist glfwrm.pdf del glfwrm.pdf
+if exist glfwrm.toc del glfwrm.toc
+if exist glfwrm.lot del glfwrm.lot
+
+REM GLFW Users Guide
+if exist glfwug.dvi del glfwug.dvi
+if exist glfwug.aux del glfwug.aux
+if exist glfwug.log del glfwug.log
+if exist glfwug.out del glfwug.out
+if exist glfwug.pdf del glfwug.pdf
+if exist glfwug.toc del glfwug.toc

data/glfw-src/docs/glfwdoc.sty

@@ -0,0 +1,80 @@
+%-------------------------------------------------------------------------
+% Common document formatting and macros for GLFW manuals
+%-------------------------------------------------------------------------
+
+% Misc. document info
+\date{\today}
+
+% Packages
+\usepackage{fancyhdr}
+\usepackage{titling}
+\usepackage{lastpage}
+\usepackage{listings}
+\usepackage{color}
+\usepackage[overload]{textcase}
+\usepackage{needspace}
+\usepackage{times}
+
+% Logo macros
+\newcommand{\OpenGL}[1][0]{\textbf{OpenGL}\texttrademark}
+\newcommand{\GLFW}[1][0]{\textbf{GLFW}}
+
+% Encoding
+\usepackage[latin1]{inputenc}
+\usepackage[T1]{fontenc}
+
+% Page formatting
+\usepackage[hmargin=2.5cm]{geometry}
+\raggedright
+\raggedbottom
+\sloppy
+\usepackage{parskip}
+
+% Header and footer
+\pagestyle{fancy}
+%\lhead{\textit{GLFW Reference Manual}}
+\lhead{\textit{GLFW \glfwdoctype}}
+\chead{API version \glfwapiver}
+\rhead{Page \thepage/\pageref{LastPage}}
+\lfoot{}
+\cfoot{}
+\rfoot{}
+\renewcommand{\headrulewidth}{0.4pt}
+\renewcommand{\footrulewidth}{0.0pt}
+
+% Titlepage
+\newcommand{\glfwmaketitle}{\begin{titlepage}\ \\%
+                            \begin{center}%
+                            \vspace{7.0cm}{\Huge\textbf{GLFW}}\\%
+                            \rule{10.0cm}{0.5pt}\\%
+                            \vspace{0.5cm}{\LARGE\textbf{\glfwdoctype}}\\%
+                            \vspace{0.8cm}{\large\textbf{API version \glfwapiver}}\\%
+                            \textit{\today}\\%
+                            \vspace{1.5cm}\textbf{\textcopyright2002-2007 Camilla Berglund}\\%
+                            \end{center}\end{titlepage}\newpage}
+
+% Colors
+\definecolor{code}{rgb}{0.9,0.9,1.0}
+\definecolor{link}{rgb}{0.6,0.0,0.0}
+\definecolor{codeA}{rgb}{0.9,1.0,0.9}
+\definecolor{codeB}{rgb}{1.0,0.9,0.9}
+
+% Code listings
+\lstset{frame=single,frameround=tttt,backgroundcolor=\color{code},%
+        language=C,basicstyle={\ttfamily},%
+        breaklines,breakindent=0pt,postbreak=\space\space\space\space}
+
+
+% A simple hack for keeping lines together
+\newenvironment{mysamepage}[1][2]{\begin{samepage}\needspace{#1\baselineskip}}{\end{samepage}}
+
+% Macros for automating function reference entries
+\newenvironment{refparameters}[1][0]{\begin{mysamepage}\textbf{Parameters}\\}{\end{mysamepage}\bigskip}
+\newenvironment{refreturn}[1][0]{\begin{mysamepage}\textbf{Return values}\\}{\end{mysamepage}\bigskip}
+\newenvironment{refdescription}[1][0]{\begin{mysamepage}\textbf{Description}\\}{\end{mysamepage}\bigskip}
+\newenvironment{refnotes}[1][0]{\begin{mysamepage}\textbf{Notes}\\}{\end{mysamepage}\bigskip}
+
+% hyperref (bookmarks, links etc) - use this package last
+\usepackage[colorlinks=true,linkcolor=link,bookmarks=true,bookmarksopen=true,%
+            pdfhighlight=/N,bookmarksnumbered=true,bookmarksopenlevel=1,%
+            pdfview=FitH,pdfstartview=FitH]{hyperref}

data/glfw-src/docs/glfwrm.tex

@@ -0,0 +1,3034 @@
+%-------------------------------------------------------------------------
+% GLFW Reference Manual
+% API Version: 2.6
+%-------------------------------------------------------------------------
+
+% Document class
+\documentclass[a4paper,11pt,oneside]{report}
+
+% Document title and API version
+\newcommand{\glfwdoctype}[1][0]{Reference Manual}
+\newcommand{\glfwapiver}[1][0]{2.6}
+
+% Common document settings and macros
+\input{glfwdoc.sty}
+
+% PDF specific document settings
+\hypersetup{pdftitle={GLFW Reference Manual}}
+\hypersetup{pdfauthor={Marcus Geelnard}}
+\hypersetup{pdfkeywords={GLFW,OpenGL,reference,manual}}
+
+
+%-------------------------------------------------------------------------
+% Document body
+%-------------------------------------------------------------------------
+
+\begin{document}
+
+\pagestyle{plain}
+
+% Title page
+\glfwmaketitle
+
+% Summary, trademarks and table of contents
+\pagenumbering{roman}
+\setcounter{page}{1}
+
+%-------------------------------------------------------------------------
+% Summary and Trademarks
+%-------------------------------------------------------------------------
+\chapter*{Summary}
+
+This document is primarily a function reference manual for the \GLFW\ API.
+For a description of how to use \GLFW\ you should refer to the
+\textit{GLFW Users Guide}.
+\vspace{10cm}
+
+\large
+Trademarks
+
+\small
+OpenGL and IRIX are registered trademarks of Silicon Graphics, Inc.\linebreak
+Microsoft and Windows are registered trademarks of Microsoft Corporation.\linebreak
+Mac OS is a registered trademark of Apple Computer, Inc.\linebreak
+Linux is a registered trademark of Linus Torvalds.\linebreak
+FreeBSD is a registered trademark of Wind River Systems, Inc.\linebreak
+Solaris is a trademark of Sun Microsystems, Inc.\linebreak
+UNIX is a registered trademark of The Open Group.\linebreak
+X Window System is a trademark of The Open Group.\linebreak
+POSIX is a trademark of IEEE.\linebreak
+Truevision, TARGA and TGA are registered trademarks of Truevision, Inc.\linebreak
+
+All other trademarks mentioned in this document are the property of their respective owners.
+\normalsize
+
+
+%-------------------------------------------------------------------------
+% Table of contents
+%-------------------------------------------------------------------------
+\tableofcontents
+
+%-------------------------------------------------------------------------
+% List of tables
+%-------------------------------------------------------------------------
+\listoftables
+\pagebreak
+
+
+% Document chapters starts here...
+\pagenumbering{arabic}
+\setcounter{page}{1}
+
+\pagestyle{fancy}
+
+
+%-------------------------------------------------------------------------
+% Introduction
+%-------------------------------------------------------------------------
+\chapter{Introduction}
+\thispagestyle{fancy}
+
+\GLFW\ is a portable API (Application Program Interface) that handles
+operating system specific tasks related to \OpenGL\ programming. While
+\OpenGL\ in general is portable, easy to use and often results in tidy and
+compact code, the operating system specific mechanisms that are required
+to set up and manage an \OpenGL\ window are quite the opposite. \GLFW\ tries
+to remedy this by providing the following functionality:
+
+\begin{itemize}
+\item Opening and managing an \OpenGL\ window.
+\item Keyboard, mouse and joystick input.
+\item A high precision timer.
+\item Multi threading support.
+\item Support for querying and using \OpenGL\ extensions.
+\item Image file loading support.
+\end{itemize}
+\vspace{18pt}
+
+All this functionality is implemented as a set of easy-to-use functions,
+which makes it possible to write an \OpenGL\ application framework in just a
+few lines of code. The \GLFW\ API is completely operating system and
+platform independent, which makes it very simple to port \GLFW\ based \OpenGL\
+applications to a variety of platforms.
+
+Currently supported platforms are:
+\begin{itemize}
+\item Microsoft Windows\textsuperscript{\textregistered} 95/98/ME/NT/2000/XP/Vista.
+\item Unix\textsuperscript{\textregistered} or Unix�-like systems running the
+X Window System\texttrademark, e.g. Linux\textsuperscript{\textregistered},
+IRIX\textsuperscript{\textregistered}, FreeBSD\textsuperscript{\textregistered},
+Solaris\texttrademark, QNX\textsuperscript{\textregistered} and
+Mac OS\textsuperscript{\textregistered} X.
+\item Mac OS\textsuperscript{\textregistered} X (Carbon)\footnote{Support for joysticks missing at the time of writing.}
+\end{itemize}
+
+
+
+%-------------------------------------------------------------------------
+% GLFW Operation
+%-------------------------------------------------------------------------
+\chapter{GLFW Operation Overview}
+\thispagestyle{fancy}
+
+
+%-------------------------------------------------------------------------
+\section{The GLFW Window}
+\GLFW\ only supports one opened window at a time. The window can be either
+a normal desktop window or a fullscreen window. The latter is completely
+undecorated, without window borders, and covers the entire monitor. With
+a fullscreen window, it is also possible to select which video mode to use.
+
+When a window is opened, an \OpenGL\ rendering context is created and
+attached to the entire client area of the window. When the window is closed,
+the \OpenGL\ rendering context is detached and destroyed.
+
+Through a window it is possible to receive user input in the form of
+keyboard and mouse input. User input is exposed through the \GLFW\ API via
+callback functions. There are different callback functions for dealing with
+different kinds of user input. Also, \GLFW\ stores most user input as
+internal state that can be queried through different \GLFW\ API functions
+(for instance it is possible to query the position of the mouse cursor
+with the \textbf{glfwGetMousePos} function).
+
+As for user input, it is possible to receive information about window
+state changes, such as window resize or close events, through callback
+functions. It is also possible to query different kinds of window
+information through different \GLFW\ API functions.
+
+
+%-------------------------------------------------------------------------
+\section{The GLFW Event Loop}
+The \GLFW\ event loop is an open loop, which means that it is up to the
+programmer to design the loop. Events are processed by calling specific
+\GLFW\ functions, which in turn query the system for new input and window
+events, and reports these events back to the program through callback
+functions.
+
+The programmer decides when to call the event processing functions, and
+when to abort the event loop.
+
+In pseudo language, a typical event loop might look like this:
+
+\begin{lstlisting}
+  repeat until window is closed
+  {
+    poll events
+    draw OpenGL graphics
+  }
+\end{lstlisting}
+
+There are two ways to handle events in \GLFW :
+
+\begin{itemize}
+  \item Block the event loop while waiting for new events.
+  \item Poll for new events, and continue the loop regardless if there are
+        any new events or not.
+\end{itemize}
+
+The first method is useful for interactive applications that do not
+need to refresh the \OpenGL\ display unless the user interacts with the
+application through user input. Typical applications are CAD software
+and other kinds of editors.
+
+The second method is useful for applications that need to refresh the
+\OpenGL\ display constantly, regardless of user input, such as games,
+demos, 3D animations, screen savers and so on.
+
+
+%-------------------------------------------------------------------------
+\section{Callback Functions}
+Using callback functions can be a good method for receiving up to date
+information about window state and user input. When a window has been
+opened, it is possible to register custom callback functions that will
+be called when certain events occur.
+
+Callback functions are called from any of the event polling functions
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers}.
+
+Callback functions should \emph{only} be used to gather information. Since
+the callback functions are called from within the internal \GLFW\ event
+polling loops, they should not call any \GLFW\ functions that might
+result in considerable \GLFW\ state changes, nor stall the event polling
+loop for a lengthy period of time.
+
+In other words, most or all \OpenGL\ rendering should be called from the
+main application event loop, not from any of the \GLFW\ callback
+functions. Also, the only \GLFW\ functions that may be safely called from
+callback functions are the different Get functions (e.g.
+\textbf{glfwGetKey}, \textbf{glfwGetTime}, \textbf{glfwGetWindowParam}
+etc).
+
+
+%-------------------------------------------------------------------------
+\section{Threads}
+\GLFW\ has functions for creating threads, which means that it is possible
+to make multi threaded applications with \GLFW . The thread that calls
+glfwInit becomes the main thread, and it is recommended that all
+\GLFW\ and \OpenGL\ functions are called from the main thread. Additional
+threads should primarily be used for CPU heavy tasks or for managing
+other resources, such as file or sound I/O.
+
+It should be noted that the current implementation of \GLFW\ is not thread
+safe, so you should never call \GLFW\ functions from different threads.
+\footnote{Of course, all thread managing functions are thread safe.}
+
+
+%-------------------------------------------------------------------------
+% Function Reference
+%-------------------------------------------------------------------------
+\chapter{Function Reference}
+\thispagestyle{fancy}
+
+%-------------------------------------------------------------------------
+\section{GLFW Initialization and Termination}
+Before any \GLFW\ functions can be used, \GLFW\ must be initialized to
+ensure proper functionality, and before a program terminates, \GLFW\ has to
+be terminated in order to free up resources etc.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwInit}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwInit( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+If the function succeeds, GL\_TRUE is returned.\\
+If the function fails, GL\_FALSE is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The glfwInit function initializes \GLFW. No other \GLFW\ functions may be
+used before this function has been called.
+\end{refdescription}
+
+\begin{refnotes}
+This function may take several seconds to complete on some systems, while
+on other systems it may take only a fraction of a second to complete.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwTerminate}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwTerminate( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function terminates \GLFW. Among other things it closes the window,
+if it is opened, and kills any running threads. This function must be
+called before a program exits.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetVersion}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwGetVersion( int *major, int *minor, int *rev )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{major}]\ \\
+  Pointer to an integer that will hold the major version number.
+\item [\textit{minor}]\ \\
+  Pointer to an integer that will hold the minor version number.
+\item [\textit{rev}]\ \\
+  Pointer to an integer that will hold the revision.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the major and minor version numbers and the revision
+for the currently linked \GLFW\ library.
+\end{refreturn}
+
+\begin{refdescription}
+The function returns the \GLFW\ library version.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Window Handling}
+The main functionality of \GLFW\ is to provide a simple interface to
+\OpenGL\ window management. \GLFW\ can open one window, which can be
+either a normal desktop window or a fullscreen window.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwOpenWindow}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwOpenWindow( int width, int height, int redbits,
+    int greenbits, int bluebits, int alphabits, int depthbits,
+    int stencilbits, int mode )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{width}]\ \\
+  The width of the window. If \textit{width} is zero, it will be
+  calculated as ${width=\frac{4}{3}height}$, if \textit{height} is not
+  zero. If both \textit{width} and \textit{height} are zero, then
+  \textit{width} will be set to 640.
+\item [\textit{hieght}]\ \\
+  The height of the window. If \textit{height} is zero, it will be
+  calculated as ${height=\frac{3}{4}width}$, if \textit{width} is not
+  zero. If both \textit{width} and \textit{height} are zero, then
+  \textit{height} will be set to 480.
+\item [\textit{redbits, greenbits, bluebits}]\ \\
+  The number of bits to use for each color component of the color buffer
+  (0 means default color depth). For instance, setting \textit{redbits=5,
+  greenbits=6, and bluebits=5} will generate a 16-�bit color buffer, if
+  possible.
+\item [\textit{alphabits}]\ \\
+  The number of bits to use for the alpha buffer (0 means no alpha
+  buffer).
+\item [\textit{depthbits}]\ \\
+  The number of bits to use for the depth buffer (0 means no depth
+  buffer).
+\item [\textit{stencilbits}]\ \\
+  The number of bits to use for the stencil buffer (0 means no stencil
+  buffer).
+\item [\textit{mode}]\ \\
+  Selects which type of \OpenGL\ window to use. \textit{mode} can be
+  either GLFW\_WINDOW, which will generate a normal desktop window, or
+  GLFW\_FULLSCREEN, which will generate a window which covers the entire
+  screen. When GLFW\_FULLSCREEN is selected, the video mode will be
+  changed to the resolution that closest matches the \textit{width} and
+  \textit{height} parameters.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+If the function succeeds, GL\_TRUE is returned.\\
+If the function fails, GL\_FALSE is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function opens a window that best matches the parameters given to the
+function. How well the resulting window matches the desired window depends
+mostly on the available hardware and \OpenGL\ drivers. In general,
+selecting a fullscreen mode has better chances of generating a close match
+than does a normal desktop window, since \GLFW\ can freely select from all
+the available video modes. A desktop window is normally restricted to the
+video mode of the desktop.
+\end{refdescription}
+
+\begin{refnotes}
+For additional control of window properties, see
+\textbf{glfwOpenWindowHint}.
+
+In fullscreen mode the mouse cursor is hidden by default, and any system
+screensavers are prohibited from starting. In windowed mode the mouse
+cursor is visible, and screensavers are allowed to start. To change the
+visibility of the mouse cursor, use \textbf{glfwEnable} or
+\textbf{glfwDisable} with the argument GLFW\_MOUSE\_CURSOR.
+
+In order to determine the actual properties of an opened window, use
+\textbf{glfwGetWindowParam} and \textbf{glfwGetWindowSize} (or
+\textbf{glfwSetWindowSizeCallback}).
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|l|p{7.0cm}|} \hline \raggedright
+\textbf{Name}            & \textbf{Default} & \textbf{Description} \\ \hline
+GLFW\_REFRESH\_RATE      & 0                & Vertical monitor refresh rate in Hz (only used for fullscreen windows). Zero means system default.\\ \hline
+GLFW\_ACCUM\_RED\_BITS   & 0                & Number of bits for the red channel of the accumulator buffer.\\ \hline
+GLFW\_ACCUM\_GREEN\_BITS & 0                & Number of bits for the green channel of the accumulator buffer.\\ \hline
+GLFW\_ACCUM\_BLUE\_BITS  & 0                & Number of bits for the blue channel of the accumulator buffer.\\ \hline
+GLFW\_ACCUM\_ALPHA\_BITS & 0                & Number of bits for the alpha channel of the accumulator buffer.\\ \hline
+GLFW\_AUX\_BUFFERS       & 0                & Number of auxiliary buffers.\\ \hline
+GLFW\_STEREO             & GL\_FALSE        & Specify if stereo rendering should be supported (can be GL\_TRUE or GL\_FALSE).\\ \hline
+GLFW\_WINDOW\_NO\_RESIZE & GL\_FALSE        & Specify whether the window can be resized (not used for fullscreen windows).\\ \hline
+GLFW\_FSAA\_SAMPLES      & 0                & Number of samples to use for the multisampling buffer. Zero disables multisampling.\\ \hline
+\end{tabular}
+\end{center}
+\caption{Targets for \textbf{glfwOpenWindowHint}}
+\label{tab:winhints}
+\end{table}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwOpenWindowHint}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwOpenWindowHint( int target, int hint )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{target}]\ \\
+  Can be any of the constants in the table \ref{tab:winhints}.
+\item [\textit{hint}]\ \\
+  An integer giving the value of the corresponding target (see table
+  \ref{tab:winhints}).
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function sets additional properties for a window that is to be opened.
+For a hint to be registered, the function must be called before calling
+\textbf{glfwOpenWindow}. When the \textbf{glfwOpenWindow} function is
+called, any hints that were registered with the \textbf{glfwOpenWindowHint}
+function are used for setting the corresponding window properties, and
+then all hints are reset to their default values.
+\end{refdescription}
+
+\begin{refnotes}
+In order to determine the actual properties of an opened window, use
+\textbf{glfwGetWindowParam} (after the window has been opened).
+
+GLFW\_STEREO is a hard constraint. If stereo rendering is requested, but
+no stereo rendering capable pixel formats / visuals are available,
+\textbf{glfwOpenWindow} will fail.
+
+The GLFW\_REFRESH\_RATE property should be used with caution. Most
+systems have default values for monitor refresh rates that are optimal
+for the specific system. Specifying the refresh rate can override these
+settings, which can result in suboptimal operation. The monitor may be
+unable to display the resulting video signal, or in the worst case it may
+even be damaged!
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwCloseWindow}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwCloseWindow( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function closes an opened window and destroys the associated \OpenGL\
+context.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetWindowCloseCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetWindowCloseCallback( GLFWwindowclosefun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called when a user requests
+  that the window should be closed, typically by clicking the window close
+  icon (e.g. the cross in the upper right corner of a window under
+  Microsoft Windows). The function should have the following C language
+  prototype:
+
+  \texttt{int GLFWCALL functionname( void );}
+
+  Where \textit{functionname} is the name of the callback function. The
+  return value of the callback function indicates wether or not the window
+  close action should continue. If the function returns GL\_TRUE, the
+  window will be closed. If the function returns GL\_FALSE, the window
+  will not be closed.
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a window close
+event.
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Window close events are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+
+The \OpenGL\ context is still valid when this function is called.
+
+Note that the window close callback function is not called when
+\textbf{glfwCloseWindow} is called, but only when the close request
+comes from the window manager.
+
+Do \emph{not} call \textbf{glfwCloseWindow} from a window close
+callback function. Close the window by returning GL\_TRUE from the
+function.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetWindowTitle}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetWindowTitle( const char *title )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{title}]\ \\
+  Pointer to a  null terminated ISO~8859-1 (8-bit Latin~1) string that
+  holds the title of the window.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function changes the title of the opened window.
+\end{refdescription}
+
+\begin{refnotes}
+The title property of a window is often used in situations other than for
+the window title, such as the title of an application icon when it is in
+iconified state.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetWindowSize}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetWindowSize( int width, int height )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{width}]\ \\
+  Width of the window.
+\item [\textit{height}]\ \\
+  Height of the window.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function changes the size of an opened window. The \textit{width} and
+\textit{height} parameters denote the size of the client area of the
+window (i.e. excluding any window borders and decorations).
+
+If the window is in fullscreen mode, the video mode will be changed to a
+resolution that closest matches the width and height parameters (the
+number of color bits will not be changed).
+\end{refdescription}
+
+\begin{refnotes}
+The \OpenGL\ context is guaranteed to be preserved after calling
+\textbf{glfwSetWindowSize}, even if the video mode is changed.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetWindowPos}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetWindowPos( int x, int y )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{x}]\ \\
+  Horizontal position of the window, relative to the upper left corner
+  of the desktop.
+\item [\textit{y}]\ \\
+  Vertical position of the window, relative to the upper left corner of
+  the desktop.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function changes the position of an opened window. It does not have
+any effect on a fullscreen window.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetWindowSize}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwGetWindowSize( int *width, int *height )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{width}]\ \\
+  Pointer to an integer that will hold the width of the window.
+\item [\textit{height}]\ \\
+  Pointer to an integer that will hold the height of the window.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The current width and height of the opened window is returned in the
+\textit{width} and \textit{height} parameters, respectively.
+\end{refreturn}
+
+\begin{refdescription}
+The function is used for determining the size of an opened window.
+The returned values are dimensions of the client area of the window
+(i.e. excluding any window borders and decorations).
+\end{refdescription}
+
+\begin{refnotes}
+Even if the size of a fullscreen window does not change once the window
+has been opened, it does not necessarily have to be the same as the size
+that was requested using \textbf{glfwOpenWindow}. Therefor it is wise to
+use this function to determine the true size of the window once it has
+been opened.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetWindowSizeCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetWindowSizeCallback( GLFWwindowsizefun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called every time the
+  window size changes. The function should have the following C language
+  prototype:
+
+  \texttt{void GLFWCALL functionname( int width, int height );}
+
+  Where \textit{functionname} is the name of the callback function, and
+  \textit{width} and \textit{height} are the dimensions of the window
+  client area.
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a window size
+change event.
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Window size changes are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwIconifyWindow}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwIconifyWindow( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+Iconify a window. If the window is in fullscreen mode, then the desktop
+video mode will be restored.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwRestoreWindow}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwRestoreWindow( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+Restore an iconified window. If the window that is restored is in
+fullscreen mode, then the fullscreen video mode will be restored.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|p{9.5cm}|} \hline \raggedright
+\textbf{Name}            & \textbf{Description} \\ \hline
+GLFW\_OPENED             & GL\_TRUE if window is opened, else GL\_FALSE.\\ \hline
+GLFW\_ACTIVE             & GL\_TRUE if window has focus, else GL\_FALSE.\\ \hline
+GLFW\_ICONIFIED          & GL\_TRUE if window is iconified, else GL\_FALSE.\\ \hline
+GLFW\_ACCELERATED        & GL\_TRUE if window is hardware accelerated, else GL\_FALSE.\\ \hline
+GLFW\_RED\_BITS          & Number of bits for the red color component.\\ \hline
+GLFW\_GREEN\_BITS        & Number of bits for the green color component.\\ \hline
+GLFW\_BLUE\_BITS         & Number of bits for the blue color component.\\ \hline
+GLFW\_ALPHA\_BITS        & Number of bits for the alpha buffer.\\ \hline
+GLFW\_DEPTH\_BITS        & Number of bits for the depth buffer.\\ \hline
+GLFW\_STENCIL\_BITS      & Number of bits for the stencil buffer.\\ \hline
+GLFW\_REFRESH\_RATE      & Vertical monitor refresh rate in Hz. Zero indicates an unknown or a default refresh rate.\\ \hline
+GLFW\_ACCUM\_RED\_BITS   & Number of bits for the red channel of the accumulator buffer.\\ \hline
+GLFW\_ACCUM\_GREEN\_BITS & Number of bits for the green channel of the accumulator buffer.\\ \hline
+GLFW\_ACCUM\_BLUE\_BITS  & Number of bits for the blue channel of the accumulator buffer.\\ \hline
+GLFW\_ACCUM\_ALPHA\_BITS & Number of bits for the alpha channel of the accumulator buffer.\\ \hline
+GLFW\_AUX\_BUFFERS       & Number of auxiliary buffers.\\ \hline
+GLFW\_STEREO             & GL\_TRUE if stereo rendering is supported, else GL\_FALSE.\\ \hline
+GLFW\_FSAA\_SAMPLES      & Number of multisampling buffer samples. Zero indicated multisampling is disabled.\\ \hline
+GLFW\_WINDOW\_NO\_RESIZE & GL\_TRUE if the window cannot be resized, else GL\_FALSE.\\ \hline
+\end{tabular}
+\end{center}
+\caption{Window parameters for \textbf{glfwGetWindowParam}}
+\label{tab:winparams}
+\end{table}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetWindowParam}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetWindowParam( int param )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{param}]\ \\
+  A token selecting which parameter the function should return (see
+  table \ref{tab:winparams}).
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns different parameters depending on the value of
+\textit{param}. Table \ref{tab:winparams} lists valid \textit{param}
+values, and their corresponding return values.
+\end{refreturn}
+
+\begin{refdescription}
+The function is used for acquiring various properties of an opened window.
+\end{refdescription}
+
+\begin{refnotes}
+GLFW\_ACCELERATED is only supported under Windows. Other systems will
+always return GL\_TRUE. Under Windows, GLFW\_ACCELERATED means that the
+\OpenGL\ renderer is a 3rd party renderer, rather than the fallback
+Microsoft software \OpenGL\ renderer. In other words, it is not a real
+guarantee that the \OpenGL\ renderer is actually hardware accelerated.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSwapBuffers}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSwapBuffers( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function swaps the back and front color buffers of the window. If
+GLFW\_AUTO\_POLL\_EVENTS is enabled (which is the default),
+\textbf{glfwPollEvents} is called before swapping the front and back
+buffers.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSwapInterval}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSwapInterval( int interval )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{interval}]\ \\
+  Minimum number of monitor vertical retraces between each buffer swap
+  performed by \textbf{glfwSwapBuffers}. If \textit{interval} is zero,
+  buffer swaps will not be synchronized to the vertical refresh of the
+  monitor (also known as 'VSync off').
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects the minimum number of monitor vertical retraces that
+should occur between two buffer swaps. If the selected swap interval is
+one, the rate of buffer swaps will never be higher than the vertical
+refresh rate of the monitor. If the selected swap interval is zero, the
+rate of buffer swaps is only limited by the speed of the software and
+the hardware.
+\end{refdescription}
+
+\begin{refnotes}
+This function will only have an effect on hardware and drivers that
+support user selection of the swap interval.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetWindowRefreshCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetWindowRefreshCallback( GLFWwindowrefreshfun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called when the window client
+  area needs to be refreshed. The function should have the following C
+  language prototype:
+
+  \texttt{void GLFWCALL functionname( void );}
+
+  Where \textit{functionname} is the name of the callback function.
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a window refresh
+event, which occurs when any part of the window client area has been
+damaged, and needs to be repainted (for instance, if a part of the window
+that was previously occluded by another window has become visible).
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Window refresh events are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Video Modes}
+Since \GLFW\ supports video mode changes when using a fullscreen window,
+it also provides functionality for querying which video modes are
+supported on a system.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetVideoModes}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetVideoModes( GLFWvidmode *list, int maxcount )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{list}]\ \\
+  A vector of \textit{GLFWvidmode} structures, which will be filled out
+  by the function.
+\item [\textit{maxcount}]\ \\
+  Maximum number of video modes that \textit{list} vector can hold.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the number of detected video modes (this number
+will never exceed \textit{maxcount}). The \textit{list} vector is
+filled out with the video modes that are supported by the system.
+\end{refreturn}
+
+\begin{refdescription}
+The function returns a list of supported video modes. Each video mode is
+represented by a \textit{GLFWvidmode} structure, which has the following
+definition:
+
+\begin{lstlisting}
+typedef struct {
+    int Width, Height; // Video resolution
+    int RedBits;       // Number of red bits
+    int GreenBits;     // Number of green bits
+    int BlueBits;      // Number of blue bits
+} GLFWvidmode;
+\end{lstlisting}
+\end{refdescription}
+
+\begin{refnotes}
+The returned list is sorted, first by color depth ($RedBits + GreenBits +
+BlueBits$), and then by resolution ($Width \times Height$), with the
+lowest resolution, fewest bits per pixel mode first.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetDesktopMode}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwGetDesktopMode( GLFWvidmode *mode )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{mode}]\ \\
+  Pointer to a \textit{GLFWvidmode} structure, which will be filled out
+  by the function.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The \textit{GLFWvidmode} structure pointed to by \textit{mode} is filled
+out with the desktop video mode.
+\end{refreturn}
+
+\begin{refdescription}
+The function returns the desktop video mode in a \textit{GLFWvidmode}
+structure. See \textbf{glfwGetVideoModes} for a definition of the
+\textit{GLFWvidmode} structure.
+\end{refdescription}
+
+\begin{refnotes}
+The color depth of the desktop display is always reported as the number
+of bits for each individual color component (red, green and blue), even
+if the desktop is not using an RGB or RGBA color format. For instance, an
+indexed 256 color display may report \textit{RedBits} = 3,
+\textit{GreenBits} = 3 and \textit{BlueBits} = 2, which adds up to 8 bits
+in total.
+
+The desktop video mode is the video mode used by the desktop, \textit{not}
+the current video mode (which may differ from the desktop video mode if
+the \GLFW\ window is a fullscreen window).
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Input Handling}
+\GLFW\ supports three channels of user input: keyboard input, mouse input
+and joystick input.
+
+Keyboard and mouse input can be treated either as events, using callback
+functions, or as state, using functions for polling specific keyboard and
+mouse states. Regardless of which method is used, all keyboard and mouse
+input is collected using window event polling.
+
+Joystick input is asynchronous to the keyboard and mouse input, and does
+not require event polling for keeping up to date joystick information.
+Also, joystick input is independent of any window, so a window does not
+have to be opened for joystick input to be used.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwPollEvents}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwPollEvents( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function is used for polling for events, such as user input and
+window resize events. Upon calling this function, all window states,
+keyboard states and mouse states are updated. If any related callback
+functions are registered, these are called during the call to
+\textbf{glfwPollEvents}.
+\end{refdescription}
+
+\begin{refnotes}
+\textbf{glfwPollEvents} is called implicitly from \textbf{glfwSwapBuffers}
+if GLFW\_AUTO\_POLL\_EVENTS is enabled (default). Thus, if
+\textbf{glfwSwapBuffers} is called frequently, which is normally the case,
+there is no need to call \textbf{glfwPollEvents}.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwWaitEvents}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwWaitEvents( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function is used for waiting for events, such as user input and
+window resize events. Upon calling this function, the calling thread will
+be put to sleep until any event appears in the event queue. When events
+are ready, the events will be processed just as they are processed by
+\textbf{glfwPollEvents}.
+
+If there are any events in the queue when the function is called, the
+function will behave exactly like \textbf{glfwPollEvents} (i.e. process
+all messages and then return, without blocking the calling thread).
+\end{refdescription}
+
+\begin{refnotes}
+It is guaranteed that \textbf{glfwWaitEvents} will wake up on any event
+that can be processed by \textbf{glfwPollEvents}. However,
+\textbf{glfwWaitEvents} may wake up on events that are \emph{not}
+processed or reported by \textbf{glfwPollEvents} too, and the function
+may behave differently on different systems. Do no make any assumptions
+about when or why \textbf{glfwWaitEvents} will return.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|l|} \hline \raggedright
+\textbf{Name}             & \textbf{Description} \\ \hline
+GLFW\_KEY\_SPACE          & Space\\ \hline
+GLFW\_KEY\_ESC            & Escape\\ \hline
+GLFW\_KEY\_F\textit{n}    & Function key \textit{n} (\textit{n} can be in the range 1..25)\\ \hline
+GLFW\_KEY\_UP             & Cursor up\\ \hline
+GLFW\_KEY\_DOWN           & Cursor down\\ \hline
+GLFW\_KEY\_LEFT           & Cursor left\\ \hline
+GLFW\_KEY\_RIGHT          & Cursor right\\ \hline
+GLFW\_KEY\_LSHIFT         & Left shift key\\ \hline
+GLFW\_KEY\_RSHIFT         & Right shift key\\ \hline
+GLFW\_KEY\_LCTRL          & Left control key\\ \hline
+GLFW\_KEY\_RCTRL          & Right control key\\ \hline
+GLFW\_KEY\_LALT           & Left alternate function key\\ \hline
+GLFW\_KEY\_RALT           & Right alternate function key\\ \hline
+GLFW\_KEY\_TAB            & Tabulator\\ \hline
+GLFW\_KEY\_ENTER          & Enter\\ \hline
+GLFW\_KEY\_BACKSPACE      & Backspace\\ \hline
+GLFW\_KEY\_INSERT         & Insert\\ \hline
+GLFW\_KEY\_DEL            & Delete\\ \hline
+GLFW\_KEY\_PAGEUP         & Page up\\ \hline
+GLFW\_KEY\_PAGEDOWN       & Page down\\ \hline
+GLFW\_KEY\_HOME           & Home\\ \hline
+GLFW\_KEY\_END            & End\\ \hline
+GLFW\_KEY\_KP\_\textit{n} & Keypad numeric key \textit{n} (\textit{n} can be in the range 0..9)\\ \hline
+GLFW\_KEY\_KP\_DIVIDE     & Keypad divide ($\div$)\\ \hline
+GLFW\_KEY\_KP\_MULTIPLY   & Keypad multiply ($\times$)\\ \hline
+GLFW\_KEY\_KP\_SUBTRACT   & Keypad subtract ($-$)\\ \hline
+GLFW\_KEY\_KP\_ADD        & Keypad add ($+$)\\ \hline
+GLFW\_KEY\_KP\_DECIMAL    & Keypad decimal (. or ,)\\ \hline
+GLFW\_KEY\_KP\_EQUAL      & Keypad equal (=)\\ \hline
+GLFW\_KEY\_KP\_ENTER      & Keypad enter\\ \hline
+\end{tabular}
+\end{center}
+\caption{Special key identifiers}
+\label{tab:keys}
+\end{table}
+
+
+%-------------------------------------------------------------------------
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|l|} \hline \raggedright
+\textbf{Name}               & \textbf{Description} \\ \hline
+GLFW\_MOUSE\_BUTTON\_LEFT   & Left mouse button (button 1) \\ \hline
+GLFW\_MOUSE\_BUTTON\_RIGHT  & Right mouse button (button 2) \\ \hline
+GLFW\_MOUSE\_BUTTON\_MIDDLE & Middle mouse button (button 3) \\ \hline
+GLFW\_MOUSE\_BUTTON\_\textit{n} & Mouse button \textit{n} (\textit{n} can be in the range 1..8)\\ \hline
+\end{tabular}
+\end{center}
+\caption{Valid mouse button identifiers}
+\label{tab:mousebuttons}
+\end{table}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetKey}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetKey( int key )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{key}]\ \\
+  A keyboard key identifier, which can be either an uppercase printable
+  ISO~8859-1 (Latin~1) character (e.g. 'A', '3' or '.'), or a special key
+  identifier. Table \ref{tab:keys} lists valid special key identifiers.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GLFW\_PRESS if the key is held down, or GLFW\_RELEASE
+if the key is not held down.
+\end{refreturn}
+
+\begin{refdescription}
+The function queries the current state of a specific keyboard key. The
+physical location of each key depends on the system keyboard layout
+setting.
+\end{refdescription}
+
+\begin{refnotes}
+The constant GLFW\_KEY\_SPACE is equal to 32, which is the ISO~8859-1 code
+for space.
+
+Not all key codes are supported on all systems. Also, while some keys are
+available on some keyboard layouts, they may not be available on other
+keyboard layouts.
+
+For systems that do not distinguish between left and right versions of
+modifier keys (shift, alt and control), the left version is used (e.g.
+GLFW\_KEY\_LSHIFT).
+
+A window must be opened for the function to have any effect, and
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} must be called before any keyboard events are
+recorded and reported by \textbf{glfwGetKey}.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetMouseButton}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetMouseButton( int button )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{button}]\ \\
+  A mouse button identifier, which can be one of the mouse button
+  identifiers listed in table \ref{tab:mousebuttons}.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GLFW\_PRESS if the mouse button is held down, or
+GLFW\_RELEASE if the mouse button is not held down.
+\end{refreturn}
+
+\begin{refdescription}
+The function queries the current state of a specific mouse button.
+\end{refdescription}
+
+\begin{refnotes}
+A window must be opened for the function to have any effect, and
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} must be called before any mouse button events
+are recorded and reported by \textbf{glfwGetMouseButton}.
+
+GLFW\_MOUSE\_BUTTON\_LEFT is equal to GLFW\_MOUSE\_BUTTON\_1.
+GLFW\_MOUSE\_BUTTON\_RIGHT is equal to GLFW\_MOUSE\_BUTTON\_2.
+GLFW\_MOUSE\_BUTTON\_MIDDLE is equal to GLFW\_MOUSE\_BUTTON\_3.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetMousePos}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwGetMousePos( int *xpos, int *ypos )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{xpos}]\ \\
+  Pointer to an integer that will be filled out with the horizontal
+  position of the mouse.
+\item [\textit{ypos}]\ \\
+  Pointer to an integer that will be filled out with the vertical
+  position of the mouse.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the current mouse position in \textit{xpos} and
+\textit{ypos}.
+\end{refreturn}
+
+\begin{refdescription}
+The function returns the current mouse position. If the cursor is not
+hidden, the mouse position is the cursor position, relative to the upper
+left corner of the window and limited to the client area of the window.
+If the cursor is hidden, the mouse position is a virtual absolute
+position, not limited to any boundaries except to those implied by the
+maximum number that can be represented by a signed integer (normally
+-2147483648 to +2147483647).
+\end{refdescription}
+
+\begin{refnotes}
+A window must be opened for the function to have any effect, and
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} must be called before any mouse movements are
+recorded and reported by \textbf{glfwGetMousePos}.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetMousePos}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetMousePos( int xpos, int ypos )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{xpos}]\ \\
+  Horizontal position of the mouse.
+\item [\textit{ypos}]\ \\
+  Vertical position of the mouse.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function changes the position of the mouse. If the cursor is
+visible (not disabled), the cursor will be moved to the specified
+position, relative to the upper left corner of the window client area.
+If the cursor is hidden (disabled), only the mouse position that is
+reported by \GLFW\ is changed.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetMouseWheel}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetMouseWheel( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the current mouse wheel position.
+\end{refreturn}
+
+\begin{refdescription}
+The function returns the current mouse wheel position. The mouse wheel can
+be thought of as a third mouse axis, which is available as a separate
+wheel or up/down stick on some mice.
+\end{refdescription}
+
+\begin{refnotes}
+A window must be opened for the function to have any effect, and
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} must be called before any mouse wheel movements
+are recorded and reported by \textbf{glfwGetMouseWheel}.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetMouseWheel}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetMouseWheel( int pos )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{pos}]\ \\
+  Position of the mouse wheel.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function changes the position of the mouse wheel.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetKeyCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetKeyCallback( GLFWkeyfun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called every time a key is
+  pressed or released. The function should have the following C language
+  prototype:
+
+  \texttt{void GLFWCALL functionname( int key, int action );}
+
+  Where \textit{functionname} is the name of the callback function,
+  \textit{key} is a key identifier, which is an uppercase printable
+  ISO~8859-1 character or a special key identifier (see  table
+  \ref{tab:keys}), and \textit{action} is either GLFW\_PRESS or
+  GLFW\_RELEASE.
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a keyboard key
+event. The callback function is called every time the state of a single
+key is changed (from released to pressed or vice versa). The reported keys
+are unaffected by any modifiers (such as shift or alt).
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Keyboard events are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetCharCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetCharCallback( GLFWcharfun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called every time a
+  printable character is generated by the keyboard. The function should
+  have the following C language prototype:
+
+  \texttt{void GLFWCALL functionname( int character, int action );}
+
+  Where \textit{functionname} is the name of the callback function,
+  \textit{character} is a Unicode (ISO~10646) character, and
+  \textit{action} is either GLFW\_PRESS or GLFW\_RELEASE.
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a keyboard character
+event. The callback function is called every time a key that results in a
+printable Unicode character is pressed or released. Characters are
+affected by modifiers (such as shift or alt).
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Character events are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+
+Control characters, such as tab and carriage return, are not reported to
+the character callback function, since they are not part of the Unicode
+character set. Use the key callback function for such events (see
+\textbf{glfwSetKeyCallback}).
+
+The Unicode character set supports character codes above 255, so never
+cast a Unicode character to an eight bit data type (e.g. the C language
+'char' type) without first checking that the character code is less than
+256. Also note that Unicode character codes 0 to 255 are equal to
+ISO~8859-1 (Latin~1).
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetMouseButtonCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetMouseButtonCallback( GLFWmousebuttonfun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called every time a mouse
+  button is pressed or released. The function should have the following C
+  language prototype:
+
+  \texttt{void GLFWCALL functionname( int button, int action );}
+
+  Where \textit{functionname} is the name of the callback function,
+  \textit{button} is a mouse button identifier (see table
+  \ref{tab:mousebuttons} on page \pageref{tab:mousebuttons}), and
+  \textit{action} is either GLFW\_PRESS or GLFW\_RELEASE.
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a mouse button
+event.
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Mouse button events are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+
+GLFW\_MOUSE\_BUTTON\_LEFT is equal to GLFW\_MOUSE\_BUTTON\_1.
+GLFW\_MOUSE\_BUTTON\_RIGHT is equal to GLFW\_MOUSE\_BUTTON\_2.
+GLFW\_MOUSE\_BUTTON\_MIDDLE is equal to GLFW\_MOUSE\_BUTTON\_3.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetMousePosCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetMousePosCallback( GLFWmouseposfun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called every time the mouse
+  is moved. The function should have the following C language prototype:
+
+  \texttt{void GLFWCALL functionname( int x, int y );}
+
+  Where \textit{functionname} is the name of the callback function, and
+  \textit{x} and \textit{y} are the mouse coordinates (see
+  \textbf{glfwGetMousePos} for more information on mouse coordinates).
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a mouse motion event.
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Mouse motion events are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetMouseWheelCallback}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetMouseWheelCallback( GLFWmousewheelfun cbfun )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cbfun}]\ \\
+  Pointer to a callback function that will be called every time the mouse
+  wheel is moved. The function should have the following C language
+  prototype:
+
+  \texttt{void GLFWCALL functionname( int pos );}
+
+  Where \textit{functionname} is the name of the callback function, and
+  \textit{pos} is the mouse wheel position.
+
+  If \textit{cbfun} is NULL, any previously selected callback function
+  will be deselected.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function selects which function to be called upon a mouse wheel event.
+
+A window has to be opened for this function to have any effect.
+\end{refdescription}
+
+\begin{refnotes}
+Mouse wheel events are recorded continuously, but only reported when
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers} is called.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|l|}\hline \raggedright
+\textbf{Name} & \textbf{Return value}\\ \hline
+GLFW\_PRESENT & GL\_TRUE if the joystick is connected, else GL\_FALSE.\\ \hline
+GLFW\_AXES    & Number of axes supported by the joystick.\\ \hline
+GLFW\_BUTTONS & Number of buttons supported by the joystick.\\ \hline
+\end{tabular}
+\end{center}
+\caption{Joystick parameters for \textbf{glfwGetJoystickParam}}
+\label{tab:joyparams}
+\end{table}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetJoystickParam}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetJoystickParam( int joy, int param )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{joy}]\ \\
+  A joystick identifier, which should be GLFW\_JOYSTICK\_\textit{n}, where
+  \textit{n} is in the range 1 to 16.
+\item [\textit{param}]\ \\
+  A token selecting which parameter the function should return (see table
+  \ref{tab:joyparams}).
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns different parameters depending on the value of
+\textit{param}. Table \ref{tab:joyparams} lists valid \textit{param}
+values, and their corresponding return values.
+\end{refreturn}
+
+\begin{refdescription}
+The function is used for acquiring various properties of a joystick.
+\end{refdescription}
+
+\begin{refnotes}
+The joystick information is updated every time the function is called.
+
+No window has to be opened for joystick information to be valid.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetJoystickPos}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetJoystickPos( int joy, float *pos, int numaxes )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{joy}]\ \\
+  A joystick identifier, which should be GLFW\_JOYSTICK\_\textit{n}, where
+  \textit{n} is in the range 1 to 16.
+\item [\textit{pos}]\ \\
+  An array that will hold the positional values for all requested axes.
+\item [\textit{numaxes}]\ \\
+  Specifies how many axes should be returned.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the number of actually returned axes. This is the
+minimum of \textit{numaxes} and the number of axes supported by the
+joystick. If the joystick is not supported or connected, the function will
+return 0 (zero).
+\end{refreturn}
+
+\begin{refdescription}
+The function queries the current position of one or more axes of a
+joystick. The positional values are returned in an array, where the first
+element represents the first axis of the joystick (normally the X axis).
+Each position is in the range -1.0 to 1.0. Where applicable, the positive
+direction of an axis is right, forward or up, and the negative direction
+is left, back or down.
+
+If \textit{numaxes} exceeds the number of axes supported by the joystick,
+or if the joystick is not available, the unused elements in the
+\textit{pos} array will be set to 0.0 (zero).
+\end{refdescription}
+
+\begin{refnotes}
+The joystick state is updated every time the function is called, so there
+is no need to call \textbf{glfwPollEvents} or \textbf{glfwWaitEvents} for
+joystick state to be updated.
+
+Use \textbf{glfwGetJoystickParam} to retrieve joystick capabilities, such
+as joystick availability and number of supported axes.
+
+No window has to be opened for joystick input to be valid.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetJoystickButtons}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetJoystickButtons( int joy, unsigned char *buttons,
+                            int numbuttons )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{joy}]\ \\
+  A joystick identifier, which should be GLFW\_JOYSTICK\_\textit{n}, where
+  \textit{n} is in the range 1 to 16.
+\item [\textit{buttons}]\ \\
+  An array that will hold the button states for all requested buttons.
+\item [\textit{numbuttons}]\ \\
+  Specifies how many buttons should be returned.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the number of actually returned buttons. This is the
+minimum of \textit{numbuttons} and the number of buttons supported by the
+joystick. If the joystick is not supported or connected, the function will
+return 0 (zero).
+\end{refreturn}
+
+\begin{refdescription}
+The function queries the current state of one or more buttons of a
+joystick. The button states are returned in an array, where the first
+element represents the first button of the joystick. Each state can be
+either GLFW\_PRESS or GLFW\_RELEASE.
+
+If \textit{numbuttons} exceeds the number of buttons supported by the
+joystick, or if the joystick is not available, the unused elements in the
+\textit{buttons} array will be set to GLFW\_RELEASE.
+\end{refdescription}
+
+\begin{refnotes}
+The joystick state is updated every time the function is called, so there
+is no need to call \textbf{glfwPollEvents} or \textbf{glfwWaitEvents} for
+joystick state to be updated.
+
+Use \textbf{glfwGetJoystickParam} to retrieve joystick capabilities, such
+as joystick availability and number of supported buttons.
+
+No window has to be opened for joystick input to be valid.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Timing}
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetTime}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+double glfwGetTime( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the value of the high precision timer. The time is
+measured in seconds, and is returned as a double precision floating point
+value.
+\end{refreturn}
+
+\begin{refdescription}
+The function returns the state of a high precision timer. Unless the timer
+has been set by the \textbf{glfwSetTime} function, the time is measured as
+the number of seconds that have passed since \textbf{glfwInit} was called.
+\end{refdescription}
+
+\begin{refnotes}
+The resolution of the timer depends on which system the program is running
+on. The worst case resolution is somewhere in the order of $10~ms$, while
+for most systems the resolution should be better than $1~\mu s$.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSetTime}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSetTime( double time )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{time}]\ \\
+  Time (in seconds) that the timer should be set to.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function sets the current time of the high precision timer to the
+specified time. Subsequent calls to \textbf{glfwGetTime} will be relative
+to this time. The time is given in seconds.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSleep}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSleep( double time )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{time}]\ \\
+  Time, in seconds, to sleep.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function puts the calling thread to sleep for the requested period of
+time. Only the calling thread is put to sleep. Other threads within the
+same process can still execute.
+\end{refdescription}
+
+\begin{refnotes}
+There is usually a system dependent minimum time for which it is possible
+to sleep. This time is generally in the range 1~$ms$ to 20~$ms$, depending
+on thread sheduling time slot intervals etc. Using a shorter time as a
+parameter to \textbf{glfwSleep} can give one of two results: either the
+thread will sleep for the minimum possible sleep time, or the thread will
+not sleep at all (\textbf{glfwSleep} returns immediately). The latter
+should only happen when very short sleep times are specified, if at all.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Image and Texture Loading}
+In order to aid loading of image data into textures, \GLFW\ has basic support
+for loading images from files and memory buffers.
+
+
+%-------------------------------------------------------------------------
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|p{9.0cm}|} \hline \raggedright
+\textbf{Name}          & \textbf{Description}\\ \hline
+GLFW\_NO\_RESCALE\_BIT & Do not rescale image to closest $2^m\times2^n$ resolution\\ \hline
+GLFW\_ORIGIN\_UL\_BIT  & Specifies that the origin of the \textit{loaded} image should be in the upper left corner (default is the lower left corner)\\ \hline
+GLFW\_ALPHA\_MAP\_BIT  & Treat single component images as alpha maps rather than luminance maps\\ \hline
+\end{tabular}
+\end{center}
+\caption{Flags for functions loading image data into textures}
+\label{tab:rdimgflags}
+\end{table}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwReadImage}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwReadImage( const char *name, GLFWimage *img, int flags )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{name}]\ \\
+  A null terminated ISO~8859-1 string holding the name of the file that
+  should be read.
+\item [\textit{img}]\ \\
+  Pointer to a GLFWimage struct, which will hold the information about
+  the loaded image (if the read was successful).
+\item [\textit{flags}]\ \\
+  Flags for controlling the image reading process. Valid flags are listed
+  in table \ref{tab:rdimgflags}
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GL\_TRUE if the image was loaded successfully.
+Otherwise GL\_FALSE is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function reads an image from the file specified by the parameter
+\textit{name} and returns the image information and data in a GLFWimage
+structure, which has the following definition:
+
+\begin{lstlisting}
+typedef struct {
+    int Width, Height;    // Image dimensions
+    int Format;           // OpenGL pixel format
+    int BytesPerPixel;    // Number of bytes per pixel
+    unsigned char *Data;  // Pointer to pixel data
+} GLFWimage;
+\end{lstlisting}
+
+\textit{Width} and \textit{Height} give the dimensions of the image.
+\textit{Format} specifies an \OpenGL\ pixel format, which can be
+GL\_LUMINANCE or GL\_ALPHA (for gray scale images), GL\_RGB or GL\_RGBA.
+\textit{BytesPerPixel} specifies the number of bytes per pixel.
+\textit{Data} is a pointer to the actual pixel data.
+
+By default the read image is rescaled to the nearest larger $2^m\times2^n$
+resolution using bilinear interpolation, if necessary, which is useful if
+the image is to be used as an \OpenGL\ texture. This behavior can be
+disabled by setting the GLFW\_NO\_RESCALE\_BIT flag.
+
+Unless the flag GLFW\_ORIGIN\_UL\_BIT is set, the first pixel in
+\textit{img->Data} is the lower left corner of the image. If the flag
+GLFW\_ORIGIN\_UL\_BIT is set, however, the first pixel is the upper left
+corner.
+
+For single component images (i.e. gray scale), \textit{Format} is set
+to GL\_ALPHA if the flag GLFW\_ALPHA\_MAP\_BIT flag is set, otherwise
+\textit{Format} is set to GL\_LUMINANCE.
+\end{refdescription}
+
+\begin{refnotes}
+\textbf{glfwReadImage} supports the Truevision Targa version 1 file format
+(.TGA). Supported pixel formats are: 8-bit gray scale, 8-bit paletted
+(24/32-bit color), 24-bit true color and 32-bit true color + alpha.
+
+Paletted images are translated into true color or true color + alpha pixel
+formats.
+
+Please note that \OpenGL~1.0 does not support single component alpha maps,
+so do not use images with Format = GL\_ALPHA directly as textures under
+\OpenGL~1.0.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwReadMemoryImage}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwReadMemoryImage( const void *data, long size, GLFWimage *img, int flags )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{data}]\ \\
+  The memory buffer holding the contents of the file that should be read.
+\item [\textit{size}]\ \\
+  The size, in bytes, of the memory buffer.
+\item [\textit{img}]\ \\
+  Pointer to a GLFWimage struct, which will hold the information about
+  the loaded image (if the read was successful).
+\item [\textit{flags}]\ \\
+  Flags for controlling the image reading process. Valid flags are listed
+  in table \ref{tab:rdimgflags}
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GL\_TRUE if the image was loaded successfully.
+Otherwise GL\_FALSE is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function reads an image from the memory buffer specified by the parameter
+\textit{data} and returns the image information and data in a GLFWimage
+structure, which has the following definition:
+
+\begin{lstlisting}
+typedef struct {
+    int Width, Height;    // Image dimensions
+    int Format;           // OpenGL pixel format
+    int BytesPerPixel;    // Number of bytes per pixel
+    unsigned char *Data;  // Pointer to pixel data
+} GLFWimage;
+\end{lstlisting}
+
+\textit{Width} and \textit{Height} give the dimensions of the image.
+\textit{Format} specifies an \OpenGL\ pixel format, which can be
+GL\_LUMINANCE or GL\_ALPHA (for gray scale images), GL\_RGB or GL\_RGBA.
+\textit{BytesPerPixel} specifies the number of bytes per pixel.
+\textit{Data} is a pointer to the actual pixel data.
+
+By default the read image is rescaled to the nearest larger $2^m\times2^n$
+resolution using bilinear interpolation, if necessary, which is useful if
+the image is to be used as an \OpenGL\ texture. This behavior can be
+disabled by setting the GLFW\_NO\_RESCALE\_BIT flag.
+
+Unless the flag GLFW\_ORIGIN\_UL\_BIT is set, the first pixel in
+\textit{img->Data} is the lower left corner of the image. If the flag
+GLFW\_ORIGIN\_UL\_BIT is set, however, the first pixel is the upper left
+corner.
+
+For single component images (i.e. gray scale), \textit{Format} is set
+to GL\_ALPHA if the flag GLFW\_ALPHA\_MAP\_BIT flag is set, otherwise
+\textit{Format} is set to GL\_LUMINANCE.
+\end{refdescription}
+
+\begin{refnotes}
+\textbf{glfwReadMemoryImage} supports the Truevision Targa version 1 file
+format (.TGA). Supported pixel formats are: 8-bit gray scale, 8-bit paletted
+(24/32-bit color), 24-bit true color and 32-bit true color + alpha.
+
+Paletted images are translated into true color or true color + alpha pixel
+formats.
+
+Please note that \OpenGL~1.0 does not support single component alpha maps,
+so do not use images with Format = GL\_ALPHA directly as textures under
+\OpenGL~1.0.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwFreeImage}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwFreeImage( GLFWimage *img )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{img}]\ \\
+  Pointer to a GLFWimage struct.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function frees any memory occupied by a loaded image, and clears all
+the fields of the GLFWimage struct. Any image that has been loaded by the
+\textbf{glfwReadImage} function should be deallocated using this function,
+once the image is not needed anymore.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|p{9.0cm}|} \hline \raggedright
+\textbf{Name}             & \textbf{Description}\\ \hline
+GLFW\_BUILD\_MIPMAPS\_BIT & Automatically build and upload all mipmap levels\\ \hline
+GLFW\_ORIGIN\_UL\_BIT     & Specifies that the origin of the \textit{loaded} image should be in the upper left corner (default is the lower left corner)\\ \hline
+GLFW\_ALPHA\_MAP\_BIT     & Treat single component images as alpha maps rather than luminance maps\\ \hline
+\end{tabular}
+\end{center}
+\caption{Flags for \textbf{glfwLoadTexture2D}}
+\label{tab:ldtexflags}
+\end{table}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwLoadTexture2D}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwLoadTexture2D( const char *name, int flags )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{name}]\ \\
+  An ISO~8859-1 string holding the name of the file that should be loaded.
+\item [\textit{flags}]\ \\
+  Flags for controlling the texture loading process. Valid flags are
+  listed in table \ref{tab:ldtexflags}.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GL\_TRUE if the texture was loaded successfully.
+Otherwise GL\_FALSE is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function reads an image from the file specified by the parameter
+\textit{name} and uploads the image to \OpenGL\ texture memory (using the
+\textbf{glTexImage2D} function).
+
+If the GLFW\_BUILD\_MIPMAPS\_BIT flag is set, all mipmap levels for the
+loaded texture are generated and uploaded to texture memory.
+
+Unless the flag GLFW\_ORIGIN\_UL\_BIT is set, the origin of the texture
+is the lower left corner of the loaded image. If the flag
+GLFW\_ORIGIN\_UL\_BIT is set, however, the first pixel is the upper left
+corner.
+
+For single component images (i.e. gray scale), the texture is uploaded as
+an alpha mask if the flag GLFW\_ALPHA\_MAP\_BIT flag is set, otherwise
+it is uploaded as a luminance texture.
+\end{refdescription}
+
+\begin{refnotes}
+\textbf{glfwLoadTexture2D} supports the Truevision Targa version 1 file
+format (.TGA). Supported pixel formats are: 8-bit gray scale, 8-bit
+paletted (24/32-bit color), 24-bit true color and 32-bit true color +
+alpha.
+
+Paletted images are translated into true color or true color + alpha pixel
+formats.
+
+The read texture is always rescaled to the nearest larger $2^m\times2^n$
+resolution using bilinear interpolation, if necessary, since \OpenGL\
+requires textures to have a $2^m\times2^n$ resolution.
+
+If the GL\_SGIS\_generate\_mipmap extension, which is usually hardware
+accelerated, is supported by the \OpenGL\ implementation it will be used
+for mipmap generation. Otherwise the mipmaps will be generated by \GLFW\
+in software.
+
+Since \OpenGL~1.0 does not support single component alpha maps, alpha map
+textures are converted to RGBA format under \OpenGL~1.0 when the
+GLFW\_ALPHA\_MAP\_BIT flag is set and the loaded texture is a single
+component texture. The red, green and blue components are set to 1.0.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwLoadMemoryTexture2D}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwLoadMemoryTexture2D( const void *data, long size, int flags )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{data}]\ \\
+  The memory buffer holding the contents of the file that should be loaded.
+\item [\textit{size}]\ \\
+  The size, in bytes, of the memory buffer.
+\item [\textit{flags}]\ \\
+  Flags for controlling the texture loading process. Valid flags are
+  listed in table \ref{tab:ldtexflags}.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GL\_TRUE if the texture was loaded successfully.
+Otherwise GL\_FALSE is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function reads an image from the memory buffer specified by the parameter
+\textit{data} and uploads the image to \OpenGL\ texture memory (using the
+\textbf{glTexImage2D} function).
+
+If the GLFW\_BUILD\_MIPMAPS\_BIT flag is set, all mipmap levels for the
+loaded texture are generated and uploaded to texture memory.
+
+Unless the flag GLFW\_ORIGIN\_UL\_BIT is set, the origin of the texture
+is the lower left corner of the loaded image. If the flag
+GLFW\_ORIGIN\_UL\_BIT is set, however, the first pixel is the upper left
+corner.
+
+For single component images (i.e. gray scale), the texture is uploaded as
+an alpha mask if the flag GLFW\_ALPHA\_MAP\_BIT flag is set, otherwise
+it is uploaded as a luminance texture.
+\end{refdescription}
+
+\begin{refnotes}
+\textbf{glfwLoadMemoryTexture2D} supports the Truevision Targa version 1 file
+format (.TGA). Supported pixel formats are: 8-bit gray scale, 8-bit
+paletted (24/32-bit color), 24-bit true color and 32-bit true color +
+alpha.
+
+Paletted images are translated into true color or true color + alpha pixel
+formats.
+
+The read texture is always rescaled to the nearest larger $2^m\times2^n$
+resolution using bilinear interpolation, if necessary, since \OpenGL\
+requires textures to have a $2^m\times2^n$ resolution.
+
+If the GL\_SGIS\_generate\_mipmap extension, which is usually hardware
+accelerated, is supported by the \OpenGL\ implementation it will be used
+for mipmap generation. Otherwise the mipmaps will be generated by \GLFW\
+in software.
+
+Since \OpenGL~1.0 does not support single component alpha maps, alpha map
+textures are converted to RGBA format under \OpenGL~1.0 when the
+GLFW\_ALPHA\_MAP\_BIT flag is set and the loaded texture is a single
+component texture. The red, green and blue components are set to 1.0.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwLoadTextureImage2D}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwLoadTextureImage2D( GLFWimage *img, int flags )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{img}]\ \\
+  Pointer to a GLFWimage struct holding the information about
+  the image to be loaded.
+\item [\textit{flags}]\ \\
+  Flags for controlling the texture loading process. Valid flags are
+  listed in table \ref{tab:ldtexflags}.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GL\_TRUE if the texture was loaded successfully.
+Otherwise GL\_FALSE is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function uploads the image specified by the parameter \textit{img} to
+\OpenGL\ texture memory (using the \textbf{glTexImage2D} function).
+
+If the GLFW\_BUILD\_MIPMAPS\_BIT flag is set, all mipmap levels for the
+loaded texture are generated and uploaded to texture memory.
+
+Unless the flag GLFW\_ORIGIN\_UL\_BIT is set, the origin of the texture
+is the lower left corner of the loaded image. If the flag
+GLFW\_ORIGIN\_UL\_BIT is set, however, the first pixel is the upper left
+corner.
+
+For single component images (i.e. gray scale), the texture is uploaded as
+an alpha mask if the flag GLFW\_ALPHA\_MAP\_BIT flag is set, otherwise
+it is uploaded as a luminance texture.
+\end{refdescription}
+
+\begin{refnotes}
+\textbf{glfwLoadTextureImage2D} supports the Truevision Targa version 1 file
+format (.TGA). Supported pixel formats are: 8-bit gray scale, 8-bit
+paletted (24/32-bit color), 24-bit true color and 32-bit true color +
+alpha.
+
+Paletted images are translated into true color or true color + alpha pixel
+formats.
+
+The read texture is always rescaled to the nearest larger $2^m\times2^n$
+resolution using bilinear interpolation, if necessary, since \OpenGL\
+requires textures to have a $2^m\times2^n$ resolution.
+
+If the GL\_SGIS\_generate\_mipmap extension, which is usually hardware
+accelerated, is supported by the \OpenGL\ implementation it will be used
+for mipmap generation. Otherwise the mipmaps will be generated by \GLFW\
+in software.
+
+Since \OpenGL~1.0 does not support single component alpha maps, alpha map
+textures are converted to RGBA format under \OpenGL~1.0 when the
+GLFW\_ALPHA\_MAP\_BIT flag is set and the loaded texture is a single
+component texture. The red, green and blue components are set to 1.0.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{OpenGL Extension Support}
+One of the great features of \OpenGL\ is its support for extensions, which
+allow independent vendors to supply non-standard functionality in their
+\OpenGL\ implementations. Using extensions is different under different
+systems, which is why \GLFW\ has provided an operating system independent
+interface to querying and using \OpenGL\ extensions.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwExtensionSupported}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwExtensionSupported( const char *extension )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{extension}]\ \\
+  A null terminated ISO~8859-1 string containing the name of an \OpenGL\
+  extension.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GL\_TRUE if the extension is supported. Otherwise it
+returns GL\_FALSE.
+\end{refreturn}
+
+\begin{refdescription}
+The function does a string search in the list of supported \OpenGL\
+extensions to find if the specified extension is listed.
+\end{refdescription}
+
+\begin{refnotes}
+An \OpenGL\ context must be created before this function can be called
+(i.e. an \OpenGL\ window must have been opened with
+\textbf{glfwOpenWindow}).
+
+In addition to checking for \OpenGL\ extensions, \GLFW\ also checks for
+extensions in the operating system ``glue API'', such as WGL extensions
+under Windows and glX extensions under the X Window System.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetProcAddress}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void * glfwGetProcAddress( const char *procname )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{procname}]\ \\
+  A null terminated ISO~8859-1 string containing the name of an \OpenGL\
+  extension function.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the pointer to the specified \OpenGL\ function if it
+is supported, otherwise NULL is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function acquires the pointer to an \OpenGL\ extension function. Some
+(but not all) \OpenGL\ extensions define new API functions, which are
+usually not available through normal linking. It is therefore necessary to
+get access to those API functions at runtime.
+\end{refdescription}
+
+\begin{refnotes}
+An \OpenGL\ context must be created before this function can be called
+(i.e. an \OpenGL\ window must have been opened with
+\textbf{glfwOpenWindow}).
+
+Some systems do not support dynamic function pointer retrieval, in which
+case \textbf{glfwGetProcAddress} will always return NULL.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetGLVersion}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwGetGLVersion( int *major, int *minor, int *rev )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{major}]\ \\
+  Pointer to an integer that will hold the major version number.
+\item [\textit{minor}]\ \\
+  Pointer to an integer that will hold the minor version number.
+\item [\textit{rev}]\ \\
+  Pointer to an integer that will hold the revision.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the major and minor version numbers and the revision
+for the currently used \OpenGL\ implementation.
+\end{refreturn}
+
+\begin{refdescription}
+The function returns the \OpenGL\ implementation version. This is a
+convenient function that parses the version number information from the
+string returned by calling \texttt{glGetString(~GL\_VERSION~)}. The
+\OpenGL\ version information can be used to determine what functionality
+is supported by the used \OpenGL\ implementation.
+\end{refdescription}
+
+\begin{refnotes}
+An \OpenGL\ context must be created before this function can be called
+(i.e. an \OpenGL\ window must have been opened with
+\textbf{glfwOpenWindow}).
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Threads}
+A thread is a separate execution path within a process. All threads within
+a process share the same address space and resources. Threads execute in
+parallel, either virtually by means of time-sharing on a single processor,
+or truly in parallel on several processors. Even on a multi-processor
+system, time-sharing is employed in order to maximize processor
+utilization and to ensure fair scheduling. \GLFW\ provides an operating
+system independent interface to thread management.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwCreateThread}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+GLFWthread glfwCreateThread( GLFWthreadfun fun, void *arg )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{fun}]\ \\
+  A pointer to a function that acts as the entry point for the new thread.
+  The function should have the following C language prototype:
+
+  \texttt{void GLFWCALL functionname( void *arg );}
+
+  Where \textit{functionname} is the name of the thread function, and
+  \textit{arg} is the user supplied argument (see below).
+\item [\textit{arg}]\ \\
+  An arbitrary argument for the thread. \textit{arg} will be passed as the
+  argument to the thread function pointed to by \textit{fun}. For
+  instance, \textit{arg} can point to data that is to be processed by the
+  thread.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns a thread identification number if the thread was
+created successfully. This number is always positive. If the function
+fails, a negative number is returned.
+\end{refreturn}
+
+\begin{refdescription}
+The function creates a new thread, which executes within the same address
+space as the calling process. The thread entry point is specified with the
+\textit{fun} argument.
+
+Once the thread function \textit{fun} returns, the thread dies.
+\end{refdescription}
+
+\begin{refnotes}
+Even if the function returns a positive thread ID, indicating that the
+thread was created successfully, the thread may be unable to execute, for
+instance if the thread start address is not a valid thread entry point.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwDestroyThread}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwDestroyThread( GLFWthread ID )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{ID}]\ \\
+  A thread identification handle, which is returned by
+  \textbf{glfwCreateThread} or \textbf{glfwGetThreadID}.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function kills a running thread and removes it from the thread list.
+\end{refdescription}
+
+\begin{refnotes}
+This function is a very dangerous operation, which may interrupt a thread
+in the middle of an important operation, and its use is discouraged. You
+should always try to end a thread in a graceful way using thread
+communication, and use \textbf{glfwWaitThread} in order to wait for the
+thread to die.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwWaitThread}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwWaitThread( GLFWthread ID, int waitmode )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{ID}]\ \\
+  A thread identification handle, which is returned by
+  \textbf{glfwCreateThread} or \textbf{glfwGetThreadID}.
+\item [\textit{waitmode}]\ \\
+  Can be either GLFW\_WAIT or GLFW\_NOWAIT.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+The function returns GL\_TRUE if the specified thread died after the
+function was called, or the thread did not exist, in which case
+\textbf{glfwWaitThread} will return immediately regardless of
+\textit{waitmode}. The function returns GL\_FALSE if \textit{waitmode}
+is GLFW\_NOWAIT, and the specified thread exists and is still running.
+\end{refreturn}
+
+\begin{refdescription}
+If \textit{waitmode} is GLFW\_WAIT, the function waits for a thread to
+die. If \textit{waitmode} is GLFW\_NOWAIT, the function checks if a thread
+exists and returns immediately.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetThreadID}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+GLFWthread glfwGetThreadID( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+The function returns a thread identification handle for the calling
+thread.
+\end{refreturn}
+
+\begin{refdescription}
+The function determines the thread ID for the calling thread. The ID is
+the same value as was returned by \textbf{glfwCreateThread} when the
+thread was created.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Mutexes}
+Mutexes are used to securely share data between threads. A mutex object
+can only be owned by one thread at a time. If more than one thread
+requires access to a mutex object, all but one thread will be put to sleep
+until they get access to it.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwCreateMutex}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+GLFWmutex glfwCreateMutex( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+The function returns a mutex handle, or NULL if the mutex could not be
+created.
+\end{refreturn}
+
+\begin{refdescription}
+The function creates a mutex object, which can be used to control access
+to data that is shared between threads.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwDestroyMutex}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwDestroyMutex( GLFWmutex mutex )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{mutex}]\ \\
+  A mutex object handle.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function destroys a mutex object. After a mutex object has been
+destroyed, it may no longer be used by any thread.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwLockMutex}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwLockMutex( GLFWmutex mutex )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{mutex}]\ \\
+  A mutex object handle.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function will acquire a lock on the selected mutex object. If the
+mutex is already locked by another thread, the function will block the
+calling thread until it is released by the locking thread. Once the
+function returns, the calling thread has an exclusive lock on the mutex.
+To release the mutex, call \textbf{glfwUnlockMutex}.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwUnlockMutex}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwUnlockMutex( GLFWmutex mutex )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{mutex}]\ \\
+  A mutex object handle.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function releases the lock of a locked mutex object.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Condition Variables}
+Condition variables are used to synchronize threads. A thread can wait for
+a condition variable to be signaled by another thread.
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwCreateCond}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+GLFWcond glfwCreateCond( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+The function returns a condition variable handle, or NULL if the condition
+variable could not be created.
+\end{refreturn}
+
+\begin{refdescription}
+The function creates a condition variable object, which can be used to
+synchronize threads.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwDestroyCond}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwDestroyCond( GLFWcond cond )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cond}]\ \\
+  A condition variable object handle.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function destroys a condition variable object. After a condition
+variable object has been destroyed, it may no longer be used by any
+thread.
+\end{refdescription}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwWaitCond}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwWaitCond( GLFWcond cond, GLFWmutex mutex, double timeout )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cond}]\ \\
+  A condition variable object handle.
+\item [\textit{mutex}]\ \\
+  A mutex object handle.
+\item [\textit{timeout}]\ \\
+  Maximum time to wait for the condition variable. The parameter can
+  either be a positive time (in seconds), or GLFW\_INFINITY.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function atomically unlocks the mutex specified by \textit{mutex}, and
+waits for the condition variable \textit{cond} to be signaled. The thread
+execution is suspended and does not consume any CPU time until the
+condition variable is signaled or the amount of time specified by timeout
+has passed. If timeout is GLFW\_INFINITY, \textbf{glfwWaitCond} will wait
+forever for \textit{cond} to be signaled. Before returning to the calling
+thread, \textbf{glfwWaitCond} automatically re-acquires the mutex.
+\end{refdescription}
+
+\begin{refnotes}
+The mutex specified by \textit{mutex} must be locked by the calling thread
+before entrance to \textbf{glfwWaitCond}.
+
+A condition variable must always be associated with a mutex, to avoid the
+race condition where a thread prepares to wait on a condition variable and
+another thread signals the condition just before the first thread actually
+waits on it.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwSignalCond}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwSignalCond( GLFWcond cond )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cond}]\ \\
+  A condition variable object handle.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function restarts one of the threads that are waiting on the condition
+variable \textit{cond}. If no threads are waiting on \textit{cond},
+nothing happens. If several threads are waiting on \textit{cond}, exactly
+one is restarted, but it is not specified which.
+\end{refdescription}
+
+\begin{refnotes}
+When several threads are waiting for the condition variable, which thread
+is started depends on operating system scheduling rules, and may vary from
+system to system and from time to time.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwBroadcastCond}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwBroadcastCond( GLFWcond cond )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{cond}]\ \\
+  A condition variable object handle.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+The function restarts all the threads that are waiting on the condition
+variable \textit{cond}. If no threads are waiting on \textit{cond},
+nothing happens.
+\end{refdescription}
+
+\begin{refnotes}
+When several threads are waiting for the condition variable, the order in
+which threads are started depends on operating system scheduling rules,
+and may vary from system to system and from time to time.
+\end{refnotes}
+
+
+%-------------------------------------------------------------------------
+\pagebreak
+\section{Miscellaneous}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwEnable/glfwDisable}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+void glfwEnable( int token )
+void glfwDisable( int token )
+\end{lstlisting}
+
+\begin{refparameters}
+\begin{description}
+\item [\textit{token}]\ \\
+  A value specifying a feature to enable or disable. Valid tokens are
+  listed in table \ref{tab:enable}.
+\end{description}
+\end{refparameters}
+
+\begin{refreturn}
+none
+\end{refreturn}
+
+\begin{refdescription}
+\textbf{glfwEnable} is used to enable a certain feature, while
+\textbf{glfwDisable} is used to disable it. Below follows a description of
+each feature.
+\end{refdescription}
+
+
+\begin{table}[p]
+\begin{center}
+\begin{tabular}{|l|p{5.0cm}|p{3.0cm}|} \hline \raggedright
+\textbf{Name} & \textbf{Controls} & \textbf{Default}\\ \hline
+\hyperlink{lnk:autopollevents}{GLFW\_AUTO\_POLL\_EVENTS}         & Automatic event polling when \textbf{glfwSwapBuffers} is called & Enabled\\ \hline
+\hyperlink{lnk:keyrepeat}{GLFW\_KEY\_REPEAT}                     & Keyboard key repeat                                    & Disabled\\ \hline
+\hyperlink{lnk:mousecursor}{GLFW\_MOUSE\_CURSOR}                 & Mouse cursor visibility                                & Enabled in windowed mode. Disabled in fullscreen mode.\\ \hline
+\hyperlink{lnk:stickykeys}{GLFW\_STICKY\_KEYS}                   & Keyboard key ``stickiness''                            & Disabled\\ \hline
+\hyperlink{lnk:stickymousebuttons}{GLFW\_STICKY\_MOUSE\_BUTTONS} & Mouse button ``stickiness''                            & Disabled\\ \hline
+\hyperlink{lnk:systemkeys}{GLFW\_SYSTEM\_KEYS}                   & Special system key actions                             & Enabled\\ \hline
+\end{tabular}
+\end{center}
+\caption{Tokens for \textbf{glfwEnable}/\textbf{glfwDisable}}
+\label{tab:enable}
+\end{table}
+
+
+\bigskip\begin{mysamepage}\hypertarget{lnk:autopollevents}{}
+\textbf{GLFW\_AUTO\_POLL\_EVENTS}\\
+When GLFW\_AUTO\_POLL\_EVENTS is enabled, \textbf{glfwPollEvents} is
+automatically called each time that \textbf{glfwSwapBuffers} is called.
+
+When GLFW\_AUTO\_POLL\_EVENTS is disabled, calling
+\textbf{glfwSwapBuffers} will not result in a call to
+\textbf{glfwPollEvents}. This can be useful if \textbf{glfwSwapBuffers}
+needs to be called from within a callback function, since calling
+\textbf{glfwPollEvents} from a callback function is not allowed.
+\end{mysamepage}
+
+
+\bigskip\begin{mysamepage}\hypertarget{lnk:keyrepeat}{}
+\textbf{GLFW\_KEY\_REPEAT}\\
+When GLFW\_KEY\_REPEAT is enabled, the key and character callback
+functions are called repeatedly when a key is held down long enough
+(according to the system key repeat configuration).
+
+When GLFW\_KEY\_REPEAT is disabled, the key and character callback
+functions are only called once when a key is pressed (and once when it is
+released).
+\end{mysamepage}
+
+
+\bigskip\begin{mysamepage}\hypertarget{lnk:mousecursor}{}
+\textbf{GLFW\_MOUSE\_CURSOR}\\
+When GLFW\_MOUSE\_CURSOR is enabled, the mouse cursor is visible, and
+mouse coordinates are relative to the upper left corner of the client area
+of the \GLFW\ window. The coordinates are limited to the client area of
+the window.
+
+When GLFW\_MOUSE\_CURSOR is disabled, the mouse cursor is invisible, and
+mouse coordinates are not limited to the drawing area of the window. It is
+as if the mouse coordinates are recieved directly from the mouse, without
+being restricted or manipulated by the windowing system.
+\end{mysamepage}
+
+
+\bigskip\begin{mysamepage}\hypertarget{lnk:stickykeys}{}
+\textbf{GLFW\_STICKY\_KEYS}\\
+When GLFW\_STICKY\_KEYS is enabled, keys which are pressed will not be
+released until they are physically released and checked with
+\textbf{glfwGetKey}. This behavior makes it possible to catch keys that
+were pressed and then released again between two calls to
+\textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers}, which would otherwise have been reported as
+released. Care should be taken when using this mode, since keys that are
+not checked with \textbf{glfwGetKey} will never be released. Note also
+that enabling GLFW\_STICKY\_KEYS does not affect the behavior of the
+keyboard callback functionality.
+
+When GLFW\_STICKY\_KEYS is disabled, the status of a key that is reported
+by \textbf{glfwGetKey} is always the physical state of the key. Disabling
+GLFW\_STICKY\_KEYS also clears the sticky information for all keys.
+\end{mysamepage}
+
+
+\bigskip\begin{mysamepage}\hypertarget{lnk:stickymousebuttons}{}
+\textbf{GLFW\_STICKY\_MOUSE\_BUTTONS}\\
+When GLFW\_STICKY\_MOUSE\_BUTTONS is enabled, mouse buttons that are
+pressed will not be released until they are physically released and
+checked with \textbf{glfwGetMouseButton}. This behavior makes it
+possible to catch mouse buttons which were pressed and then released again
+between two calls to \textbf{glfwPollEvents}, \textbf{glfwWaitEvents} or
+\textbf{glfwSwapBuffers}, which would otherwise have been reported as
+released. Care should be taken when using this mode, since mouse buttons
+that are not checked with \textbf{glfwGetMouseButton} will never be
+released. Note also that enabling GLFW\_STICKY\_MOUSE\_BUTTONS does not
+affect the behavior of the mouse button callback functionality.
+
+When GLFW\_STICKY\_MOUSE\_BUTTONS is disabled, the status of a mouse
+button that is reported by \textbf{glfwGetMouseButton} is always the
+physical state of the mouse button. Disabling GLFW\_STICKY\_MOUSE\_BUTTONS
+also clears the sticky information for all mouse buttons.
+\end{mysamepage}
+
+
+\bigskip\begin{mysamepage}\hypertarget{lnk:systemkeys}{}
+\textbf{GLFW\_SYSTEM\_KEYS}\\
+When GLFW\_SYSTEM\_KEYS is enabled, pressing standard system key
+combinations, such as \texttt{ALT+TAB} under Windows, will give the normal
+behavior. Note that when \texttt{ALT+TAB} is issued under Windows in this
+mode so that the \GLFW\ application is deselected when \GLFW\ is operating
+in fullscreen mode, the \GLFW\ application window will be minimized and
+the video mode will be set to the original desktop mode. When the \GLFW\
+application is re-selected, the video mode will be set to the \GLFW\ video
+mode again.
+
+When GLFW\_SYSTEM\_KEYS is disabled, pressing standard system key
+combinations will have no effect, since those key combinations are blocked
+by \GLFW . This mode can be useful in situations when the \GLFW\ program
+must not be interrupted (normally for games in fullscreen mode).
+\end{mysamepage}
+
+
+%-------------------------------------------------------------------------
+\subsection{glfwGetNumberOfProcessors}
+
+\textbf{C language syntax}
+\begin{lstlisting}
+int glfwGetNumberOfProcessors( void )
+\end{lstlisting}
+
+\begin{refparameters}
+none
+\end{refparameters}
+
+\begin{refreturn}
+The function returns the number of active processors in the system.
+\end{refreturn}
+
+\begin{refdescription}
+The function determines the number of active processors in the system.
+\end{refdescription}
+
+\begin{refnotes}
+Systems with several logical processors per physical processor, also
+known as SMT (Symmetric Multi Threading) processors, will report the
+number of logical processors.
+\end{refnotes}
+
+
+\end{document}