+
+
diff --git a/images/mapproviders/googleearth.svg b/images/mapproviders/googleearth.svg
new file mode 100644
index 0000000000000000000000000000000000000000..0cb3de179f351f02088c7f09bc70cc91942245b8
--- /dev/null
+++ b/images/mapproviders/googleearth.svg
@@ -0,0 +1,383 @@
+
+
+
diff --git a/images/patterns/abby.jpg b/images/patterns/abby.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..b39b9a5e53e0b741934eec8c7d8d5bcf4b88faa7
Binary files /dev/null and b/images/patterns/abby.jpg differ
diff --git a/images/patterns/cake.jpg b/images/patterns/cake.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..a6ea3434ab67b1a0bd5e045e08d4efef8a796ffa
Binary files /dev/null and b/images/patterns/cake.jpg differ
diff --git a/images/patterns/cola.jpg b/images/patterns/cola.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..2faed5d5235fbbe96b85c4e62a485cb0f2e29f98
Binary files /dev/null and b/images/patterns/cola.jpg differ
diff --git a/images/patterns/flag.jpg b/images/patterns/flag.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..667a7c18679512186570155a409d3ddc3ca31c9f
Binary files /dev/null and b/images/patterns/flag.jpg differ
diff --git a/images/patterns/mona.jpg b/images/patterns/mona.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3f440d7f24af41efd3ca47c987c41d6427f92ec0
Binary files /dev/null and b/images/patterns/mona.jpg differ
diff --git a/images/patterns/sign.jpg b/images/patterns/sign.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..89efc8f9a36d0a1939d93f5b3402191e532168e0
Binary files /dev/null and b/images/patterns/sign.jpg differ
diff --git a/images/patterns/supa.png b/images/patterns/supa.png
new file mode 100644
index 0000000000000000000000000000000000000000..5d8552f45c2476d8c82aa8feb0740925d66e877e
Binary files /dev/null and b/images/patterns/supa.png differ
diff --git a/images/patterns/turm.jpg b/images/patterns/turm.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5ccbfe36075278aa3dfe40fd32d6af3739582212
Binary files /dev/null and b/images/patterns/turm.jpg differ
diff --git a/images/patterns/work.jpg b/images/patterns/work.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..1fa2cb12959351de9649814a0193c1312d938dd1
Binary files /dev/null and b/images/patterns/work.jpg differ
diff --git a/images/style-mission.css b/images/style-mission.css
index ee1f1635f07a018dc5de440b2380374abcc950c3..5831e88853c9a6d8cd922d936800b7b87686907d 100644
--- a/images/style-mission.css
+++ b/images/style-mission.css
@@ -77,10 +77,43 @@ border: 1px solid #777777;
color: #DDDDDF;
}
+ QMainWindow::separator {
+ background: #090909;
+ width: 2px; /* when vertical */
+ height: 2px; /* when horizontal */
+ }
+
+ QMainWindow::separator:hover {
+ background: white;
+ }
+
QDockWidget {
- font: bold;
- border: 1px solid #32345E;
-}
+ border: 1px solid #32345E;
+ /* titlebar-close-icon: url(close.png);
+ titlebar-normal-icon: url(undock.png);*/
+ }
+
+ QDockWidget::title {
+ text-align: left; /* align the text to the left */
+ background: lightgray;
+ padding-left: 5px;
+ }
+
+ QDockWidget::close-button, QDockWidget::float-button {
+ border: 1px solid transparent;
+ background: darkgray;
+ padding: 0px;
+ }
+
+ QDockWidget::close-button:hover, QDockWidget::float-button:hover {
+ background: gray;
+ }
+
+ QDockWidget::close-button:pressed, QDockWidget::float-button:pressed {
+ padding: 1px -1px -1px 1px;
+ }
+
+
QDockWidget::close-button, QDockWidget::float-button {
background-color: #181820;
diff --git a/lib/QMapControl/src/emptymapadapter.cpp b/lib/QMapControl/src/emptymapadapter.cpp
index 93cf3c99b7792dcaa5cfe123407d1920421205fa..0de9cc47378574b07d57aa1660372d354d12082d 100644
--- a/lib/QMapControl/src/emptymapadapter.cpp
+++ b/lib/QMapControl/src/emptymapadapter.cpp
@@ -98,8 +98,8 @@ namespace qmapcontrol
z= min_zoom - z;
}
- if (x<0 || x>pow(2,z)-1 ||
- y<0 || y>pow(2,z)-1)
+ if (x<0 || x>pow(2.0,z)-1 ||
+ y<0 || y>pow(2.0,z)-1)
{
return false;
}
@@ -108,7 +108,7 @@ namespace qmapcontrol
}
int EmptyMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
- return int(pow(2, zoomlevel));
+ return int(pow(2.0, zoomlevel));
}
int EmptyMapAdapter::xoffset(int x) const
{
diff --git a/lib/QMapControl/src/layer.cpp b/lib/QMapControl/src/layer.cpp
index 32f63583277935c897a6edfac2f59c3866a3f10d..62d78f1de186ce76c5d23c3a73911a5f3863cf1b 100644
--- a/lib/QMapControl/src/layer.cpp
+++ b/lib/QMapControl/src/layer.cpp
@@ -99,9 +99,10 @@ namespace qmapcontrol
Geometry* Layer::get_Geometry(int index)
{
+ Geometry* geo = NULL;
if(geometrySelected)
{
- return geometrySelected;
+ geo = geometrySelected;
}
else
{
@@ -110,7 +111,7 @@ namespace qmapcontrol
Geometry *geometry = geometries[i];
if(geometry->name() == QString::number(index))
{
- return geometry;
+ geo = geometry;
}
}
@@ -124,7 +125,7 @@ namespace qmapcontrol
// }
}
-
+ return geo;
}
bool Layer::isVisible() const
diff --git a/lib/QMapControl/src/layermanager.cpp b/lib/QMapControl/src/layermanager.cpp
index 3e10bb225a580e39e6ed11dc755aef0ced94bb19..3358605a41af94821e9c45b9783d0c0db6293d02 100644
--- a/lib/QMapControl/src/layermanager.cpp
+++ b/lib/QMapControl/src/layermanager.cpp
@@ -112,7 +112,14 @@ namespace qmapcontrol
void LayerManager::setView(const QPointF& coordinate)
{
+ QPoint oldMapPx = mapmiddle_px;
+
mapmiddle_px = layer()->mapadapter()->coordinateToDisplay(coordinate);
+
+ scroll += mapmiddle_px - oldMapPx;
+ zoomImageScroll+= mapmiddle_px - oldMapPx;
+
+
mapmiddle = coordinate;
//TODO: muss wegen moveTo() raus
@@ -125,7 +132,8 @@ namespace qmapcontrol
//TODO:
// verschiebung ausrechnen
// oder immer neues offscreenimage
- newOffscreenImage();
+ //newOffscreenImage();
+ moveWidgets();
}
}
diff --git a/lib/QMapControl/src/mapcontrol.cpp b/lib/QMapControl/src/mapcontrol.cpp
index 2f4c6d6094fdf9de1d68a75dadf982d759d5ed11..2872765dab8b14751d843c93fccfce9b839bcdca 100644
--- a/lib/QMapControl/src/mapcontrol.cpp
+++ b/lib/QMapControl/src/mapcontrol.cpp
@@ -157,7 +157,7 @@ namespace qmapcontrol
{
if (currentZoom() >= 0 && distanceList.size() > currentZoom())
{
- line = distanceList.at( currentZoom() ) / pow(2, 18-currentZoom() ) / 0.597164;
+ line = distanceList.at( currentZoom() ) / pow(2.0, 18-currentZoom() ) / 0.597164;
// draw the scale
painter.setPen(Qt::black);
@@ -210,7 +210,7 @@ namespace qmapcontrol
// Draw the Lat and Lon if needed
if (cursorPosVisible) {
- line = distanceList.at( currentZoom() ) / pow(2, 18-currentZoom() ) / 0.597164;
+ line = distanceList.at( currentZoom() ) / pow(2.0, 18-currentZoom() ) / 0.597164;
QString str;
str = QString(tr(" Lat: %1")).arg(currentWorldCoordinate.y());
diff --git a/lib/QMapControl/src/mapnetwork.cpp b/lib/QMapControl/src/mapnetwork.cpp
index f1430d05ab8bc143b4d58a4295c7b9eb5debb27f..155d9202f1029ec00851f6d1e8cddbe2e3e41c2c 100644
--- a/lib/QMapControl/src/mapnetwork.cpp
+++ b/lib/QMapControl/src/mapnetwork.cpp
@@ -95,7 +95,9 @@ namespace qmapcontrol
}
else
{
- qDebug() << "NETWORK_PIXMAP_ERROR: " << ax;
+ // QGC FIXME Error is currently undetected
+ // TODO Error is currently undetected
+ //qDebug() << "NETWORK_PIXMAP_ERROR: " << ax;
}
}
diff --git a/lib/QMapControl/src/point.cpp b/lib/QMapControl/src/point.cpp
index e1831befa6ac1d0c23270fefd8d9ec032a4fa526..45793a628996d3f310c0424cb0b2760ed4f4894e 100644
--- a/lib/QMapControl/src/point.cpp
+++ b/lib/QMapControl/src/point.cpp
@@ -144,8 +144,8 @@ namespace qmapcontrol
int diffzoom = homelevel-currentzoom;
int viewheight = size.height();
int viewwidth = size.width();
- viewheight = int(viewheight / pow(2, diffzoom));
- viewwidth = int(viewwidth / pow(2, diffzoom));
+ viewheight = int(viewheight / pow(2.0, diffzoom));
+ viewwidth = int(viewwidth / pow(2.0, diffzoom));
if (minsize.height()!= -1 && viewheight < minsize.height())
viewheight = minsize.height();
diff --git a/lib/QMapControl/src/tilemapadapter.cpp b/lib/QMapControl/src/tilemapadapter.cpp
index e61cbc90814fa45f7704d94067974abc4cc6e506..17d0e3b52ab19af9d0ea2af9f71bf5c6fec9277c 100644
--- a/lib/QMapControl/src/tilemapadapter.cpp
+++ b/lib/QMapControl/src/tilemapadapter.cpp
@@ -162,8 +162,8 @@ namespace qmapcontrol
z= min_zoom - z;
}
- if (x<0 || x>pow(2,z)-1 ||
- y<0 || y>pow(2,z)-1)
+ if (x<0 || x>pow(2.0,z)-1 ||
+ y<0 || y>pow(2.0,z)-1)
{
return false;
}
@@ -172,7 +172,7 @@ namespace qmapcontrol
}
int TileMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
- return int(pow(2, zoomlevel));
+ return int(pow(2.0, zoomlevel));
}
int TileMapAdapter::xoffset(int x) const
{
diff --git a/lib/QMapControl/src/wmsmapadapter.cpp b/lib/QMapControl/src/wmsmapadapter.cpp
index 96fa4fe60da9bf36d626d4679540720ff4f72acf..c6441a9bdb05f88bedd7a8374d4201786f4c37e6 100644
--- a/lib/QMapControl/src/wmsmapadapter.cpp
+++ b/lib/QMapControl/src/wmsmapadapter.cpp
@@ -47,7 +47,7 @@ namespace qmapcontrol
this->serverPath.append("&WIDTH=").append(loc.toString(tilesize))
.append("&HEIGHT=").append(loc.toString(tilesize))
.append("&BBOX=");
- numberOfTiles = pow(2, current_zoom);
+ numberOfTiles = pow(2.0, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
@@ -72,14 +72,14 @@ namespace qmapcontrol
void WMSMapAdapter::zoom_in()
{
current_zoom+=1;
- numberOfTiles = pow(2, current_zoom);
+ numberOfTiles = pow(2.0, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
void WMSMapAdapter::zoom_out()
{
current_zoom-=1;
- numberOfTiles = pow(2, current_zoom);
+ numberOfTiles = pow(2.0, current_zoom);
coord_per_x_tile = 360. / numberOfTiles;
coord_per_y_tile = 180. / numberOfTiles;
}
diff --git a/lib/QMapControl/src/yahoomapadapter.cpp b/lib/QMapControl/src/yahoomapadapter.cpp
index 863d7c2089a246f1c8eee9e820f3c157e84adbfd..b264080552e2ab7832494322debbf8b8e6da351d 100644
--- a/lib/QMapControl/src/yahoomapadapter.cpp
+++ b/lib/QMapControl/src/yahoomapadapter.cpp
@@ -30,13 +30,13 @@ namespace qmapcontrol
: TileMapAdapter("png.maps.yimg.com", "/png?v=3.1.0&x=%2&y=%3&z=%1", 256, 17,0)
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
- numberOfTiles = pow(2, zoom+1);
+ numberOfTiles = pow(2.0, zoom+1);
}
YahooMapAdapter::YahooMapAdapter(QString host, QString url)
: TileMapAdapter(host, url, 256, 17,0)
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
- numberOfTiles = pow(2, zoom+1);
+ numberOfTiles = pow(2.0, zoom+1);
}
YahooMapAdapter::~YahooMapAdapter()
{
@@ -49,14 +49,14 @@ namespace qmapcontrol
int YahooMapAdapter::tilesonzoomlevel(int zoomlevel) const
{
- return int(pow(2, zoomlevel+1));
+ return int(pow(2.0, zoomlevel+1));
}
int YahooMapAdapter::yoffset(int y) const
{
int zoom = max_zoom < min_zoom ? min_zoom - current_zoom : current_zoom;
- int tiles = int(pow(2, zoom));
+ int tiles = int(pow(2.0, zoom));
y = y*(-1)+tiles-1;
return int(y);
}
diff --git a/lib/mac32-gcc40/frameworks/.gitignore b/lib/mac32-gcc40/frameworks/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..39aa8067655ced203e5e936db165559cad9040d8
--- /dev/null
+++ b/lib/mac32-gcc40/frameworks/.gitignore
@@ -0,0 +1,2 @@
+*.framework
+osgPlugins*
diff --git a/lib/mac32-gcc40/frameworks/README b/lib/mac32-gcc40/frameworks/README
new file mode 100644
index 0000000000000000000000000000000000000000..2436e3d15e557bb60a2adcecf99663c59df5963b
--- /dev/null
+++ b/lib/mac32-gcc40/frameworks/README
@@ -0,0 +1,3 @@
+For instructions how to download or build the frameworks necessary to get OSG / osgEarth support, please refer to the QGroundControl wiki:
+
+http://qgroundcontrol.org/dev/open_scene_graph
diff --git a/lib/mac32-gcc40/include/.gitignore b/lib/mac32-gcc40/include/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..256a7a811270f51885b8d016129ba17789fb45ee
--- /dev/null
+++ b/lib/mac32-gcc40/include/.gitignore
@@ -0,0 +1,2 @@
+OpenThreads
+osg*
diff --git a/lib/mac32-gcc40/include/curl/curl.h b/lib/mac32-gcc40/include/curl/curl.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb9d0fbfbf5a98ec19e78bd37f868e78371abb01
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/curl.h
@@ -0,0 +1,2119 @@
+#ifndef __CURL_CURL_H
+#define __CURL_CURL_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/*
+ * If you have libcurl problems, all docs and details are found here:
+ * http://curl.haxx.se/libcurl/
+ *
+ * curl-library mailing list subscription and unsubscription web interface:
+ * http://cool.haxx.se/mailman/listinfo/curl-library/
+ */
+
+#include "curlver.h" /* libcurl version defines */
+#include "curlbuild.h" /* libcurl build definitions */
+#include "curlrules.h" /* libcurl rules enforcement */
+
+/*
+ * Define WIN32 when build target is Win32 API
+ */
+
+#if (defined(_WIN32) || defined(__WIN32__)) && \
+ !defined(WIN32) && !defined(__SYMBIAN32__)
+#define WIN32
+#endif
+
+#include
+#include
+
+#if defined(__FreeBSD__) && (__FreeBSD__ >= 2)
+/* Needed for __FreeBSD_version symbol definition */
+#include
+#endif
+
+/* The include stuff here below is mainly for time_t! */
+#include
+#include
+
+#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__GNUC__) && \
+ !defined(__CYGWIN__) || defined(__MINGW32__)
+#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H))
+/* The check above prevents the winsock2 inclusion if winsock.h already was
+ included, since they can't co-exist without problems */
+#include
+#include
+#endif
+#else
+
+/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish
+ libc5-based Linux systems. Only include it on system that are known to
+ require it! */
+#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
+ defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
+ defined(ANDROID) || \
+ (defined(__FreeBSD_version) && (__FreeBSD_version < 800000))
+#include
+#endif
+
+#ifndef _WIN32_WCE
+#include
+#endif
+#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__)
+#include
+#endif
+#include
+#endif
+
+#ifdef __BEOS__
+#include
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void CURL;
+
+/*
+ * Decorate exportable functions for Win32 and Symbian OS DLL linking.
+ * This avoids using a .def file for building libcurl.dll.
+ */
+#if (defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)) && \
+ !defined(CURL_STATICLIB)
+#if defined(BUILDING_LIBCURL)
+#define CURL_EXTERN __declspec(dllexport)
+#else
+#define CURL_EXTERN __declspec(dllimport)
+#endif
+#else
+
+#ifdef CURL_HIDDEN_SYMBOLS
+/*
+ * This definition is used to make external definitions visible in the
+ * shared library when symbols are hidden by default. It makes no
+ * difference when compiling applications whether this is set or not,
+ * only when compiling the library.
+ */
+#define CURL_EXTERN CURL_EXTERN_SYMBOL
+#else
+#define CURL_EXTERN
+#endif
+#endif
+
+#ifndef curl_socket_typedef
+/* socket typedef */
+#ifdef WIN32
+typedef SOCKET curl_socket_t;
+#define CURL_SOCKET_BAD INVALID_SOCKET
+#else
+typedef int curl_socket_t;
+#define CURL_SOCKET_BAD -1
+#endif
+#define curl_socket_typedef
+#endif /* curl_socket_typedef */
+
+struct curl_httppost {
+ struct curl_httppost *next; /* next entry in the list */
+ char *name; /* pointer to allocated name */
+ long namelength; /* length of name length */
+ char *contents; /* pointer to allocated data contents */
+ long contentslength; /* length of contents field */
+ char *buffer; /* pointer to allocated buffer contents */
+ long bufferlength; /* length of buffer field */
+ char *contenttype; /* Content-Type */
+ struct curl_slist* contentheader; /* list of extra headers for this form */
+ struct curl_httppost *more; /* if one field name has more than one
+ file, this link should link to following
+ files */
+ long flags; /* as defined below */
+#define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */
+#define HTTPPOST_READFILE (1<<1) /* specified content is a file name */
+#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer
+ do not free in formfree */
+#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer
+ do not free in formfree */
+#define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */
+#define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */
+#define HTTPPOST_CALLBACK (1<<6) /* upload file contents by using the
+ regular read callback to get the data
+ and pass the given pointer as custom
+ pointer */
+
+ char *showfilename; /* The file name to show. If not set, the
+ actual file name will be used (if this
+ is a file part) */
+ void *userp; /* custom pointer used for
+ HTTPPOST_CALLBACK posts */
+};
+
+typedef int (*curl_progress_callback)(void *clientp,
+ double dltotal,
+ double dlnow,
+ double ultotal,
+ double ulnow);
+
+#ifndef CURL_MAX_WRITE_SIZE
+ /* Tests have proven that 20K is a very bad buffer size for uploads on
+ Windows, while 16K for some odd reason performed a lot better.
+ We do the ifndef check to allow this value to easier be changed at build
+ time for those who feel adventurous. The practical minimum is about
+ 400 bytes since libcurl uses a buffer of this size as a scratch area
+ (unrelated to network send operations). */
+#define CURL_MAX_WRITE_SIZE 16384
+#endif
+
+#ifndef CURL_MAX_HTTP_HEADER
+/* The only reason to have a max limit for this is to avoid the risk of a bad
+ server feeding libcurl with a never-ending header that will cause reallocs
+ infinitely */
+#define CURL_MAX_HTTP_HEADER (100*1024)
+#endif
+
+
+/* This is a magic return code for the write callback that, when returned,
+ will signal libcurl to pause receiving on the current transfer. */
+#define CURL_WRITEFUNC_PAUSE 0x10000001
+typedef size_t (*curl_write_callback)(char *buffer,
+ size_t size,
+ size_t nitems,
+ void *outstream);
+
+
+
+/* enumeration of file types */
+typedef enum {
+ CURLFILETYPE_FILE = 0,
+ CURLFILETYPE_DIRECTORY,
+ CURLFILETYPE_SYMLINK,
+ CURLFILETYPE_DEVICE_BLOCK,
+ CURLFILETYPE_DEVICE_CHAR,
+ CURLFILETYPE_NAMEDPIPE,
+ CURLFILETYPE_SOCKET,
+ CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */
+
+ CURLFILETYPE_UNKNOWN /* should never occur */
+} curlfiletype;
+
+#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0)
+#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1)
+#define CURLFINFOFLAG_KNOWN_TIME (1<<2)
+#define CURLFINFOFLAG_KNOWN_PERM (1<<3)
+#define CURLFINFOFLAG_KNOWN_UID (1<<4)
+#define CURLFINFOFLAG_KNOWN_GID (1<<5)
+#define CURLFINFOFLAG_KNOWN_SIZE (1<<6)
+#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7)
+
+/* Content of this structure depends on information which is known and is
+ achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man
+ page for callbacks returning this structure -- some fields are mandatory,
+ some others are optional. The FLAG field has special meaning. */
+struct curl_fileinfo {
+ char *filename;
+ curlfiletype filetype;
+ time_t time;
+ unsigned int perm;
+ int uid;
+ int gid;
+ curl_off_t size;
+ long int hardlinks;
+
+ struct {
+ /* If some of these fields is not NULL, it is a pointer to b_data. */
+ char *time;
+ char *perm;
+ char *user;
+ char *group;
+ char *target; /* pointer to the target filename of a symlink */
+ } strings;
+
+ unsigned int flags;
+
+ /* used internally */
+ char * b_data;
+ size_t b_size;
+ size_t b_used;
+};
+
+/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */
+#define CURL_CHUNK_BGN_FUNC_OK 0
+#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */
+#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */
+
+/* if splitting of data transfer is enabled, this callback is called before
+ download of an individual chunk started. Note that parameter "remains" works
+ only for FTP wildcard downloading (for now), otherwise is not used */
+typedef long (*curl_chunk_bgn_callback)(const void *transfer_info,
+ void *ptr,
+ int remains);
+
+/* return codes for CURLOPT_CHUNK_END_FUNCTION */
+#define CURL_CHUNK_END_FUNC_OK 0
+#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */
+
+/* If splitting of data transfer is enabled this callback is called after
+ download of an individual chunk finished.
+ Note! After this callback was set then it have to be called FOR ALL chunks.
+ Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC.
+ This is the reason why we don't need "transfer_info" parameter in this
+ callback and we are not interested in "remains" parameter too. */
+typedef long (*curl_chunk_end_callback)(void *ptr);
+
+/* return codes for FNMATCHFUNCTION */
+#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */
+#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern doesn't match the string */
+#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */
+
+/* callback type for wildcard downloading pattern matching. If the
+ string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */
+typedef int (*curl_fnmatch_callback)(void *ptr,
+ const char *pattern,
+ const char *string);
+
+/* These are the return codes for the seek callbacks */
+#define CURL_SEEKFUNC_OK 0
+#define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */
+#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so
+ libcurl might try other means instead */
+typedef int (*curl_seek_callback)(void *instream,
+ curl_off_t offset,
+ int origin); /* 'whence' */
+
+/* This is a return code for the read callback that, when returned, will
+ signal libcurl to immediately abort the current transfer. */
+#define CURL_READFUNC_ABORT 0x10000000
+/* This is a return code for the read callback that, when returned, will
+ signal libcurl to pause sending data on the current transfer. */
+#define CURL_READFUNC_PAUSE 0x10000001
+
+typedef size_t (*curl_read_callback)(char *buffer,
+ size_t size,
+ size_t nitems,
+ void *instream);
+
+typedef enum {
+ CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */
+ CURLSOCKTYPE_LAST /* never use */
+} curlsocktype;
+
+typedef int (*curl_sockopt_callback)(void *clientp,
+ curl_socket_t curlfd,
+ curlsocktype purpose);
+
+struct curl_sockaddr {
+ int family;
+ int socktype;
+ int protocol;
+ unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it
+ turned really ugly and painful on the systems that
+ lack this type */
+ struct sockaddr addr;
+};
+
+typedef curl_socket_t
+(*curl_opensocket_callback)(void *clientp,
+ curlsocktype purpose,
+ struct curl_sockaddr *address);
+
+typedef enum {
+ CURLIOE_OK, /* I/O operation successful */
+ CURLIOE_UNKNOWNCMD, /* command was unknown to callback */
+ CURLIOE_FAILRESTART, /* failed to restart the read */
+ CURLIOE_LAST /* never use */
+} curlioerr;
+
+typedef enum {
+ CURLIOCMD_NOP, /* no operation */
+ CURLIOCMD_RESTARTREAD, /* restart the read stream from start */
+ CURLIOCMD_LAST /* never use */
+} curliocmd;
+
+typedef curlioerr (*curl_ioctl_callback)(CURL *handle,
+ int cmd,
+ void *clientp);
+
+/*
+ * The following typedef's are signatures of malloc, free, realloc, strdup and
+ * calloc respectively. Function pointers of these types can be passed to the
+ * curl_global_init_mem() function to set user defined memory management
+ * callback routines.
+ */
+typedef void *(*curl_malloc_callback)(size_t size);
+typedef void (*curl_free_callback)(void *ptr);
+typedef void *(*curl_realloc_callback)(void *ptr, size_t size);
+typedef char *(*curl_strdup_callback)(const char *str);
+typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size);
+
+/* the kind of data that is passed to information_callback*/
+typedef enum {
+ CURLINFO_TEXT = 0,
+ CURLINFO_HEADER_IN, /* 1 */
+ CURLINFO_HEADER_OUT, /* 2 */
+ CURLINFO_DATA_IN, /* 3 */
+ CURLINFO_DATA_OUT, /* 4 */
+ CURLINFO_SSL_DATA_IN, /* 5 */
+ CURLINFO_SSL_DATA_OUT, /* 6 */
+ CURLINFO_END
+} curl_infotype;
+
+typedef int (*curl_debug_callback)
+ (CURL *handle, /* the handle/transfer this concerns */
+ curl_infotype type, /* what kind of data */
+ char *data, /* points to the data */
+ size_t size, /* size of the data pointed to */
+ void *userptr); /* whatever the user please */
+
+/* All possible error codes from all sorts of curl functions. Future versions
+ may return other values, stay prepared.
+
+ Always add new return codes last. Never *EVER* remove any. The return
+ codes must remain the same!
+ */
+
+typedef enum {
+ CURLE_OK = 0,
+ CURLE_UNSUPPORTED_PROTOCOL, /* 1 */
+ CURLE_FAILED_INIT, /* 2 */
+ CURLE_URL_MALFORMAT, /* 3 */
+ CURLE_OBSOLETE4, /* 4 - NOT USED */
+ CURLE_COULDNT_RESOLVE_PROXY, /* 5 */
+ CURLE_COULDNT_RESOLVE_HOST, /* 6 */
+ CURLE_COULDNT_CONNECT, /* 7 */
+ CURLE_FTP_WEIRD_SERVER_REPLY, /* 8 */
+ CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server
+ due to lack of access - when login fails
+ this is not returned. */
+ CURLE_OBSOLETE10, /* 10 - NOT USED */
+ CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */
+ CURLE_OBSOLETE12, /* 12 - NOT USED */
+ CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */
+ CURLE_FTP_WEIRD_227_FORMAT, /* 14 */
+ CURLE_FTP_CANT_GET_HOST, /* 15 */
+ CURLE_OBSOLETE16, /* 16 - NOT USED */
+ CURLE_FTP_COULDNT_SET_TYPE, /* 17 */
+ CURLE_PARTIAL_FILE, /* 18 */
+ CURLE_FTP_COULDNT_RETR_FILE, /* 19 */
+ CURLE_OBSOLETE20, /* 20 - NOT USED */
+ CURLE_QUOTE_ERROR, /* 21 - quote command failure */
+ CURLE_HTTP_RETURNED_ERROR, /* 22 */
+ CURLE_WRITE_ERROR, /* 23 */
+ CURLE_OBSOLETE24, /* 24 - NOT USED */
+ CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */
+ CURLE_READ_ERROR, /* 26 - couldn't open/read from file */
+ CURLE_OUT_OF_MEMORY, /* 27 */
+ /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error
+ instead of a memory allocation error if CURL_DOES_CONVERSIONS
+ is defined
+ */
+ CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */
+ CURLE_OBSOLETE29, /* 29 - NOT USED */
+ CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */
+ CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */
+ CURLE_OBSOLETE32, /* 32 - NOT USED */
+ CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */
+ CURLE_HTTP_POST_ERROR, /* 34 */
+ CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */
+ CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */
+ CURLE_FILE_COULDNT_READ_FILE, /* 37 */
+ CURLE_LDAP_CANNOT_BIND, /* 38 */
+ CURLE_LDAP_SEARCH_FAILED, /* 39 */
+ CURLE_OBSOLETE40, /* 40 - NOT USED */
+ CURLE_FUNCTION_NOT_FOUND, /* 41 */
+ CURLE_ABORTED_BY_CALLBACK, /* 42 */
+ CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */
+ CURLE_OBSOLETE44, /* 44 - NOT USED */
+ CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */
+ CURLE_OBSOLETE46, /* 46 - NOT USED */
+ CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */
+ CURLE_UNKNOWN_TELNET_OPTION, /* 48 - User specified an unknown option */
+ CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */
+ CURLE_OBSOLETE50, /* 50 - NOT USED */
+ CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint
+ wasn't verified fine */
+ CURLE_GOT_NOTHING, /* 52 - when this is a specific error */
+ CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */
+ CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as
+ default */
+ CURLE_SEND_ERROR, /* 55 - failed sending network data */
+ CURLE_RECV_ERROR, /* 56 - failure in receiving network data */
+ CURLE_OBSOLETE57, /* 57 - NOT IN USE */
+ CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */
+ CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */
+ CURLE_SSL_CACERT, /* 60 - problem with the CA cert (path?) */
+ CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized transfer encoding */
+ CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */
+ CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */
+ CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */
+ CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind
+ that failed */
+ CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */
+ CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not
+ accepted and we failed to login */
+ CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */
+ CURLE_TFTP_PERM, /* 69 - permission problem on server */
+ CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */
+ CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */
+ CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */
+ CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */
+ CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */
+ CURLE_CONV_FAILED, /* 75 - conversion failed */
+ CURLE_CONV_REQD, /* 76 - caller must register conversion
+ callbacks using curl_easy_setopt options
+ CURLOPT_CONV_FROM_NETWORK_FUNCTION,
+ CURLOPT_CONV_TO_NETWORK_FUNCTION, and
+ CURLOPT_CONV_FROM_UTF8_FUNCTION */
+ CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing
+ or wrong format */
+ CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */
+ CURLE_SSH, /* 79 - error from the SSH layer, somewhat
+ generic so the error message will be of
+ interest when this has happened */
+
+ CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL
+ connection */
+ CURLE_AGAIN, /* 81 - socket is not ready for send/recv,
+ wait till it's ready and try again (Added
+ in 7.18.2) */
+ CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or
+ wrong format (Added in 7.19.0) */
+ CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in
+ 7.19.0) */
+ CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */
+ CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */
+ CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Identifiers */
+ CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */
+ CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */
+
+ CURL_LAST /* never use! */
+} CURLcode;
+
+#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
+ the obsolete stuff removed! */
+
+/* Backwards compatibility with older names */
+
+/* The following were added in 7.17.1 */
+/* These are scheduled to disappear by 2009 */
+#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION
+
+/* The following were added in 7.17.0 */
+/* These are scheduled to disappear by 2009 */
+#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* noone should be using this! */
+#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46
+#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44
+#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10
+#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16
+#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32
+#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29
+#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12
+#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20
+#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40
+#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24
+#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57
+#define CURLE_URL_MALFORMAT_USER CURLE_OBSOLETE4
+
+#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED
+#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE
+#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR
+#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL
+#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS
+#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR
+#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED
+
+/* The following were added earlier */
+
+#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT
+
+#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR
+#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED
+#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED
+
+#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE
+#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME
+
+/* This was the error code 50 in 7.7.3 and a few earlier versions, this
+ is no longer used by libcurl but is instead #defined here only to not
+ make programs break */
+#define CURLE_ALREADY_COMPLETE 99999
+
+#endif /*!CURL_NO_OLDIES*/
+
+/* This prototype applies to all conversion callbacks */
+typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length);
+
+typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */
+ void *ssl_ctx, /* actually an
+ OpenSSL SSL_CTX */
+ void *userptr);
+
+typedef enum {
+ CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use
+ CONNECT HTTP/1.1 */
+ CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT
+ HTTP/1.0 */
+ CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already
+ in 7.10 */
+ CURLPROXY_SOCKS5 = 5, /* added in 7.10 */
+ CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */
+ CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the
+ host name rather than the IP address. added
+ in 7.18.0 */
+} curl_proxytype; /* this enum was added in 7.10 */
+
+#define CURLAUTH_NONE 0 /* nothing */
+#define CURLAUTH_BASIC (1<<0) /* Basic (default) */
+#define CURLAUTH_DIGEST (1<<1) /* Digest */
+#define CURLAUTH_GSSNEGOTIATE (1<<2) /* GSS-Negotiate */
+#define CURLAUTH_NTLM (1<<3) /* NTLM */
+#define CURLAUTH_DIGEST_IE (1<<4) /* Digest with IE flavour */
+#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) /* all fine types set */
+#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE))
+
+#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */
+#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */
+#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */
+#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */
+#define CURLSSH_AUTH_HOST (1<<2) /* host key files */
+#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */
+#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY
+
+#define CURL_ERROR_SIZE 256
+
+struct curl_khkey {
+ const char *key; /* points to a zero-terminated string encoded with base64
+ if len is zero, otherwise to the "raw" data */
+ size_t len;
+ enum type {
+ CURLKHTYPE_UNKNOWN,
+ CURLKHTYPE_RSA1,
+ CURLKHTYPE_RSA,
+ CURLKHTYPE_DSS
+ } keytype;
+};
+
+/* this is the set of return values expected from the curl_sshkeycallback
+ callback */
+enum curl_khstat {
+ CURLKHSTAT_FINE_ADD_TO_FILE,
+ CURLKHSTAT_FINE,
+ CURLKHSTAT_REJECT, /* reject the connection, return an error */
+ CURLKHSTAT_DEFER, /* do not accept it, but we can't answer right now so
+ this causes a CURLE_DEFER error but otherwise the
+ connection will be left intact etc */
+ CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */
+};
+
+/* this is the set of status codes pass in to the callback */
+enum curl_khmatch {
+ CURLKHMATCH_OK, /* match */
+ CURLKHMATCH_MISMATCH, /* host found, key mismatch! */
+ CURLKHMATCH_MISSING, /* no matching host/key found */
+ CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */
+};
+
+typedef int
+ (*curl_sshkeycallback) (CURL *easy, /* easy handle */
+ const struct curl_khkey *knownkey, /* known */
+ const struct curl_khkey *foundkey, /* found */
+ enum curl_khmatch, /* libcurl's view on the keys */
+ void *clientp); /* custom pointer passed from app */
+
+/* parameter for the CURLOPT_USE_SSL option */
+typedef enum {
+ CURLUSESSL_NONE, /* do not attempt to use SSL */
+ CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */
+ CURLUSESSL_CONTROL, /* SSL for the control connection or fail */
+ CURLUSESSL_ALL, /* SSL for all communication or fail */
+ CURLUSESSL_LAST /* not an option, never use */
+} curl_usessl;
+
+#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
+ the obsolete stuff removed! */
+
+/* Backwards compatibility with older names */
+/* These are scheduled to disappear by 2009 */
+
+#define CURLFTPSSL_NONE CURLUSESSL_NONE
+#define CURLFTPSSL_TRY CURLUSESSL_TRY
+#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL
+#define CURLFTPSSL_ALL CURLUSESSL_ALL
+#define CURLFTPSSL_LAST CURLUSESSL_LAST
+#define curl_ftpssl curl_usessl
+#endif /*!CURL_NO_OLDIES*/
+
+/* parameter for the CURLOPT_FTP_SSL_CCC option */
+typedef enum {
+ CURLFTPSSL_CCC_NONE, /* do not send CCC */
+ CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */
+ CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */
+ CURLFTPSSL_CCC_LAST /* not an option, never use */
+} curl_ftpccc;
+
+/* parameter for the CURLOPT_FTPSSLAUTH option */
+typedef enum {
+ CURLFTPAUTH_DEFAULT, /* let libcurl decide */
+ CURLFTPAUTH_SSL, /* use "AUTH SSL" */
+ CURLFTPAUTH_TLS, /* use "AUTH TLS" */
+ CURLFTPAUTH_LAST /* not an option, never use */
+} curl_ftpauth;
+
+/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */
+typedef enum {
+ CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */
+ CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD
+ again if MKD succeeded, for SFTP this does
+ similar magic */
+ CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD
+ again even if MKD failed! */
+ CURLFTP_CREATE_DIR_LAST /* not an option, never use */
+} curl_ftpcreatedir;
+
+/* parameter for the CURLOPT_FTP_FILEMETHOD option */
+typedef enum {
+ CURLFTPMETHOD_DEFAULT, /* let libcurl pick */
+ CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */
+ CURLFTPMETHOD_NOCWD, /* no CWD at all */
+ CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */
+ CURLFTPMETHOD_LAST /* not an option, never use */
+} curl_ftpmethod;
+
+/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */
+#define CURLPROTO_HTTP (1<<0)
+#define CURLPROTO_HTTPS (1<<1)
+#define CURLPROTO_FTP (1<<2)
+#define CURLPROTO_FTPS (1<<3)
+#define CURLPROTO_SCP (1<<4)
+#define CURLPROTO_SFTP (1<<5)
+#define CURLPROTO_TELNET (1<<6)
+#define CURLPROTO_LDAP (1<<7)
+#define CURLPROTO_LDAPS (1<<8)
+#define CURLPROTO_DICT (1<<9)
+#define CURLPROTO_FILE (1<<10)
+#define CURLPROTO_TFTP (1<<11)
+#define CURLPROTO_IMAP (1<<12)
+#define CURLPROTO_IMAPS (1<<13)
+#define CURLPROTO_POP3 (1<<14)
+#define CURLPROTO_POP3S (1<<15)
+#define CURLPROTO_SMTP (1<<16)
+#define CURLPROTO_SMTPS (1<<17)
+#define CURLPROTO_RTSP (1<<18)
+#define CURLPROTO_RTMP (1<<19)
+#define CURLPROTO_RTMPT (1<<20)
+#define CURLPROTO_RTMPE (1<<21)
+#define CURLPROTO_RTMPTE (1<<22)
+#define CURLPROTO_RTMPS (1<<23)
+#define CURLPROTO_RTMPTS (1<<24)
+#define CURLPROTO_GOPHER (1<<25)
+#define CURLPROTO_ALL (~0) /* enable everything */
+
+/* long may be 32 or 64 bits, but we should never depend on anything else
+ but 32 */
+#define CURLOPTTYPE_LONG 0
+#define CURLOPTTYPE_OBJECTPOINT 10000
+#define CURLOPTTYPE_FUNCTIONPOINT 20000
+#define CURLOPTTYPE_OFF_T 30000
+
+/* name is uppercase CURLOPT_,
+ type is one of the defined CURLOPTTYPE_
+ number is unique identifier */
+#ifdef CINIT
+#undef CINIT
+#endif
+
+#ifdef CURL_ISOCPP
+#define CINIT(name,type,number) CURLOPT_ ## name = CURLOPTTYPE_ ## type + number
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define LONG CURLOPTTYPE_LONG
+#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT
+#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
+#define OFF_T CURLOPTTYPE_OFF_T
+#define CINIT(name,type,number) CURLOPT_/**/name = type + number
+#endif
+
+/*
+ * This macro-mania below setups the CURLOPT_[what] enum, to be used with
+ * curl_easy_setopt(). The first argument in the CINIT() macro is the [what]
+ * word.
+ */
+
+typedef enum {
+ /* This is the FILE * or void * the regular output should be written to. */
+ CINIT(FILE, OBJECTPOINT, 1),
+
+ /* The full URL to get/put */
+ CINIT(URL, OBJECTPOINT, 2),
+
+ /* Port number to connect to, if other than default. */
+ CINIT(PORT, LONG, 3),
+
+ /* Name of proxy to use. */
+ CINIT(PROXY, OBJECTPOINT, 4),
+
+ /* "name:password" to use when fetching. */
+ CINIT(USERPWD, OBJECTPOINT, 5),
+
+ /* "name:password" to use with proxy. */
+ CINIT(PROXYUSERPWD, OBJECTPOINT, 6),
+
+ /* Range to get, specified as an ASCII string. */
+ CINIT(RANGE, OBJECTPOINT, 7),
+
+ /* not used */
+
+ /* Specified file stream to upload from (use as input): */
+ CINIT(INFILE, OBJECTPOINT, 9),
+
+ /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
+ * bytes big. If this is not used, error messages go to stderr instead: */
+ CINIT(ERRORBUFFER, OBJECTPOINT, 10),
+
+ /* Function that will be called to store the output (instead of fwrite). The
+ * parameters will use fwrite() syntax, make sure to follow them. */
+ CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11),
+
+ /* Function that will be called to read the input (instead of fread). The
+ * parameters will use fread() syntax, make sure to follow them. */
+ CINIT(READFUNCTION, FUNCTIONPOINT, 12),
+
+ /* Time-out the read operation after this amount of seconds */
+ CINIT(TIMEOUT, LONG, 13),
+
+ /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about
+ * how large the file being sent really is. That allows better error
+ * checking and better verifies that the upload was successful. -1 means
+ * unknown size.
+ *
+ * For large file support, there is also a _LARGE version of the key
+ * which takes an off_t type, allowing platforms with larger off_t
+ * sizes to handle larger files. See below for INFILESIZE_LARGE.
+ */
+ CINIT(INFILESIZE, LONG, 14),
+
+ /* POST static input fields. */
+ CINIT(POSTFIELDS, OBJECTPOINT, 15),
+
+ /* Set the referrer page (needed by some CGIs) */
+ CINIT(REFERER, OBJECTPOINT, 16),
+
+ /* Set the FTP PORT string (interface name, named or numerical IP address)
+ Use i.e '-' to use default address. */
+ CINIT(FTPPORT, OBJECTPOINT, 17),
+
+ /* Set the User-Agent string (examined by some CGIs) */
+ CINIT(USERAGENT, OBJECTPOINT, 18),
+
+ /* If the download receives less than "low speed limit" bytes/second
+ * during "low speed time" seconds, the operations is aborted.
+ * You could i.e if you have a pretty high speed connection, abort if
+ * it is less than 2000 bytes/sec during 20 seconds.
+ */
+
+ /* Set the "low speed limit" */
+ CINIT(LOW_SPEED_LIMIT, LONG, 19),
+
+ /* Set the "low speed time" */
+ CINIT(LOW_SPEED_TIME, LONG, 20),
+
+ /* Set the continuation offset.
+ *
+ * Note there is also a _LARGE version of this key which uses
+ * off_t types, allowing for large file offsets on platforms which
+ * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE.
+ */
+ CINIT(RESUME_FROM, LONG, 21),
+
+ /* Set cookie in request: */
+ CINIT(COOKIE, OBJECTPOINT, 22),
+
+ /* This points to a linked list of headers, struct curl_slist kind */
+ CINIT(HTTPHEADER, OBJECTPOINT, 23),
+
+ /* This points to a linked list of post entries, struct curl_httppost */
+ CINIT(HTTPPOST, OBJECTPOINT, 24),
+
+ /* name of the file keeping your private SSL-certificate */
+ CINIT(SSLCERT, OBJECTPOINT, 25),
+
+ /* password for the SSL or SSH private key */
+ CINIT(KEYPASSWD, OBJECTPOINT, 26),
+
+ /* send TYPE parameter? */
+ CINIT(CRLF, LONG, 27),
+
+ /* send linked-list of QUOTE commands */
+ CINIT(QUOTE, OBJECTPOINT, 28),
+
+ /* send FILE * or void * to store headers to, if you use a callback it
+ is simply passed to the callback unmodified */
+ CINIT(WRITEHEADER, OBJECTPOINT, 29),
+
+ /* point to a file to read the initial cookies from, also enables
+ "cookie awareness" */
+ CINIT(COOKIEFILE, OBJECTPOINT, 31),
+
+ /* What version to specifically try to use.
+ See CURL_SSLVERSION defines below. */
+ CINIT(SSLVERSION, LONG, 32),
+
+ /* What kind of HTTP time condition to use, see defines */
+ CINIT(TIMECONDITION, LONG, 33),
+
+ /* Time to use with the above condition. Specified in number of seconds
+ since 1 Jan 1970 */
+ CINIT(TIMEVALUE, LONG, 34),
+
+ /* 35 = OBSOLETE */
+
+ /* Custom request, for customizing the get command like
+ HTTP: DELETE, TRACE and others
+ FTP: to use a different list command
+ */
+ CINIT(CUSTOMREQUEST, OBJECTPOINT, 36),
+
+ /* HTTP request, for odd commands like DELETE, TRACE and others */
+ CINIT(STDERR, OBJECTPOINT, 37),
+
+ /* 38 is not used */
+
+ /* send linked-list of post-transfer QUOTE commands */
+ CINIT(POSTQUOTE, OBJECTPOINT, 39),
+
+ /* Pass a pointer to string of the output using full variable-replacement
+ as described elsewhere. */
+ CINIT(WRITEINFO, OBJECTPOINT, 40),
+
+ CINIT(VERBOSE, LONG, 41), /* talk a lot */
+ CINIT(HEADER, LONG, 42), /* throw the header out too */
+ CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */
+ CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */
+ CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 300 */
+ CINIT(UPLOAD, LONG, 46), /* this is an upload */
+ CINIT(POST, LONG, 47), /* HTTP POST method */
+ CINIT(DIRLISTONLY, LONG, 48), /* return bare names when listing directories */
+
+ CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */
+
+ /* Specify whether to read the user+password from the .netrc or the URL.
+ * This must be one of the CURL_NETRC_* enums below. */
+ CINIT(NETRC, LONG, 51),
+
+ CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */
+
+ CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */
+ CINIT(PUT, LONG, 54), /* HTTP PUT */
+
+ /* 55 = OBSOLETE */
+
+ /* Function that will be called instead of the internal progress display
+ * function. This function should be defined as the curl_progress_callback
+ * prototype defines. */
+ CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56),
+
+ /* Data passed to the progress callback */
+ CINIT(PROGRESSDATA, OBJECTPOINT, 57),
+
+ /* We want the referrer field set automatically when following locations */
+ CINIT(AUTOREFERER, LONG, 58),
+
+ /* Port of the proxy, can be set in the proxy string as well with:
+ "[host]:[port]" */
+ CINIT(PROXYPORT, LONG, 59),
+
+ /* size of the POST input data, if strlen() is not good to use */
+ CINIT(POSTFIELDSIZE, LONG, 60),
+
+ /* tunnel non-http operations through a HTTP proxy */
+ CINIT(HTTPPROXYTUNNEL, LONG, 61),
+
+ /* Set the interface string to use as outgoing network interface */
+ CINIT(INTERFACE, OBJECTPOINT, 62),
+
+ /* Set the krb4/5 security level, this also enables krb4/5 awareness. This
+ * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string
+ * is set but doesn't match one of these, 'private' will be used. */
+ CINIT(KRBLEVEL, OBJECTPOINT, 63),
+
+ /* Set if we should verify the peer in ssl handshake, set 1 to verify. */
+ CINIT(SSL_VERIFYPEER, LONG, 64),
+
+ /* The CApath or CAfile used to validate the peer certificate
+ this option is used only if SSL_VERIFYPEER is true */
+ CINIT(CAINFO, OBJECTPOINT, 65),
+
+ /* 66 = OBSOLETE */
+ /* 67 = OBSOLETE */
+
+ /* Maximum number of http redirects to follow */
+ CINIT(MAXREDIRS, LONG, 68),
+
+ /* Pass a long set to 1 to get the date of the requested document (if
+ possible)! Pass a zero to shut it off. */
+ CINIT(FILETIME, LONG, 69),
+
+ /* This points to a linked list of telnet options */
+ CINIT(TELNETOPTIONS, OBJECTPOINT, 70),
+
+ /* Max amount of cached alive connections */
+ CINIT(MAXCONNECTS, LONG, 71),
+
+ /* What policy to use when closing connections when the cache is filled
+ up */
+ CINIT(CLOSEPOLICY, LONG, 72),
+
+ /* 73 = OBSOLETE */
+
+ /* Set to explicitly use a new connection for the upcoming transfer.
+ Do not use this unless you're absolutely sure of this, as it makes the
+ operation slower and is less friendly for the network. */
+ CINIT(FRESH_CONNECT, LONG, 74),
+
+ /* Set to explicitly forbid the upcoming transfer's connection to be re-used
+ when done. Do not use this unless you're absolutely sure of this, as it
+ makes the operation slower and is less friendly for the network. */
+ CINIT(FORBID_REUSE, LONG, 75),
+
+ /* Set to a file name that contains random data for libcurl to use to
+ seed the random engine when doing SSL connects. */
+ CINIT(RANDOM_FILE, OBJECTPOINT, 76),
+
+ /* Set to the Entropy Gathering Daemon socket pathname */
+ CINIT(EGDSOCKET, OBJECTPOINT, 77),
+
+ /* Time-out connect operations after this amount of seconds, if connects
+ are OK within this time, then fine... This only aborts the connect
+ phase. [Only works on unix-style/SIGALRM operating systems] */
+ CINIT(CONNECTTIMEOUT, LONG, 78),
+
+ /* Function that will be called to store headers (instead of fwrite). The
+ * parameters will use fwrite() syntax, make sure to follow them. */
+ CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79),
+
+ /* Set this to force the HTTP request to get back to GET. Only really usable
+ if POST, PUT or a custom request have been used first.
+ */
+ CINIT(HTTPGET, LONG, 80),
+
+ /* Set if we should verify the Common name from the peer certificate in ssl
+ * handshake, set 1 to check existence, 2 to ensure that it matches the
+ * provided hostname. */
+ CINIT(SSL_VERIFYHOST, LONG, 81),
+
+ /* Specify which file name to write all known cookies in after completed
+ operation. Set file name to "-" (dash) to make it go to stdout. */
+ CINIT(COOKIEJAR, OBJECTPOINT, 82),
+
+ /* Specify which SSL ciphers to use */
+ CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83),
+
+ /* Specify which HTTP version to use! This must be set to one of the
+ CURL_HTTP_VERSION* enums set below. */
+ CINIT(HTTP_VERSION, LONG, 84),
+
+ /* Specifically switch on or off the FTP engine's use of the EPSV command. By
+ default, that one will always be attempted before the more traditional
+ PASV command. */
+ CINIT(FTP_USE_EPSV, LONG, 85),
+
+ /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */
+ CINIT(SSLCERTTYPE, OBJECTPOINT, 86),
+
+ /* name of the file keeping your private SSL-key */
+ CINIT(SSLKEY, OBJECTPOINT, 87),
+
+ /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */
+ CINIT(SSLKEYTYPE, OBJECTPOINT, 88),
+
+ /* crypto engine for the SSL-sub system */
+ CINIT(SSLENGINE, OBJECTPOINT, 89),
+
+ /* set the crypto engine for the SSL-sub system as default
+ the param has no meaning...
+ */
+ CINIT(SSLENGINE_DEFAULT, LONG, 90),
+
+ /* Non-zero value means to use the global dns cache */
+ CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* To become OBSOLETE soon */
+
+ /* DNS cache timeout */
+ CINIT(DNS_CACHE_TIMEOUT, LONG, 92),
+
+ /* send linked-list of pre-transfer QUOTE commands */
+ CINIT(PREQUOTE, OBJECTPOINT, 93),
+
+ /* set the debug function */
+ CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94),
+
+ /* set the data for the debug function */
+ CINIT(DEBUGDATA, OBJECTPOINT, 95),
+
+ /* mark this as start of a cookie session */
+ CINIT(COOKIESESSION, LONG, 96),
+
+ /* The CApath directory used to validate the peer certificate
+ this option is used only if SSL_VERIFYPEER is true */
+ CINIT(CAPATH, OBJECTPOINT, 97),
+
+ /* Instruct libcurl to use a smaller receive buffer */
+ CINIT(BUFFERSIZE, LONG, 98),
+
+ /* Instruct libcurl to not use any signal/alarm handlers, even when using
+ timeouts. This option is useful for multi-threaded applications.
+ See libcurl-the-guide for more background information. */
+ CINIT(NOSIGNAL, LONG, 99),
+
+ /* Provide a CURLShare for mutexing non-ts data */
+ CINIT(SHARE, OBJECTPOINT, 100),
+
+ /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
+ CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */
+ CINIT(PROXYTYPE, LONG, 101),
+
+ /* Set the Accept-Encoding string. Use this to tell a server you would like
+ the response to be compressed. */
+ CINIT(ENCODING, OBJECTPOINT, 102),
+
+ /* Set pointer to private data */
+ CINIT(PRIVATE, OBJECTPOINT, 103),
+
+ /* Set aliases for HTTP 200 in the HTTP Response header */
+ CINIT(HTTP200ALIASES, OBJECTPOINT, 104),
+
+ /* Continue to send authentication (user+password) when following locations,
+ even when hostname changed. This can potentially send off the name
+ and password to whatever host the server decides. */
+ CINIT(UNRESTRICTED_AUTH, LONG, 105),
+
+ /* Specifically switch on or off the FTP engine's use of the EPRT command ( it
+ also disables the LPRT attempt). By default, those ones will always be
+ attempted before the good old traditional PORT command. */
+ CINIT(FTP_USE_EPRT, LONG, 106),
+
+ /* Set this to a bitmask value to enable the particular authentications
+ methods you like. Use this in combination with CURLOPT_USERPWD.
+ Note that setting multiple bits may cause extra network round-trips. */
+ CINIT(HTTPAUTH, LONG, 107),
+
+ /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx
+ in second argument. The function must be matching the
+ curl_ssl_ctx_callback proto. */
+ CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108),
+
+ /* Set the userdata for the ssl context callback function's third
+ argument */
+ CINIT(SSL_CTX_DATA, OBJECTPOINT, 109),
+
+ /* FTP Option that causes missing dirs to be created on the remote server.
+ In 7.19.4 we introduced the convenience enums for this option using the
+ CURLFTP_CREATE_DIR prefix.
+ */
+ CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110),
+
+ /* Set this to a bitmask value to enable the particular authentications
+ methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
+ Note that setting multiple bits may cause extra network round-trips. */
+ CINIT(PROXYAUTH, LONG, 111),
+
+ /* FTP option that changes the timeout, in seconds, associated with
+ getting a response. This is different from transfer timeout time and
+ essentially places a demand on the FTP server to acknowledge commands
+ in a timely manner. */
+ CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112),
+#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT
+
+ /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
+ tell libcurl to resolve names to those IP versions only. This only has
+ affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */
+ CINIT(IPRESOLVE, LONG, 113),
+
+ /* Set this option to limit the size of a file that will be downloaded from
+ an HTTP or FTP server.
+
+ Note there is also _LARGE version which adds large file support for
+ platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */
+ CINIT(MAXFILESIZE, LONG, 114),
+
+ /* See the comment for INFILESIZE above, but in short, specifies
+ * the size of the file being uploaded. -1 means unknown.
+ */
+ CINIT(INFILESIZE_LARGE, OFF_T, 115),
+
+ /* Sets the continuation offset. There is also a LONG version of this;
+ * look above for RESUME_FROM.
+ */
+ CINIT(RESUME_FROM_LARGE, OFF_T, 116),
+
+ /* Sets the maximum size of data that will be downloaded from
+ * an HTTP or FTP server. See MAXFILESIZE above for the LONG version.
+ */
+ CINIT(MAXFILESIZE_LARGE, OFF_T, 117),
+
+ /* Set this option to the file name of your .netrc file you want libcurl
+ to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
+ a poor attempt to find the user's home directory and check for a .netrc
+ file in there. */
+ CINIT(NETRC_FILE, OBJECTPOINT, 118),
+
+ /* Enable SSL/TLS for FTP, pick one of:
+ CURLFTPSSL_TRY - try using SSL, proceed anyway otherwise
+ CURLFTPSSL_CONTROL - SSL for the control connection or fail
+ CURLFTPSSL_ALL - SSL for all communication or fail
+ */
+ CINIT(USE_SSL, LONG, 119),
+
+ /* The _LARGE version of the standard POSTFIELDSIZE option */
+ CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120),
+
+ /* Enable/disable the TCP Nagle algorithm */
+ CINIT(TCP_NODELAY, LONG, 121),
+
+ /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+ /* 123 OBSOLETE. Gone in 7.16.0 */
+ /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+ /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+ /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */
+ /* 127 OBSOLETE. Gone in 7.16.0 */
+ /* 128 OBSOLETE. Gone in 7.16.0 */
+
+ /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option
+ can be used to change libcurl's default action which is to first try
+ "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
+ response has been received.
+
+ Available parameters are:
+ CURLFTPAUTH_DEFAULT - let libcurl decide
+ CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS
+ CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL
+ */
+ CINIT(FTPSSLAUTH, LONG, 129),
+
+ CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130),
+ CINIT(IOCTLDATA, OBJECTPOINT, 131),
+
+ /* 132 OBSOLETE. Gone in 7.16.0 */
+ /* 133 OBSOLETE. Gone in 7.16.0 */
+
+ /* zero terminated string for pass on to the FTP server when asked for
+ "account" info */
+ CINIT(FTP_ACCOUNT, OBJECTPOINT, 134),
+
+ /* feed cookies into cookie engine */
+ CINIT(COOKIELIST, OBJECTPOINT, 135),
+
+ /* ignore Content-Length */
+ CINIT(IGNORE_CONTENT_LENGTH, LONG, 136),
+
+ /* Set to non-zero to skip the IP address received in a 227 PASV FTP server
+ response. Typically used for FTP-SSL purposes but is not restricted to
+ that. libcurl will then instead use the same IP address it used for the
+ control connection. */
+ CINIT(FTP_SKIP_PASV_IP, LONG, 137),
+
+ /* Select "file method" to use when doing FTP, see the curl_ftpmethod
+ above. */
+ CINIT(FTP_FILEMETHOD, LONG, 138),
+
+ /* Local port number to bind the socket to */
+ CINIT(LOCALPORT, LONG, 139),
+
+ /* Number of ports to try, including the first one set with LOCALPORT.
+ Thus, setting it to 1 will make no additional attempts but the first.
+ */
+ CINIT(LOCALPORTRANGE, LONG, 140),
+
+ /* no transfer, set up connection and let application use the socket by
+ extracting it with CURLINFO_LASTSOCKET */
+ CINIT(CONNECT_ONLY, LONG, 141),
+
+ /* Function that will be called to convert from the
+ network encoding (instead of using the iconv calls in libcurl) */
+ CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142),
+
+ /* Function that will be called to convert to the
+ network encoding (instead of using the iconv calls in libcurl) */
+ CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143),
+
+ /* Function that will be called to convert from UTF8
+ (instead of using the iconv calls in libcurl)
+ Note that this is used only for SSL certificate processing */
+ CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144),
+
+ /* if the connection proceeds too quickly then need to slow it down */
+ /* limit-rate: maximum number of bytes per second to send or receive */
+ CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145),
+ CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146),
+
+ /* Pointer to command string to send if USER/PASS fails. */
+ CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147),
+
+ /* callback function for setting socket options */
+ CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148),
+ CINIT(SOCKOPTDATA, OBJECTPOINT, 149),
+
+ /* set to 0 to disable session ID re-use for this transfer, default is
+ enabled (== 1) */
+ CINIT(SSL_SESSIONID_CACHE, LONG, 150),
+
+ /* allowed SSH authentication methods */
+ CINIT(SSH_AUTH_TYPES, LONG, 151),
+
+ /* Used by scp/sftp to do public/private key authentication */
+ CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152),
+ CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153),
+
+ /* Send CCC (Clear Command Channel) after authentication */
+ CINIT(FTP_SSL_CCC, LONG, 154),
+
+ /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */
+ CINIT(TIMEOUT_MS, LONG, 155),
+ CINIT(CONNECTTIMEOUT_MS, LONG, 156),
+
+ /* set to zero to disable the libcurl's decoding and thus pass the raw body
+ data to the application even when it is encoded/compressed */
+ CINIT(HTTP_TRANSFER_DECODING, LONG, 157),
+ CINIT(HTTP_CONTENT_DECODING, LONG, 158),
+
+ /* Permission used when creating new files and directories on the remote
+ server for protocols that support it, SFTP/SCP/FILE */
+ CINIT(NEW_FILE_PERMS, LONG, 159),
+ CINIT(NEW_DIRECTORY_PERMS, LONG, 160),
+
+ /* Set the behaviour of POST when redirecting. Values must be set to one
+ of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */
+ CINIT(POSTREDIR, LONG, 161),
+
+ /* used by scp/sftp to verify the host's public key */
+ CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162),
+
+ /* Callback function for opening socket (instead of socket(2)). Optionally,
+ callback is able change the address or refuse to connect returning
+ CURL_SOCKET_BAD. The callback should have type
+ curl_opensocket_callback */
+ CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163),
+ CINIT(OPENSOCKETDATA, OBJECTPOINT, 164),
+
+ /* POST volatile input fields. */
+ CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165),
+
+ /* set transfer mode (;type=) when doing FTP via an HTTP proxy */
+ CINIT(PROXY_TRANSFER_MODE, LONG, 166),
+
+ /* Callback function for seeking in the input stream */
+ CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167),
+ CINIT(SEEKDATA, OBJECTPOINT, 168),
+
+ /* CRL file */
+ CINIT(CRLFILE, OBJECTPOINT, 169),
+
+ /* Issuer certificate */
+ CINIT(ISSUERCERT, OBJECTPOINT, 170),
+
+ /* (IPv6) Address scope */
+ CINIT(ADDRESS_SCOPE, LONG, 171),
+
+ /* Collect certificate chain info and allow it to get retrievable with
+ CURLINFO_CERTINFO after the transfer is complete. (Unfortunately) only
+ working with OpenSSL-powered builds. */
+ CINIT(CERTINFO, LONG, 172),
+
+ /* "name" and "pwd" to use when fetching. */
+ CINIT(USERNAME, OBJECTPOINT, 173),
+ CINIT(PASSWORD, OBJECTPOINT, 174),
+
+ /* "name" and "pwd" to use with Proxy when fetching. */
+ CINIT(PROXYUSERNAME, OBJECTPOINT, 175),
+ CINIT(PROXYPASSWORD, OBJECTPOINT, 176),
+
+ /* Comma separated list of hostnames defining no-proxy zones. These should
+ match both hostnames directly, and hostnames within a domain. For
+ example, local.com will match local.com and www.local.com, but NOT
+ notlocal.com or www.notlocal.com. For compatibility with other
+ implementations of this, .local.com will be considered to be the same as
+ local.com. A single * is the only valid wildcard, and effectively
+ disables the use of proxy. */
+ CINIT(NOPROXY, OBJECTPOINT, 177),
+
+ /* block size for TFTP transfers */
+ CINIT(TFTP_BLKSIZE, LONG, 178),
+
+ /* Socks Service */
+ CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179),
+
+ /* Socks Service */
+ CINIT(SOCKS5_GSSAPI_NEC, LONG, 180),
+
+ /* set the bitmask for the protocols that are allowed to be used for the
+ transfer, which thus helps the app which takes URLs from users or other
+ external inputs and want to restrict what protocol(s) to deal
+ with. Defaults to CURLPROTO_ALL. */
+ CINIT(PROTOCOLS, LONG, 181),
+
+ /* set the bitmask for the protocols that libcurl is allowed to follow to,
+ as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
+ to be set in both bitmasks to be allowed to get redirected to. Defaults
+ to all protocols except FILE and SCP. */
+ CINIT(REDIR_PROTOCOLS, LONG, 182),
+
+ /* set the SSH knownhost file name to use */
+ CINIT(SSH_KNOWNHOSTS, OBJECTPOINT, 183),
+
+ /* set the SSH host key callback, must point to a curl_sshkeycallback
+ function */
+ CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184),
+
+ /* set the SSH host key callback custom pointer */
+ CINIT(SSH_KEYDATA, OBJECTPOINT, 185),
+
+ /* set the SMTP mail originator */
+ CINIT(MAIL_FROM, OBJECTPOINT, 186),
+
+ /* set the SMTP mail receiver(s) */
+ CINIT(MAIL_RCPT, OBJECTPOINT, 187),
+
+ /* FTP: send PRET before PASV */
+ CINIT(FTP_USE_PRET, LONG, 188),
+
+ /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */
+ CINIT(RTSP_REQUEST, LONG, 189),
+
+ /* The RTSP session identifier */
+ CINIT(RTSP_SESSION_ID, OBJECTPOINT, 190),
+
+ /* The RTSP stream URI */
+ CINIT(RTSP_STREAM_URI, OBJECTPOINT, 191),
+
+ /* The Transport: header to use in RTSP requests */
+ CINIT(RTSP_TRANSPORT, OBJECTPOINT, 192),
+
+ /* Manually initialize the client RTSP CSeq for this handle */
+ CINIT(RTSP_CLIENT_CSEQ, LONG, 193),
+
+ /* Manually initialize the server RTSP CSeq for this handle */
+ CINIT(RTSP_SERVER_CSEQ, LONG, 194),
+
+ /* The stream to pass to INTERLEAVEFUNCTION. */
+ CINIT(INTERLEAVEDATA, OBJECTPOINT, 195),
+
+ /* Let the application define a custom write method for RTP data */
+ CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196),
+
+ /* Turn on wildcard matching */
+ CINIT(WILDCARDMATCH, LONG, 197),
+
+ /* Directory matching callback called before downloading of an
+ individual file (chunk) started */
+ CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198),
+
+ /* Directory matching callback called after the file (chunk)
+ was downloaded, or skipped */
+ CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199),
+
+ /* Change match (fnmatch-like) callback for wildcard matching */
+ CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200),
+
+ /* Let the application define custom chunk data pointer */
+ CINIT(CHUNK_DATA, OBJECTPOINT, 201),
+
+ /* FNMATCH_FUNCTION user pointer */
+ CINIT(FNMATCH_DATA, OBJECTPOINT, 202),
+
+ CURLOPT_LASTENTRY /* the last unused */
+} CURLoption;
+
+#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all
+ the obsolete stuff removed! */
+
+/* Backwards compatibility with older names */
+/* These are scheduled to disappear by 2011 */
+
+/* This was added in version 7.19.1 */
+#define CURLOPT_POST301 CURLOPT_POSTREDIR
+
+/* These are scheduled to disappear by 2009 */
+
+/* The following were added in 7.17.0 */
+#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD
+#define CURLOPT_FTPAPPEND CURLOPT_APPEND
+#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY
+#define CURLOPT_FTP_SSL CURLOPT_USE_SSL
+
+/* The following were added earlier */
+
+#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD
+#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL
+
+#else
+/* This is set if CURL_NO_OLDIES is defined at compile-time */
+#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */
+#endif
+
+
+ /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host
+ name resolves addresses using more than one IP protocol version, this
+ option might be handy to force libcurl to use a specific IP version. */
+#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP
+ versions that your system allows */
+#define CURL_IPRESOLVE_V4 1 /* resolve to ipv4 addresses */
+#define CURL_IPRESOLVE_V6 2 /* resolve to ipv6 addresses */
+
+ /* three convenient "aliases" that follow the name scheme better */
+#define CURLOPT_WRITEDATA CURLOPT_FILE
+#define CURLOPT_READDATA CURLOPT_INFILE
+#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER
+#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER
+
+ /* These enums are for use with the CURLOPT_HTTP_VERSION option. */
+enum {
+ CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd
+ like the library to choose the best possible
+ for us! */
+ CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */
+ CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */
+
+ CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */
+};
+
+/*
+ * Public API enums for RTSP requests
+ */
+enum {
+ CURL_RTSPREQ_NONE, /* first in list */
+ CURL_RTSPREQ_OPTIONS,
+ CURL_RTSPREQ_DESCRIBE,
+ CURL_RTSPREQ_ANNOUNCE,
+ CURL_RTSPREQ_SETUP,
+ CURL_RTSPREQ_PLAY,
+ CURL_RTSPREQ_PAUSE,
+ CURL_RTSPREQ_TEARDOWN,
+ CURL_RTSPREQ_GET_PARAMETER,
+ CURL_RTSPREQ_SET_PARAMETER,
+ CURL_RTSPREQ_RECORD,
+ CURL_RTSPREQ_RECEIVE,
+ CURL_RTSPREQ_LAST /* last in list */
+};
+
+ /* These enums are for use with the CURLOPT_NETRC option. */
+enum CURL_NETRC_OPTION {
+ CURL_NETRC_IGNORED, /* The .netrc will never be read.
+ * This is the default. */
+ CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred
+ * to one in the .netrc. */
+ CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored.
+ * Unless one is set programmatically, the .netrc
+ * will be queried. */
+ CURL_NETRC_LAST
+};
+
+enum {
+ CURL_SSLVERSION_DEFAULT,
+ CURL_SSLVERSION_TLSv1,
+ CURL_SSLVERSION_SSLv2,
+ CURL_SSLVERSION_SSLv3,
+
+ CURL_SSLVERSION_LAST /* never use, keep last */
+};
+
+/* symbols to use with CURLOPT_POSTREDIR.
+ CURL_REDIR_POST_301 and CURL_REDIR_POST_302 can be bitwise ORed so that
+ CURL_REDIR_POST_301 | CURL_REDIR_POST_302 == CURL_REDIR_POST_ALL */
+
+#define CURL_REDIR_GET_ALL 0
+#define CURL_REDIR_POST_301 1
+#define CURL_REDIR_POST_302 2
+#define CURL_REDIR_POST_ALL (CURL_REDIR_POST_301|CURL_REDIR_POST_302)
+
+typedef enum {
+ CURL_TIMECOND_NONE,
+
+ CURL_TIMECOND_IFMODSINCE,
+ CURL_TIMECOND_IFUNMODSINCE,
+ CURL_TIMECOND_LASTMOD,
+
+ CURL_TIMECOND_LAST
+} curl_TimeCond;
+
+
+/* curl_strequal() and curl_strnequal() are subject for removal in a future
+ libcurl, see lib/README.curlx for details */
+CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2);
+CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n);
+
+/* name is uppercase CURLFORM_ */
+#ifdef CFINIT
+#undef CFINIT
+#endif
+
+#ifdef CURL_ISOCPP
+#define CFINIT(name) CURLFORM_ ## name
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define CFINIT(name) CURLFORM_/**/name
+#endif
+
+typedef enum {
+ CFINIT(NOTHING), /********* the first one is unused ************/
+
+ /* */
+ CFINIT(COPYNAME),
+ CFINIT(PTRNAME),
+ CFINIT(NAMELENGTH),
+ CFINIT(COPYCONTENTS),
+ CFINIT(PTRCONTENTS),
+ CFINIT(CONTENTSLENGTH),
+ CFINIT(FILECONTENT),
+ CFINIT(ARRAY),
+ CFINIT(OBSOLETE),
+ CFINIT(FILE),
+
+ CFINIT(BUFFER),
+ CFINIT(BUFFERPTR),
+ CFINIT(BUFFERLENGTH),
+
+ CFINIT(CONTENTTYPE),
+ CFINIT(CONTENTHEADER),
+ CFINIT(FILENAME),
+ CFINIT(END),
+ CFINIT(OBSOLETE2),
+
+ CFINIT(STREAM),
+
+ CURLFORM_LASTENTRY /* the last unused */
+} CURLformoption;
+
+#undef CFINIT /* done */
+
+/* structure to be used as parameter for CURLFORM_ARRAY */
+struct curl_forms {
+ CURLformoption option;
+ const char *value;
+};
+
+/* use this for multipart formpost building */
+/* Returns code for curl_formadd()
+ *
+ * Returns:
+ * CURL_FORMADD_OK on success
+ * CURL_FORMADD_MEMORY if the FormInfo allocation fails
+ * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form
+ * CURL_FORMADD_NULL if a null pointer was given for a char
+ * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed
+ * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
+ * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error)
+ * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated
+ * CURL_FORMADD_MEMORY if some allocation for string copying failed.
+ * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array
+ *
+ ***************************************************************************/
+typedef enum {
+ CURL_FORMADD_OK, /* first, no error */
+
+ CURL_FORMADD_MEMORY,
+ CURL_FORMADD_OPTION_TWICE,
+ CURL_FORMADD_NULL,
+ CURL_FORMADD_UNKNOWN_OPTION,
+ CURL_FORMADD_INCOMPLETE,
+ CURL_FORMADD_ILLEGAL_ARRAY,
+ CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */
+
+ CURL_FORMADD_LAST /* last */
+} CURLFORMcode;
+
+/*
+ * NAME curl_formadd()
+ *
+ * DESCRIPTION
+ *
+ * Pretty advanced function for building multi-part formposts. Each invoke
+ * adds one part that together construct a full post. Then use
+ * CURLOPT_HTTPPOST to send it off to libcurl.
+ */
+CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost,
+ struct curl_httppost **last_post,
+ ...);
+
+/*
+ * callback function for curl_formget()
+ * The void *arg pointer will be the one passed as second argument to
+ * curl_formget().
+ * The character buffer passed to it must not be freed.
+ * Should return the buffer length passed to it as the argument "len" on
+ * success.
+ */
+typedef size_t (*curl_formget_callback)(void *arg, const char *buf, size_t len);
+
+/*
+ * NAME curl_formget()
+ *
+ * DESCRIPTION
+ *
+ * Serialize a curl_httppost struct built with curl_formadd().
+ * Accepts a void pointer as second argument which will be passed to
+ * the curl_formget_callback function.
+ * Returns 0 on success.
+ */
+CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg,
+ curl_formget_callback append);
+/*
+ * NAME curl_formfree()
+ *
+ * DESCRIPTION
+ *
+ * Free a multipart formpost previously built with curl_formadd().
+ */
+CURL_EXTERN void curl_formfree(struct curl_httppost *form);
+
+/*
+ * NAME curl_getenv()
+ *
+ * DESCRIPTION
+ *
+ * Returns a malloc()'ed string that MUST be curl_free()ed after usage is
+ * complete. DEPRECATED - see lib/README.curlx
+ */
+CURL_EXTERN char *curl_getenv(const char *variable);
+
+/*
+ * NAME curl_version()
+ *
+ * DESCRIPTION
+ *
+ * Returns a static ascii string of the libcurl version.
+ */
+CURL_EXTERN char *curl_version(void);
+
+/*
+ * NAME curl_easy_escape()
+ *
+ * DESCRIPTION
+ *
+ * Escapes URL strings (converts all letters consider illegal in URLs to their
+ * %XX versions). This function returns a new allocated string or NULL if an
+ * error occurred.
+ */
+CURL_EXTERN char *curl_easy_escape(CURL *handle,
+ const char *string,
+ int length);
+
+/* the previous version: */
+CURL_EXTERN char *curl_escape(const char *string,
+ int length);
+
+
+/*
+ * NAME curl_easy_unescape()
+ *
+ * DESCRIPTION
+ *
+ * Unescapes URL encoding in strings (converts all %XX codes to their 8bit
+ * versions). This function returns a new allocated string or NULL if an error
+ * occurred.
+ * Conversion Note: On non-ASCII platforms the ASCII %XX codes are
+ * converted into the host encoding.
+ */
+CURL_EXTERN char *curl_easy_unescape(CURL *handle,
+ const char *string,
+ int length,
+ int *outlength);
+
+/* the previous version */
+CURL_EXTERN char *curl_unescape(const char *string,
+ int length);
+
+/*
+ * NAME curl_free()
+ *
+ * DESCRIPTION
+ *
+ * Provided for de-allocation in the same translation unit that did the
+ * allocation. Added in libcurl 7.10
+ */
+CURL_EXTERN void curl_free(void *p);
+
+/*
+ * NAME curl_global_init()
+ *
+ * DESCRIPTION
+ *
+ * curl_global_init() should be invoked exactly once for each application that
+ * uses libcurl and before any call of other libcurl functions.
+ *
+ * This function is not thread-safe!
+ */
+CURL_EXTERN CURLcode curl_global_init(long flags);
+
+/*
+ * NAME curl_global_init_mem()
+ *
+ * DESCRIPTION
+ *
+ * curl_global_init() or curl_global_init_mem() should be invoked exactly once
+ * for each application that uses libcurl. This function can be used to
+ * initialize libcurl and set user defined memory management callback
+ * functions. Users can implement memory management routines to check for
+ * memory leaks, check for mis-use of the curl library etc. User registered
+ * callback routines with be invoked by this library instead of the system
+ * memory management routines like malloc, free etc.
+ */
+CURL_EXTERN CURLcode curl_global_init_mem(long flags,
+ curl_malloc_callback m,
+ curl_free_callback f,
+ curl_realloc_callback r,
+ curl_strdup_callback s,
+ curl_calloc_callback c);
+
+/*
+ * NAME curl_global_cleanup()
+ *
+ * DESCRIPTION
+ *
+ * curl_global_cleanup() should be invoked exactly once for each application
+ * that uses libcurl
+ */
+CURL_EXTERN void curl_global_cleanup(void);
+
+/* linked-list structure for the CURLOPT_QUOTE option (and other) */
+struct curl_slist {
+ char *data;
+ struct curl_slist *next;
+};
+
+/*
+ * NAME curl_slist_append()
+ *
+ * DESCRIPTION
+ *
+ * Appends a string to a linked list. If no list exists, it will be created
+ * first. Returns the new list, after appending.
+ */
+CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *,
+ const char *);
+
+/*
+ * NAME curl_slist_free_all()
+ *
+ * DESCRIPTION
+ *
+ * free a previously built curl_slist.
+ */
+CURL_EXTERN void curl_slist_free_all(struct curl_slist *);
+
+/*
+ * NAME curl_getdate()
+ *
+ * DESCRIPTION
+ *
+ * Returns the time, in seconds since 1 Jan 1970 of the time string given in
+ * the first argument. The time argument in the second parameter is unused
+ * and should be set to NULL.
+ */
+CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused);
+
+/* info about the certificate chain, only for OpenSSL builds. Asked
+ for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */
+struct curl_certinfo {
+ int num_of_certs; /* number of certificates with information */
+ struct curl_slist **certinfo; /* for each index in this array, there's a
+ linked list with textual information in the
+ format "name: value" */
+};
+
+#define CURLINFO_STRING 0x100000
+#define CURLINFO_LONG 0x200000
+#define CURLINFO_DOUBLE 0x300000
+#define CURLINFO_SLIST 0x400000
+#define CURLINFO_MASK 0x0fffff
+#define CURLINFO_TYPEMASK 0xf00000
+
+typedef enum {
+ CURLINFO_NONE, /* first, never use this */
+ CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1,
+ CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2,
+ CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3,
+ CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4,
+ CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5,
+ CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
+ CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7,
+ CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8,
+ CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9,
+ CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10,
+ CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11,
+ CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12,
+ CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13,
+ CURLINFO_FILETIME = CURLINFO_LONG + 14,
+ CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15,
+ CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16,
+ CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
+ CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18,
+ CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19,
+ CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20,
+ CURLINFO_PRIVATE = CURLINFO_STRING + 21,
+ CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22,
+ CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23,
+ CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24,
+ CURLINFO_OS_ERRNO = CURLINFO_LONG + 25,
+ CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26,
+ CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27,
+ CURLINFO_COOKIELIST = CURLINFO_SLIST + 28,
+ CURLINFO_LASTSOCKET = CURLINFO_LONG + 29,
+ CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30,
+ CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31,
+ CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32,
+ CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33,
+ CURLINFO_CERTINFO = CURLINFO_SLIST + 34,
+ CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35,
+ CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36,
+ CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37,
+ CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38,
+ CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39,
+ CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40,
+ CURLINFO_LOCAL_IP = CURLINFO_STRING + 41,
+ CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42,
+ /* Fill in new entries below here! */
+
+ CURLINFO_LASTONE = 42
+} CURLINFO;
+
+/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as
+ CURLINFO_HTTP_CODE */
+#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE
+
+typedef enum {
+ CURLCLOSEPOLICY_NONE, /* first, never use this */
+
+ CURLCLOSEPOLICY_OLDEST,
+ CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
+ CURLCLOSEPOLICY_LEAST_TRAFFIC,
+ CURLCLOSEPOLICY_SLOWEST,
+ CURLCLOSEPOLICY_CALLBACK,
+
+ CURLCLOSEPOLICY_LAST /* last, never use this */
+} curl_closepolicy;
+
+#define CURL_GLOBAL_SSL (1<<0)
+#define CURL_GLOBAL_WIN32 (1<<1)
+#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32)
+#define CURL_GLOBAL_NOTHING 0
+#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL
+
+
+/*****************************************************************************
+ * Setup defines, protos etc for the sharing stuff.
+ */
+
+/* Different data locks for a single share */
+typedef enum {
+ CURL_LOCK_DATA_NONE = 0,
+ /* CURL_LOCK_DATA_SHARE is used internally to say that
+ * the locking is just made to change the internal state of the share
+ * itself.
+ */
+ CURL_LOCK_DATA_SHARE,
+ CURL_LOCK_DATA_COOKIE,
+ CURL_LOCK_DATA_DNS,
+ CURL_LOCK_DATA_SSL_SESSION,
+ CURL_LOCK_DATA_CONNECT,
+ CURL_LOCK_DATA_LAST
+} curl_lock_data;
+
+/* Different lock access types */
+typedef enum {
+ CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */
+ CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */
+ CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */
+ CURL_LOCK_ACCESS_LAST /* never use */
+} curl_lock_access;
+
+typedef void (*curl_lock_function)(CURL *handle,
+ curl_lock_data data,
+ curl_lock_access locktype,
+ void *userptr);
+typedef void (*curl_unlock_function)(CURL *handle,
+ curl_lock_data data,
+ void *userptr);
+
+typedef void CURLSH;
+
+typedef enum {
+ CURLSHE_OK, /* all is fine */
+ CURLSHE_BAD_OPTION, /* 1 */
+ CURLSHE_IN_USE, /* 2 */
+ CURLSHE_INVALID, /* 3 */
+ CURLSHE_NOMEM, /* out of memory */
+ CURLSHE_LAST /* never use */
+} CURLSHcode;
+
+typedef enum {
+ CURLSHOPT_NONE, /* don't use */
+ CURLSHOPT_SHARE, /* specify a data type to share */
+ CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */
+ CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */
+ CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */
+ CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock
+ callback functions */
+ CURLSHOPT_LAST /* never use */
+} CURLSHoption;
+
+CURL_EXTERN CURLSH *curl_share_init(void);
+CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...);
+CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *);
+
+/****************************************************************************
+ * Structures for querying information about the curl library at runtime.
+ */
+
+typedef enum {
+ CURLVERSION_FIRST,
+ CURLVERSION_SECOND,
+ CURLVERSION_THIRD,
+ CURLVERSION_FOURTH,
+ CURLVERSION_LAST /* never actually use this */
+} CURLversion;
+
+/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by
+ basically all programs ever that want to get version information. It is
+ meant to be a built-in version number for what kind of struct the caller
+ expects. If the struct ever changes, we redefine the NOW to another enum
+ from above. */
+#define CURLVERSION_NOW CURLVERSION_FOURTH
+
+typedef struct {
+ CURLversion age; /* age of the returned struct */
+ const char *version; /* LIBCURL_VERSION */
+ unsigned int version_num; /* LIBCURL_VERSION_NUM */
+ const char *host; /* OS/host/cpu/machine when configured */
+ int features; /* bitmask, see defines below */
+ const char *ssl_version; /* human readable string */
+ long ssl_version_num; /* not used anymore, always 0 */
+ const char *libz_version; /* human readable string */
+ /* protocols is terminated by an entry with a NULL protoname */
+ const char * const *protocols;
+
+ /* The fields below this were added in CURLVERSION_SECOND */
+ const char *ares;
+ int ares_num;
+
+ /* This field was added in CURLVERSION_THIRD */
+ const char *libidn;
+
+ /* These field were added in CURLVERSION_FOURTH */
+
+ /* Same as '_libiconv_version' if built with HAVE_ICONV */
+ int iconv_ver_num;
+
+ const char *libssh_version; /* human readable string */
+
+} curl_version_info_data;
+
+#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */
+#define CURL_VERSION_KERBEROS4 (1<<1) /* kerberos auth is supported */
+#define CURL_VERSION_SSL (1<<2) /* SSL options are present */
+#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */
+#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */
+#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */
+#define CURL_VERSION_DEBUG (1<<6) /* built with debug capabilities */
+#define CURL_VERSION_ASYNCHDNS (1<<7) /* asynchronous dns resolves */
+#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth */
+#define CURL_VERSION_LARGEFILE (1<<9) /* supports files bigger than 2GB */
+#define CURL_VERSION_IDN (1<<10) /* International Domain Names support */
+#define CURL_VERSION_SSPI (1<<11) /* SSPI is supported */
+#define CURL_VERSION_CONV (1<<12) /* character conversions supported */
+#define CURL_VERSION_CURLDEBUG (1<<13) /* debug memory tracking supported */
+
+/*
+ * NAME curl_version_info()
+ *
+ * DESCRIPTION
+ *
+ * This function returns a pointer to a static copy of the version info
+ * struct. See above.
+ */
+CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion);
+
+/*
+ * NAME curl_easy_strerror()
+ *
+ * DESCRIPTION
+ *
+ * The curl_easy_strerror function may be used to turn a CURLcode value
+ * into the equivalent human readable error string. This is useful
+ * for printing meaningful error messages.
+ */
+CURL_EXTERN const char *curl_easy_strerror(CURLcode);
+
+/*
+ * NAME curl_share_strerror()
+ *
+ * DESCRIPTION
+ *
+ * The curl_share_strerror function may be used to turn a CURLSHcode value
+ * into the equivalent human readable error string. This is useful
+ * for printing meaningful error messages.
+ */
+CURL_EXTERN const char *curl_share_strerror(CURLSHcode);
+
+/*
+ * NAME curl_easy_pause()
+ *
+ * DESCRIPTION
+ *
+ * The curl_easy_pause function pauses or unpauses transfers. Select the new
+ * state by setting the bitmask, use the convenience defines below.
+ *
+ */
+CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask);
+
+#define CURLPAUSE_RECV (1<<0)
+#define CURLPAUSE_RECV_CONT (0)
+
+#define CURLPAUSE_SEND (1<<2)
+#define CURLPAUSE_SEND_CONT (0)
+
+#define CURLPAUSE_ALL (CURLPAUSE_RECV|CURLPAUSE_SEND)
+#define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT)
+
+#ifdef __cplusplus
+}
+#endif
+
+/* unfortunately, the easy.h and multi.h include files need options and info
+ stuff before they can be included! */
+#include "easy.h" /* nothing in curl is fun without the easy stuff */
+#include "multi.h"
+
+/* the typechecker doesn't work in C++ (yet) */
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \
+ ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \
+ !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK)
+#include "typecheck-gcc.h"
+#else
+#if defined(__STDC__) && (__STDC__ >= 1)
+/* This preprocessor magic that replaces a call with the exact same call is
+ only done to make sure application authors pass exactly three arguments
+ to these functions. */
+#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param)
+#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg)
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
+#endif /* __STDC__ >= 1 */
+#endif /* gcc >= 4.3 && !__cplusplus */
+
+#endif /* __CURL_CURL_H */
diff --git a/lib/mac32-gcc40/include/curl/curlbuild.h b/lib/mac32-gcc40/include/curl/curlbuild.h
new file mode 100644
index 0000000000000000000000000000000000000000..81f4a285470c0e6a8bec459574d8a7e64c02e666
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/curlbuild.h
@@ -0,0 +1,191 @@
+/* include/curl/curlbuild.h. Generated from curlbuild.h.in by configure. */
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2009, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/* NOTES FOR CONFIGURE CAPABLE SYSTEMS */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.in or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/* DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+# error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+# error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+# error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+# error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+# error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+# error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+# error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+# error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+# error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+# error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+ Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/* EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file ws2tcpip.h must be included by the external interface. */
+/* #undef CURL_PULL_WS2TCPIP_H */
+#ifdef CURL_PULL_WS2TCPIP_H
+# ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+# endif
+# include
+# include
+# include
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file sys/types.h must be included by the external interface. */
+#define CURL_PULL_SYS_TYPES_H 1
+#ifdef CURL_PULL_SYS_TYPES_H
+# include
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file stdint.h must be included by the external interface. */
+#define CURL_PULL_STDINT_H 1
+#ifdef CURL_PULL_STDINT_H
+# include
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file inttypes.h must be included by the external interface. */
+#define CURL_PULL_INTTYPES_H 1
+#ifdef CURL_PULL_INTTYPES_H
+# include
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file sys/socket.h must be included by the external interface. */
+#define CURL_PULL_SYS_SOCKET_H 1
+#ifdef CURL_PULL_SYS_SOCKET_H
+# include
+#endif
+
+/* The size of `long', as computed by sizeof. */
+#define CURL_SIZEOF_LONG 4
+
+/* Integral data type used for curl_socklen_t. */
+#define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+
+/* The size of `curl_socklen_t', as computed by sizeof. */
+#define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+/* Data type definition of curl_socklen_t. */
+typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+
+/* Signed integral data type used for curl_off_t. */
+#define CURL_TYPEOF_CURL_OFF_T int64_t
+
+/* Data type definition of curl_off_t. */
+typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+
+/* curl_off_t formatting string directive without "%" conversion specifier. */
+#define CURL_FORMAT_CURL_OFF_T "lld"
+
+/* unsigned curl_off_t formatting string without "%" conversion specifier. */
+#define CURL_FORMAT_CURL_OFF_TU "llu"
+
+/* curl_off_t formatting string directive with "%" conversion specifier. */
+#define CURL_FORMAT_OFF_T "%lld"
+
+/* The size of `curl_off_t', as computed by sizeof. */
+#define CURL_SIZEOF_CURL_OFF_T 8
+
+/* curl_off_t constant suffix. */
+#define CURL_SUFFIX_CURL_OFF_T LL
+
+/* unsigned curl_off_t constant suffix. */
+#define CURL_SUFFIX_CURL_OFF_TU ULL
+
+#endif /* __CURL_CURLBUILD_H */
diff --git a/lib/mac32-gcc40/include/curl/curlrules.h b/lib/mac32-gcc40/include/curl/curlrules.h
new file mode 100644
index 0000000000000000000000000000000000000000..8aad1df678c0d827ca792c16137d17d86963fc3d
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/curlrules.h
@@ -0,0 +1,252 @@
+#ifndef __CURL_CURLRULES_H
+#define __CURL_CURLRULES_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/* COMPILE TIME SANITY CHECKS */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * All checks done in this file are intentionally placed in a public
+ * header file which is pulled by curl/curl.h when an application is
+ * being built using an already built libcurl library. Additionally
+ * this file is also included and used when building the library.
+ *
+ * If compilation fails on this file it is certainly sure that the
+ * problem is elsewhere. It could be a problem in the curlbuild.h
+ * header file, or simply that you are using different compilation
+ * settings than those used to build the library.
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * Do not deactivate any check, these are done to make sure that the
+ * library is properly built and used.
+ *
+ * You can find further help on the libcurl development mailing list:
+ * http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * NOTE 2
+ * ------
+ *
+ * Some of the following compile time checks are based on the fact
+ * that the dimension of a constant array can not be a negative one.
+ * In this way if the compile time verification fails, the compilation
+ * will fail issuing an error. The error description wording is compiler
+ * dependent but it will be quite similar to one of the following:
+ *
+ * "negative subscript or subscript is too large"
+ * "array must have at least one element"
+ * "-1 is an illegal array size"
+ * "size of array is negative"
+ *
+ * If you are building an application which tries to use an already
+ * built libcurl library and you are getting this kind of errors on
+ * this file, it is a clear indication that there is a mismatch between
+ * how the library was built and how you are trying to use it for your
+ * application. Your already compiled or binary library provider is the
+ * only one who can give you the details you need to properly use it.
+ */
+
+/*
+ * Verify that some macros are actually defined.
+ */
+
+#ifndef CURL_SIZEOF_LONG
+# error "CURL_SIZEOF_LONG definition is missing!"
+ Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_SOCKLEN_T
+# error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!"
+ Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_SOCKLEN_T
+# error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!"
+ Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_OFF_T
+# error "CURL_TYPEOF_CURL_OFF_T definition is missing!"
+ Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_T
+# error "CURL_FORMAT_CURL_OFF_T definition is missing!"
+ Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_TU
+# error "CURL_FORMAT_CURL_OFF_TU definition is missing!"
+ Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing
+#endif
+
+#ifndef CURL_FORMAT_OFF_T
+# error "CURL_FORMAT_OFF_T definition is missing!"
+ Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_OFF_T
+# error "CURL_SIZEOF_CURL_OFF_T definition is missing!"
+ Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_T
+# error "CURL_SUFFIX_CURL_OFF_T definition is missing!"
+ Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_TU
+# error "CURL_SUFFIX_CURL_OFF_TU definition is missing!"
+ Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing
+#endif
+
+/*
+ * Macros private to this header file.
+ */
+
+#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1
+
+#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
+
+/*
+ * Verify that the size previously defined and expected for long
+ * is the same as the one reported by sizeof() at compile time.
+ */
+
+typedef char
+ __curl_rule_01__
+ [CurlchkszEQ(long, CURL_SIZEOF_LONG)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_off_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+ __curl_rule_02__
+ [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)];
+
+/*
+ * Verify at compile time that the size of curl_off_t as reported
+ * by sizeof() is greater or equal than the one reported for long
+ * for the current compilation.
+ */
+
+typedef char
+ __curl_rule_03__
+ [CurlchkszGE(curl_off_t, long)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_socklen_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+ __curl_rule_04__
+ [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)];
+
+/*
+ * Verify at compile time that the size of curl_socklen_t as reported
+ * by sizeof() is greater or equal than the one reported for int for
+ * the current compilation.
+ */
+
+typedef char
+ __curl_rule_05__
+ [CurlchkszGE(curl_socklen_t, int)];
+
+/* ================================================================ */
+/* EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS */
+/* ================================================================ */
+
+/*
+ * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow
+ * these to be visible and exported by the external libcurl interface API,
+ * while also making them visible to the library internals, simply including
+ * setup.h, without actually needing to include curl.h internally.
+ * If some day this section would grow big enough, all this should be moved
+ * to its own header file.
+ */
+
+/*
+ * Figure out if we can use the ## preprocessor operator, which is supported
+ * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__
+ * or __cplusplus so we need to carefully check for them too.
+ */
+
+#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \
+ defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \
+ defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \
+ defined(__ILEC400__)
+ /* This compiler is believed to have an ISO compatible preprocessor */
+#define CURL_ISOCPP
+#else
+ /* This compiler is believed NOT to have an ISO compatible preprocessor */
+#undef CURL_ISOCPP
+#endif
+
+/*
+ * Macros for minimum-width signed and unsigned curl_off_t integer constants.
+ */
+
+#ifdef CURL_ISOCPP
+# define __CURL_OFF_T_C_HELPER2(Val,Suffix) Val ## Suffix
+#else
+# define __CURL_OFF_T_C_HELPER2(Val,Suffix) Val/**/Suffix
+#endif
+#define __CURL_OFF_T_C_HELPER1(Val,Suffix) __CURL_OFF_T_C_HELPER2(Val,Suffix)
+#define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HELPER1(Val,CURL_SUFFIX_CURL_OFF_T)
+#define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HELPER1(Val,CURL_SUFFIX_CURL_OFF_TU)
+
+/*
+ * Get rid of macros private to this header file.
+ */
+
+#undef CurlchkszEQ
+#undef CurlchkszGE
+
+/*
+ * Get rid of macros not intended to exist beyond this point.
+ */
+
+#undef CURL_PULL_WS2TCPIP_H
+#undef CURL_PULL_SYS_TYPES_H
+#undef CURL_PULL_SYS_SOCKET_H
+#undef CURL_PULL_STDINT_H
+#undef CURL_PULL_INTTYPES_H
+
+#undef CURL_TYPEOF_CURL_SOCKLEN_T
+#undef CURL_TYPEOF_CURL_OFF_T
+
+#ifdef CURL_NO_OLDIES
+#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */
+#endif
+
+#endif /* __CURL_CURLRULES_H */
diff --git a/lib/mac32-gcc40/include/curl/curlver.h b/lib/mac32-gcc40/include/curl/curlver.h
new file mode 100644
index 0000000000000000000000000000000000000000..e345f56dfbfe13a9c9e8252ff88a2d848096e46d
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/curlver.h
@@ -0,0 +1,69 @@
+#ifndef __CURL_CURLVER_H
+#define __CURL_CURLVER_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* This header file contains nothing but libcurl version info, generated by
+ a script at release-time. This was made its own header file in 7.11.2 */
+
+/* This is the global package copyright */
+#define LIBCURL_COPYRIGHT "1996 - 2010 Daniel Stenberg, ."
+
+/* This is the version number of the libcurl package from which this header
+ file origins: */
+#define LIBCURL_VERSION "7.21.2"
+
+/* The numeric version number is also available "in parts" by using these
+ defines: */
+#define LIBCURL_VERSION_MAJOR 7
+#define LIBCURL_VERSION_MINOR 21
+#define LIBCURL_VERSION_PATCH 2
+
+/* This is the numeric version of the libcurl version number, meant for easier
+ parsing and comparions by programs. The LIBCURL_VERSION_NUM define will
+ always follow this syntax:
+
+ 0xXXYYZZ
+
+ Where XX, YY and ZZ are the main version, release and patch numbers in
+ hexadecimal (using 8 bits each). All three numbers are always represented
+ using two digits. 1.2 would appear as "0x010200" while version 9.11.7
+ appears as "0x090b07".
+
+ This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+ and it is always a greater number in a more recent release. It makes
+ comparisons with greater than and less than work.
+*/
+#define LIBCURL_VERSION_NUM 0x071502
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in git, as the timestamp is properly set in the
+ * tarballs by the maketgz script.
+ *
+ * The format of the date should follow this template:
+ *
+ * "Mon Feb 12 11:35:33 UTC 2007"
+ */
+#define LIBCURL_TIMESTAMP "Tue Oct 12 22:03:31 UTC 2010"
+
+#endif /* __CURL_CURLVER_H */
diff --git a/lib/mac32-gcc40/include/curl/easy.h b/lib/mac32-gcc40/include/curl/easy.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ddb4fe5a2cb476f1a1278b83c7b576135bd5aa9
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/easy.h
@@ -0,0 +1,102 @@
+#ifndef __CURL_EASY_H
+#define __CURL_EASY_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2008, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN CURL *curl_easy_init(void);
+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
+CURL_EXTERN void curl_easy_cleanup(CURL *curl);
+
+/*
+ * NAME curl_easy_getinfo()
+ *
+ * DESCRIPTION
+ *
+ * Request internal information from the curl session with this function. The
+ * third argument MUST be a pointer to a long, a pointer to a char * or a
+ * pointer to a double (as the documentation describes elsewhere). The data
+ * pointed to will be filled in accordingly and can be relied upon only if the
+ * function returns CURLE_OK. This function is intended to get used *AFTER* a
+ * performed transfer, all results from this function are undefined until the
+ * transfer is completed.
+ */
+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
+
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistant connections cannot
+ * be transfered. It is useful in multithreaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl);
+
+/*
+ * NAME curl_easy_reset()
+ *
+ * DESCRIPTION
+ *
+ * Re-initializes a CURL handle to the default values. This puts back the
+ * handle to the same state as it was in when it was just created.
+ *
+ * It does keep: live connections, the Session ID cache, the DNS cache and the
+ * cookies.
+ */
+CURL_EXTERN void curl_easy_reset(CURL *curl);
+
+/*
+ * NAME curl_easy_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
+ size_t *n);
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
+ size_t buflen, size_t *n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/mac32-gcc40/include/curl/mprintf.h b/lib/mac32-gcc40/include/curl/mprintf.h
new file mode 100644
index 0000000000000000000000000000000000000000..de7dd2f3c360e327e6280372e8a10f335fcf3504
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/mprintf.h
@@ -0,0 +1,81 @@
+#ifndef __CURL_MPRINTF_H
+#define __CURL_MPRINTF_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2006, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include
+#include /* needed for FILE */
+
+#include "curl.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN int curl_mprintf(const char *format, ...);
+CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...);
+CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...);
+CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
+ const char *format, ...);
+CURL_EXTERN int curl_mvprintf(const char *format, va_list args);
+CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args);
+CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args);
+CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
+ const char *format, va_list args);
+CURL_EXTERN char *curl_maprintf(const char *format, ...);
+CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
+
+#ifdef _MPRINTF_REPLACE
+# undef printf
+# undef fprintf
+# undef sprintf
+# undef vsprintf
+# undef snprintf
+# undef vprintf
+# undef vfprintf
+# undef vsnprintf
+# undef aprintf
+# undef vaprintf
+# define printf curl_mprintf
+# define fprintf curl_mfprintf
+#ifdef CURLDEBUG
+/* When built with CURLDEBUG we define away the sprintf() functions since we
+ don't want internal code to be using them */
+# define sprintf sprintf_was_used
+# define vsprintf vsprintf_was_used
+#else
+# define sprintf curl_msprintf
+# define vsprintf curl_mvsprintf
+#endif
+# define snprintf curl_msnprintf
+# define vprintf curl_mvprintf
+# define vfprintf curl_mvfprintf
+# define vsnprintf curl_mvsnprintf
+# define aprintf curl_maprintf
+# define vaprintf curl_mvaprintf
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CURL_MPRINTF_H */
diff --git a/lib/mac32-gcc40/include/curl/multi.h b/lib/mac32-gcc40/include/curl/multi.h
new file mode 100644
index 0000000000000000000000000000000000000000..f96566669c6771fbbf2e1735f826d8cb3a1fce11
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/multi.h
@@ -0,0 +1,345 @@
+#ifndef __CURL_MULTI_H
+#define __CURL_MULTI_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2007, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+/*
+ This is an "external" header file. Don't give away any internals here!
+
+ GOALS
+
+ o Enable a "pull" interface. The application that uses libcurl decides where
+ and when to ask libcurl to get/send data.
+
+ o Enable multiple simultaneous transfers in the same thread without making it
+ complicated for the application.
+
+ o Enable the application to select() on its own file descriptors and curl's
+ file descriptors simultaneous easily.
+
+*/
+
+/*
+ * This header file should not really need to include "curl.h" since curl.h
+ * itself includes this file and we expect user applications to do #include
+ * without the need for especially including multi.h.
+ *
+ * For some reason we added this include here at one point, and rather than to
+ * break existing (wrongly written) libcurl applications, we leave it as-is
+ * but with this warning attached.
+ */
+#include "curl.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void CURLM;
+
+typedef enum {
+ CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or
+ curl_multi_socket*() soon */
+ CURLM_OK,
+ CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */
+ CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
+ CURLM_OUT_OF_MEMORY, /* if you ever get this, you're in deep sh*t */
+ CURLM_INTERNAL_ERROR, /* this is a libcurl bug */
+ CURLM_BAD_SOCKET, /* the passed in socket argument did not match */
+ CURLM_UNKNOWN_OPTION, /* curl_multi_setopt() with unsupported option */
+ CURLM_LAST
+} CURLMcode;
+
+/* just to make code nicer when using curl_multi_socket() you can now check
+ for CURLM_CALL_MULTI_SOCKET too in the same style it works for
+ curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */
+#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM
+
+typedef enum {
+ CURLMSG_NONE, /* first, not used */
+ CURLMSG_DONE, /* This easy handle has completed. 'result' contains
+ the CURLcode of the transfer */
+ CURLMSG_LAST /* last, not used */
+} CURLMSG;
+
+struct CURLMsg {
+ CURLMSG msg; /* what this message means */
+ CURL *easy_handle; /* the handle it concerns */
+ union {
+ void *whatever; /* message-specific data */
+ CURLcode result; /* return code for transfer */
+ } data;
+};
+typedef struct CURLMsg CURLMsg;
+
+/*
+ * Name: curl_multi_init()
+ *
+ * Desc: inititalize multi-style curl usage
+ *
+ * Returns: a new CURLM handle to use in all 'curl_multi' functions.
+ */
+CURL_EXTERN CURLM *curl_multi_init(void);
+
+/*
+ * Name: curl_multi_add_handle()
+ *
+ * Desc: add a standard curl handle to the multi stack
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+ CURL *curl_handle);
+
+ /*
+ * Name: curl_multi_remove_handle()
+ *
+ * Desc: removes a curl handle from the multi stack again
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+ CURL *curl_handle);
+
+ /*
+ * Name: curl_multi_fdset()
+ *
+ * Desc: Ask curl for its fd_set sets. The app can use these to select() or
+ * poll() on. We want curl_multi_perform() called as soon as one of
+ * them are ready.
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
+ fd_set *read_fd_set,
+ fd_set *write_fd_set,
+ fd_set *exc_fd_set,
+ int *max_fd);
+
+ /*
+ * Name: curl_multi_perform()
+ *
+ * Desc: When the app thinks there's data available for curl it calls this
+ * function to read/write whatever there is right now. This returns
+ * as soon as the reads and writes are done. This function does not
+ * require that there actually is data available for reading or that
+ * data can be written, it can be called just in case. It returns
+ * the number of handles that still transfer data in the second
+ * argument's integer-pointer.
+ *
+ * Returns: CURLMcode type, general multi error code. *NOTE* that this only
+ * returns errors etc regarding the whole multi stack. There might
+ * still have occurred problems on invidual transfers even when this
+ * returns OK.
+ */
+CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
+ int *running_handles);
+
+ /*
+ * Name: curl_multi_cleanup()
+ *
+ * Desc: Cleans up and removes a whole multi stack. It does not free or
+ * touch any individual easy handles in any way. We need to define
+ * in what state those handles will be if this function is called
+ * in the middle of a transfer.
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
+
+/*
+ * Name: curl_multi_info_read()
+ *
+ * Desc: Ask the multi handle if there's any messages/informationals from
+ * the individual transfers. Messages include informationals such as
+ * error code from the transfer or just the fact that a transfer is
+ * completed. More details on these should be written down as well.
+ *
+ * Repeated calls to this function will return a new struct each
+ * time, until a special "end of msgs" struct is returned as a signal
+ * that there is no more to get at this point.
+ *
+ * The data the returned pointer points to will not survive calling
+ * curl_multi_cleanup().
+ *
+ * The 'CURLMsg' struct is meant to be very simple and only contain
+ * very basic informations. If more involved information is wanted,
+ * we will provide the particular "transfer handle" in that struct
+ * and that should/could/would be used in subsequent
+ * curl_easy_getinfo() calls (or similar). The point being that we
+ * must never expose complex structs to applications, as then we'll
+ * undoubtably get backwards compatibility problems in the future.
+ *
+ * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
+ * of structs. It also writes the number of messages left in the
+ * queue (after this read) in the integer the second argument points
+ * to.
+ */
+CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
+ int *msgs_in_queue);
+
+/*
+ * Name: curl_multi_strerror()
+ *
+ * Desc: The curl_multi_strerror function may be used to turn a CURLMcode
+ * value into the equivalent human readable error string. This is
+ * useful for printing meaningful error messages.
+ *
+ * Returns: A pointer to a zero-terminated error message.
+ */
+CURL_EXTERN const char *curl_multi_strerror(CURLMcode);
+
+/*
+ * Name: curl_multi_socket() and
+ * curl_multi_socket_all()
+ *
+ * Desc: An alternative version of curl_multi_perform() that allows the
+ * application to pass in one of the file descriptors that have been
+ * detected to have "action" on them and let libcurl perform.
+ * See man page for details.
+ */
+#define CURL_POLL_NONE 0
+#define CURL_POLL_IN 1
+#define CURL_POLL_OUT 2
+#define CURL_POLL_INOUT 3
+#define CURL_POLL_REMOVE 4
+
+#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD
+
+#define CURL_CSELECT_IN 0x01
+#define CURL_CSELECT_OUT 0x02
+#define CURL_CSELECT_ERR 0x04
+
+typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */
+ curl_socket_t s, /* socket */
+ int what, /* see above */
+ void *userp, /* private callback
+ pointer */
+ void *socketp); /* private socket
+ pointer */
+/*
+ * Name: curl_multi_timer_callback
+ *
+ * Desc: Called by libcurl whenever the library detects a change in the
+ * maximum number of milliseconds the app is allowed to wait before
+ * curl_multi_socket() or curl_multi_perform() must be called
+ * (to allow libcurl's timed events to take place).
+ *
+ * Returns: The callback should return zero.
+ */
+typedef int (*curl_multi_timer_callback)(CURLM *multi, /* multi handle */
+ long timeout_ms, /* see above */
+ void *userp); /* private callback
+ pointer */
+
+CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s,
+ int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
+ curl_socket_t s,
+ int ev_bitmask,
+ int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle,
+ int *running_handles);
+
+#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
+/* This macro below was added in 7.16.3 to push users who recompile to use
+ the new curl_multi_socket_action() instead of the old curl_multi_socket()
+*/
+#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z)
+#endif
+
+/*
+ * Name: curl_multi_timeout()
+ *
+ * Desc: Returns the maximum number of milliseconds the app is allowed to
+ * wait before curl_multi_socket() or curl_multi_perform() must be
+ * called (to allow libcurl's timed events to take place).
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
+ long *milliseconds);
+
+#undef CINIT /* re-using the same name as in curl.h */
+
+#ifdef CURL_ISOCPP
+#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define LONG CURLOPTTYPE_LONG
+#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT
+#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
+#define OFF_T CURLOPTTYPE_OFF_T
+#define CINIT(name,type,number) CURLMOPT_/**/name = type + number
+#endif
+
+typedef enum {
+ /* This is the socket callback function pointer */
+ CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1),
+
+ /* This is the argument passed to the socket callback */
+ CINIT(SOCKETDATA, OBJECTPOINT, 2),
+
+ /* set to 1 to enable pipelining for this multi handle */
+ CINIT(PIPELINING, LONG, 3),
+
+ /* This is the timer callback function pointer */
+ CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4),
+
+ /* This is the argument passed to the timer callback */
+ CINIT(TIMERDATA, OBJECTPOINT, 5),
+
+ /* maximum number of entries in the connection cache */
+ CINIT(MAXCONNECTS, LONG, 6),
+
+ CURLMOPT_LASTENTRY /* the last unused */
+} CURLMoption;
+
+
+/*
+ * Name: curl_multi_setopt()
+ *
+ * Desc: Sets options for the multi handle.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
+ CURLMoption option, ...);
+
+
+/*
+ * Name: curl_multi_assign()
+ *
+ * Desc: This function sets an association in the multi handle between the
+ * given socket and a private pointer of the application. This is
+ * (only) useful for curl_multi_socket uses.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
+ curl_socket_t sockfd, void *sockp);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif
diff --git a/lib/mac32-gcc40/include/curl/stdcheaders.h b/lib/mac32-gcc40/include/curl/stdcheaders.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad82ef6335d6167aecf8b9e49d68c462ea028bfd
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/stdcheaders.h
@@ -0,0 +1,33 @@
+#ifndef __STDC_HEADERS_H
+#define __STDC_HEADERS_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include
+
+size_t fread (void *, size_t, size_t, FILE *);
+size_t fwrite (const void *, size_t, size_t, FILE *);
+
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, size_t);
+
+#endif /* __STDC_HEADERS_H */
diff --git a/lib/mac32-gcc40/include/curl/typecheck-gcc.h b/lib/mac32-gcc40/include/curl/typecheck-gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6f74a95840326a9156032507a7844cca76ad683
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/typecheck-gcc.h
@@ -0,0 +1,584 @@
+#ifndef __CURL_TYPECHECK_GCC_H
+#define __CURL_TYPECHECK_GCC_H
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* wraps curl_easy_setopt() with typechecking */
+
+/* To add a new kind of warning, add an
+ * if(_curl_is_sometype_option(_curl_opt))
+ * if(!_curl_is_sometype(value))
+ * _curl_easy_setopt_err_sometype();
+ * block and define _curl_is_sometype_option, _curl_is_sometype and
+ * _curl_easy_setopt_err_sometype below
+ *
+ * NOTE: We use two nested 'if' statements here instead of the && operator, in
+ * order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x
+ * when compiling with -Wlogical-op.
+ *
+ * To add an option that uses the same type as an existing option, you'll just
+ * need to extend the appropriate _curl_*_option macro
+ */
+#define curl_easy_setopt(handle, option, value) \
+__extension__ ({ \
+ __typeof__ (option) _curl_opt = option; \
+ if (__builtin_constant_p(_curl_opt)) { \
+ if (_curl_is_long_option(_curl_opt)) \
+ if (!_curl_is_long(value)) \
+ _curl_easy_setopt_err_long(); \
+ if (_curl_is_off_t_option(_curl_opt)) \
+ if (!_curl_is_off_t(value)) \
+ _curl_easy_setopt_err_curl_off_t(); \
+ if (_curl_is_string_option(_curl_opt)) \
+ if (!_curl_is_string(value)) \
+ _curl_easy_setopt_err_string(); \
+ if (_curl_is_write_cb_option(_curl_opt)) \
+ if (!_curl_is_write_cb(value)) \
+ _curl_easy_setopt_err_write_callback(); \
+ if ((_curl_opt) == CURLOPT_READFUNCTION) \
+ if (!_curl_is_read_cb(value)) \
+ _curl_easy_setopt_err_read_cb(); \
+ if ((_curl_opt) == CURLOPT_IOCTLFUNCTION) \
+ if (!_curl_is_ioctl_cb(value)) \
+ _curl_easy_setopt_err_ioctl_cb(); \
+ if ((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \
+ if (!_curl_is_sockopt_cb(value)) \
+ _curl_easy_setopt_err_sockopt_cb(); \
+ if ((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \
+ if (!_curl_is_opensocket_cb(value)) \
+ _curl_easy_setopt_err_opensocket_cb(); \
+ if ((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \
+ if (!_curl_is_progress_cb(value)) \
+ _curl_easy_setopt_err_progress_cb(); \
+ if ((_curl_opt) == CURLOPT_DEBUGFUNCTION) \
+ if (!_curl_is_debug_cb(value)) \
+ _curl_easy_setopt_err_debug_cb(); \
+ if ((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \
+ if (!_curl_is_ssl_ctx_cb(value)) \
+ _curl_easy_setopt_err_ssl_ctx_cb(); \
+ if (_curl_is_conv_cb_option(_curl_opt)) \
+ if (!_curl_is_conv_cb(value)) \
+ _curl_easy_setopt_err_conv_cb(); \
+ if ((_curl_opt) == CURLOPT_SEEKFUNCTION) \
+ if (!_curl_is_seek_cb(value)) \
+ _curl_easy_setopt_err_seek_cb(); \
+ if (_curl_is_cb_data_option(_curl_opt)) \
+ if (!_curl_is_cb_data(value)) \
+ _curl_easy_setopt_err_cb_data(); \
+ if ((_curl_opt) == CURLOPT_ERRORBUFFER) \
+ if (!_curl_is_error_buffer(value)) \
+ _curl_easy_setopt_err_error_buffer(); \
+ if ((_curl_opt) == CURLOPT_STDERR) \
+ if (!_curl_is_FILE(value)) \
+ _curl_easy_setopt_err_FILE(); \
+ if (_curl_is_postfields_option(_curl_opt)) \
+ if (!_curl_is_postfields(value)) \
+ _curl_easy_setopt_err_postfields(); \
+ if ((_curl_opt) == CURLOPT_HTTPPOST) \
+ if (!_curl_is_arr((value), struct curl_httppost)) \
+ _curl_easy_setopt_err_curl_httpost(); \
+ if (_curl_is_slist_option(_curl_opt)) \
+ if (!_curl_is_arr((value), struct curl_slist)) \
+ _curl_easy_setopt_err_curl_slist(); \
+ if ((_curl_opt) == CURLOPT_SHARE) \
+ if (!_curl_is_ptr((value), CURLSH)) \
+ _curl_easy_setopt_err_CURLSH(); \
+ } \
+ curl_easy_setopt(handle, _curl_opt, value); \
+})
+
+/* wraps curl_easy_getinfo() with typechecking */
+/* FIXME: don't allow const pointers */
+#define curl_easy_getinfo(handle, info, arg) \
+__extension__ ({ \
+ __typeof__ (info) _curl_info = info; \
+ if (__builtin_constant_p(_curl_info)) { \
+ if (_curl_is_string_info(_curl_info)) \
+ if (!_curl_is_arr((arg), char *)) \
+ _curl_easy_getinfo_err_string(); \
+ if (_curl_is_long_info(_curl_info)) \
+ if (!_curl_is_arr((arg), long)) \
+ _curl_easy_getinfo_err_long(); \
+ if (_curl_is_double_info(_curl_info)) \
+ if (!_curl_is_arr((arg), double)) \
+ _curl_easy_getinfo_err_double(); \
+ if (_curl_is_slist_info(_curl_info)) \
+ if (!_curl_is_arr((arg), struct curl_slist *)) \
+ _curl_easy_getinfo_err_curl_slist(); \
+ } \
+ curl_easy_getinfo(handle, _curl_info, arg); \
+})
+
+/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(),
+ * for now just make sure that the functions are called with three
+ * arguments
+ */
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
+
+
+/* the actual warnings, triggered by calling the _curl_easy_setopt_err*
+ * functions */
+
+/* To define a new warning, use _CURL_WARNING(identifier, "message") */
+#define _CURL_WARNING(id, message) \
+ static void __attribute__((warning(message))) __attribute__((unused)) \
+ __attribute__((noinline)) id(void) { __asm__(""); }
+
+_CURL_WARNING(_curl_easy_setopt_err_long,
+ "curl_easy_setopt expects a long argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_off_t,
+ "curl_easy_setopt expects a curl_off_t argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_string,
+ "curl_easy_setopt expects a string (char* or char[]) argument for this option"
+ )
+_CURL_WARNING(_curl_easy_setopt_err_write_callback,
+ "curl_easy_setopt expects a curl_write_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_read_cb,
+ "curl_easy_setopt expects a curl_read_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb,
+ "curl_easy_setopt expects a curl_ioctl_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb,
+ "curl_easy_setopt expects a curl_sockopt_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb,
+ "curl_easy_setopt expects a curl_opensocket_callback argument for this option"
+ )
+_CURL_WARNING(_curl_easy_setopt_err_progress_cb,
+ "curl_easy_setopt expects a curl_progress_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_debug_cb,
+ "curl_easy_setopt expects a curl_debug_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb,
+ "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_conv_cb,
+ "curl_easy_setopt expects a curl_conv_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_seek_cb,
+ "curl_easy_setopt expects a curl_seek_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_cb_data,
+ "curl_easy_setopt expects a private data pointer as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_error_buffer,
+ "curl_easy_setopt expects a char buffer of CURL_ERROR_SIZE as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_FILE,
+ "curl_easy_setopt expects a FILE* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_postfields,
+ "curl_easy_setopt expects a void* or char* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_httpost,
+ "curl_easy_setopt expects a struct curl_httppost* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_slist,
+ "curl_easy_setopt expects a struct curl_slist* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_CURLSH,
+ "curl_easy_setopt expects a CURLSH* argument for this option")
+
+_CURL_WARNING(_curl_easy_getinfo_err_string,
+ "curl_easy_getinfo expects a pointer to char * for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_long,
+ "curl_easy_getinfo expects a pointer to long for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_double,
+ "curl_easy_getinfo expects a pointer to double for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_curl_slist,
+ "curl_easy_getinfo expects a pointer to struct curl_slist * for this info")
+
+/* groups of curl_easy_setops options that take the same type of argument */
+
+/* To add a new option to one of the groups, just add
+ * (option) == CURLOPT_SOMETHING
+ * to the or-expression. If the option takes a long or curl_off_t, you don't
+ * have to do anything
+ */
+
+/* evaluates to true if option takes a long argument */
+#define _curl_is_long_option(option) \
+ (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
+
+#define _curl_is_off_t_option(option) \
+ ((option) > CURLOPTTYPE_OFF_T)
+
+/* evaluates to true if option takes a char* argument */
+#define _curl_is_string_option(option) \
+ ((option) == CURLOPT_URL || \
+ (option) == CURLOPT_PROXY || \
+ (option) == CURLOPT_INTERFACE || \
+ (option) == CURLOPT_NETRC_FILE || \
+ (option) == CURLOPT_USERPWD || \
+ (option) == CURLOPT_USERNAME || \
+ (option) == CURLOPT_PASSWORD || \
+ (option) == CURLOPT_PROXYUSERPWD || \
+ (option) == CURLOPT_PROXYUSERNAME || \
+ (option) == CURLOPT_PROXYPASSWORD || \
+ (option) == CURLOPT_NOPROXY || \
+ (option) == CURLOPT_ENCODING || \
+ (option) == CURLOPT_REFERER || \
+ (option) == CURLOPT_USERAGENT || \
+ (option) == CURLOPT_COOKIE || \
+ (option) == CURLOPT_COOKIEFILE || \
+ (option) == CURLOPT_COOKIEJAR || \
+ (option) == CURLOPT_COOKIELIST || \
+ (option) == CURLOPT_FTPPORT || \
+ (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \
+ (option) == CURLOPT_FTP_ACCOUNT || \
+ (option) == CURLOPT_RANGE || \
+ (option) == CURLOPT_CUSTOMREQUEST || \
+ (option) == CURLOPT_SSLCERT || \
+ (option) == CURLOPT_SSLCERTTYPE || \
+ (option) == CURLOPT_SSLKEY || \
+ (option) == CURLOPT_SSLKEYTYPE || \
+ (option) == CURLOPT_KEYPASSWD || \
+ (option) == CURLOPT_SSLENGINE || \
+ (option) == CURLOPT_CAINFO || \
+ (option) == CURLOPT_CAPATH || \
+ (option) == CURLOPT_RANDOM_FILE || \
+ (option) == CURLOPT_EGDSOCKET || \
+ (option) == CURLOPT_SSL_CIPHER_LIST || \
+ (option) == CURLOPT_KRBLEVEL || \
+ (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \
+ (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \
+ (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \
+ (option) == CURLOPT_CRLFILE || \
+ (option) == CURLOPT_ISSUERCERT || \
+ (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \
+ (option) == CURLOPT_SSH_KNOWNHOSTS || \
+ (option) == CURLOPT_MAIL_FROM || \
+ (option) == CURLOPT_RTSP_SESSION_ID || \
+ (option) == CURLOPT_RTSP_STREAM_URI || \
+ (option) == CURLOPT_RTSP_TRANSPORT || \
+ 0)
+
+/* evaluates to true if option takes a curl_write_callback argument */
+#define _curl_is_write_cb_option(option) \
+ ((option) == CURLOPT_HEADERFUNCTION || \
+ (option) == CURLOPT_WRITEFUNCTION)
+
+/* evaluates to true if option takes a curl_conv_callback argument */
+#define _curl_is_conv_cb_option(option) \
+ ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION || \
+ (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION || \
+ (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION)
+
+/* evaluates to true if option takes a data argument to pass to a callback */
+#define _curl_is_cb_data_option(option) \
+ ((option) == CURLOPT_WRITEDATA || \
+ (option) == CURLOPT_READDATA || \
+ (option) == CURLOPT_IOCTLDATA || \
+ (option) == CURLOPT_SOCKOPTDATA || \
+ (option) == CURLOPT_OPENSOCKETDATA || \
+ (option) == CURLOPT_PROGRESSDATA || \
+ (option) == CURLOPT_WRITEHEADER || \
+ (option) == CURLOPT_DEBUGDATA || \
+ (option) == CURLOPT_SSL_CTX_DATA || \
+ (option) == CURLOPT_SEEKDATA || \
+ (option) == CURLOPT_PRIVATE || \
+ (option) == CURLOPT_SSH_KEYDATA || \
+ (option) == CURLOPT_INTERLEAVEDATA || \
+ (option) == CURLOPT_CHUNK_DATA || \
+ (option) == CURLOPT_FNMATCH_DATA || \
+ 0)
+
+/* evaluates to true if option takes a POST data argument (void* or char*) */
+#define _curl_is_postfields_option(option) \
+ ((option) == CURLOPT_POSTFIELDS || \
+ (option) == CURLOPT_COPYPOSTFIELDS || \
+ 0)
+
+/* evaluates to true if option takes a struct curl_slist * argument */
+#define _curl_is_slist_option(option) \
+ ((option) == CURLOPT_HTTPHEADER || \
+ (option) == CURLOPT_HTTP200ALIASES || \
+ (option) == CURLOPT_QUOTE || \
+ (option) == CURLOPT_POSTQUOTE || \
+ (option) == CURLOPT_PREQUOTE || \
+ (option) == CURLOPT_TELNETOPTIONS || \
+ (option) == CURLOPT_MAIL_RCPT || \
+ 0)
+
+/* groups of curl_easy_getinfo infos that take the same type of argument */
+
+/* evaluates to true if info expects a pointer to char * argument */
+#define _curl_is_string_info(info) \
+ (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG)
+
+/* evaluates to true if info expects a pointer to long argument */
+#define _curl_is_long_info(info) \
+ (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE)
+
+/* evaluates to true if info expects a pointer to double argument */
+#define _curl_is_double_info(info) \
+ (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST)
+
+/* true if info expects a pointer to struct curl_slist * argument */
+#define _curl_is_slist_info(info) \
+ (CURLINFO_SLIST < (info))
+
+
+/* typecheck helpers -- check whether given expression has requested type*/
+
+/* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros,
+ * otherwise define a new macro. Search for __builtin_types_compatible_p
+ * in the GCC manual.
+ * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is
+ * the actual expression passed to the curl_easy_setopt macro. This
+ * means that you can only apply the sizeof and __typeof__ operators, no
+ * == or whatsoever.
+ */
+
+/* XXX: should evaluate to true iff expr is a pointer */
+#define _curl_is_any_ptr(expr) \
+ (sizeof(expr) == sizeof(void*))
+
+/* evaluates to true if expr is NULL */
+/* XXX: must not evaluate expr, so this check is not accurate */
+#define _curl_is_NULL(expr) \
+ (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL)))
+
+/* evaluates to true if expr is type*, const type* or NULL */
+#define _curl_is_ptr(expr, type) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), type *) || \
+ __builtin_types_compatible_p(__typeof__(expr), const type *))
+
+/* evaluates to true if expr is one of type[], type*, NULL or const type* */
+#define _curl_is_arr(expr, type) \
+ (_curl_is_ptr((expr), type) || \
+ __builtin_types_compatible_p(__typeof__(expr), type []))
+
+/* evaluates to true if expr is a string */
+#define _curl_is_string(expr) \
+ (_curl_is_arr((expr), char) || \
+ _curl_is_arr((expr), signed char) || \
+ _curl_is_arr((expr), unsigned char))
+
+/* evaluates to true if expr is a long (no matter the signedness)
+ * XXX: for now, int is also accepted (and therefore short and char, which
+ * are promoted to int when passed to a variadic function) */
+#define _curl_is_long(expr) \
+ (__builtin_types_compatible_p(__typeof__(expr), long) || \
+ __builtin_types_compatible_p(__typeof__(expr), signed long) || \
+ __builtin_types_compatible_p(__typeof__(expr), unsigned long) || \
+ __builtin_types_compatible_p(__typeof__(expr), int) || \
+ __builtin_types_compatible_p(__typeof__(expr), signed int) || \
+ __builtin_types_compatible_p(__typeof__(expr), unsigned int) || \
+ __builtin_types_compatible_p(__typeof__(expr), short) || \
+ __builtin_types_compatible_p(__typeof__(expr), signed short) || \
+ __builtin_types_compatible_p(__typeof__(expr), unsigned short) || \
+ __builtin_types_compatible_p(__typeof__(expr), char) || \
+ __builtin_types_compatible_p(__typeof__(expr), signed char) || \
+ __builtin_types_compatible_p(__typeof__(expr), unsigned char))
+
+/* evaluates to true if expr is of type curl_off_t */
+#define _curl_is_off_t(expr) \
+ (__builtin_types_compatible_p(__typeof__(expr), curl_off_t))
+
+/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */
+/* XXX: also check size of an char[] array? */
+#define _curl_is_error_buffer(expr) \
+ (__builtin_types_compatible_p(__typeof__(expr), char *) || \
+ __builtin_types_compatible_p(__typeof__(expr), char[]))
+
+/* evaluates to true if expr is of type (const) void* or (const) FILE* */
+#if 0
+#define _curl_is_cb_data(expr) \
+ (_curl_is_ptr((expr), void) || \
+ _curl_is_ptr((expr), FILE))
+#else /* be less strict */
+#define _curl_is_cb_data(expr) \
+ _curl_is_any_ptr(expr)
+#endif
+
+/* evaluates to true if expr is of type FILE* */
+#define _curl_is_FILE(expr) \
+ (__builtin_types_compatible_p(__typeof__(expr), FILE *))
+
+/* evaluates to true if expr can be passed as POST data (void* or char*) */
+#define _curl_is_postfields(expr) \
+ (_curl_is_ptr((expr), void) || \
+ _curl_is_arr((expr), char))
+
+/* FIXME: the whole callback checking is messy...
+ * The idea is to tolerate char vs. void and const vs. not const
+ * pointers in arguments at least
+ */
+/* helper: __builtin_types_compatible_p distinguishes between functions and
+ * function pointers, hide it */
+#define _curl_callback_compatible(func, type) \
+ (__builtin_types_compatible_p(__typeof__(func), type) || \
+ __builtin_types_compatible_p(__typeof__(func), type*))
+
+/* evaluates to true if expr is of type curl_read_callback or "similar" */
+#define _curl_is_read_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) || \
+ _curl_callback_compatible((expr), _curl_read_callback1) || \
+ _curl_callback_compatible((expr), _curl_read_callback2) || \
+ _curl_callback_compatible((expr), _curl_read_callback3) || \
+ _curl_callback_compatible((expr), _curl_read_callback4) || \
+ _curl_callback_compatible((expr), _curl_read_callback5) || \
+ _curl_callback_compatible((expr), _curl_read_callback6))
+typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void*);
+typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void*);
+typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE*);
+typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void*);
+typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void*);
+typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE*);
+
+/* evaluates to true if expr is of type curl_write_callback or "similar" */
+#define _curl_is_write_cb(expr) \
+ (_curl_is_read_cb(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) || \
+ _curl_callback_compatible((expr), _curl_write_callback1) || \
+ _curl_callback_compatible((expr), _curl_write_callback2) || \
+ _curl_callback_compatible((expr), _curl_write_callback3) || \
+ _curl_callback_compatible((expr), _curl_write_callback4) || \
+ _curl_callback_compatible((expr), _curl_write_callback5) || \
+ _curl_callback_compatible((expr), _curl_write_callback6))
+typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void*);
+typedef size_t (_curl_write_callback2)(const char *, size_t, size_t,
+ const void*);
+typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE*);
+typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void*);
+typedef size_t (_curl_write_callback5)(const void *, size_t, size_t,
+ const void*);
+typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE*);
+
+/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */
+#define _curl_is_ioctl_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) || \
+ _curl_callback_compatible((expr), _curl_ioctl_callback1) || \
+ _curl_callback_compatible((expr), _curl_ioctl_callback2) || \
+ _curl_callback_compatible((expr), _curl_ioctl_callback3) || \
+ _curl_callback_compatible((expr), _curl_ioctl_callback4))
+typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void*);
+typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void*);
+typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void*);
+typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void*);
+
+/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */
+#define _curl_is_sockopt_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) || \
+ _curl_callback_compatible((expr), _curl_sockopt_callback1) || \
+ _curl_callback_compatible((expr), _curl_sockopt_callback2))
+typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype);
+typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t,
+ curlsocktype);
+
+/* evaluates to true if expr is of type curl_opensocket_callback or "similar" */
+#define _curl_is_opensocket_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\
+ _curl_callback_compatible((expr), _curl_opensocket_callback1) || \
+ _curl_callback_compatible((expr), _curl_opensocket_callback2) || \
+ _curl_callback_compatible((expr), _curl_opensocket_callback3) || \
+ _curl_callback_compatible((expr), _curl_opensocket_callback4))
+typedef curl_socket_t (_curl_opensocket_callback1)
+ (void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback2)
+ (void *, curlsocktype, const struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback3)
+ (const void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback4)
+ (const void *, curlsocktype, const struct curl_sockaddr *);
+
+/* evaluates to true if expr is of type curl_progress_callback or "similar" */
+#define _curl_is_progress_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) || \
+ _curl_callback_compatible((expr), _curl_progress_callback1) || \
+ _curl_callback_compatible((expr), _curl_progress_callback2))
+typedef int (_curl_progress_callback1)(void *,
+ double, double, double, double);
+typedef int (_curl_progress_callback2)(const void *,
+ double, double, double, double);
+
+/* evaluates to true if expr is of type curl_debug_callback or "similar" */
+#define _curl_is_debug_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) || \
+ _curl_callback_compatible((expr), _curl_debug_callback1) || \
+ _curl_callback_compatible((expr), _curl_debug_callback2) || \
+ _curl_callback_compatible((expr), _curl_debug_callback3) || \
+ _curl_callback_compatible((expr), _curl_debug_callback4))
+typedef int (_curl_debug_callback1) (CURL *,
+ curl_infotype, char *, size_t, void *);
+typedef int (_curl_debug_callback2) (CURL *,
+ curl_infotype, char *, size_t, const void *);
+typedef int (_curl_debug_callback3) (CURL *,
+ curl_infotype, const char *, size_t, void *);
+typedef int (_curl_debug_callback4) (CURL *,
+ curl_infotype, const char *, size_t, const void *);
+
+/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */
+/* this is getting even messier... */
+#define _curl_is_ssl_ctx_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) || \
+ _curl_callback_compatible((expr), _curl_ssl_ctx_callback8))
+typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *);
+#ifdef HEADER_SSL_H
+/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX
+ * this will of course break if we're included before OpenSSL headers...
+ */
+typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX, const void *);
+#else
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8;
+#endif
+
+/* evaluates to true if expr is of type curl_conv_callback or "similar" */
+#define _curl_is_conv_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) || \
+ _curl_callback_compatible((expr), _curl_conv_callback1) || \
+ _curl_callback_compatible((expr), _curl_conv_callback2) || \
+ _curl_callback_compatible((expr), _curl_conv_callback3) || \
+ _curl_callback_compatible((expr), _curl_conv_callback4))
+typedef CURLcode (*_curl_conv_callback1)(char *, size_t length);
+typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length);
+typedef CURLcode (*_curl_conv_callback3)(void *, size_t length);
+typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length);
+
+/* evaluates to true if expr is of type curl_seek_callback or "similar" */
+#define _curl_is_seek_cb(expr) \
+ (_curl_is_NULL(expr) || \
+ __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) || \
+ _curl_callback_compatible((expr), _curl_seek_callback1) || \
+ _curl_callback_compatible((expr), _curl_seek_callback2))
+typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int);
+typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int);
+
+
+#endif /* __CURL_TYPECHECK_GCC_H */
diff --git a/lib/mac32-gcc40/include/curl/types.h b/lib/mac32-gcc40/include/curl/types.h
new file mode 100644
index 0000000000000000000000000000000000000000..d37d6ae9e11e48d3f8aaba1957015a03f7f12c63
--- /dev/null
+++ b/lib/mac32-gcc40/include/curl/types.h
@@ -0,0 +1 @@
+/* not used */
diff --git a/lib/mac32-gcc40/include/expat.h b/lib/mac32-gcc40/include/expat.h
new file mode 100644
index 0000000000000000000000000000000000000000..20a8278f78d2ab6990152da4ecd67e16e02ef00e
--- /dev/null
+++ b/lib/mac32-gcc40/include/expat.h
@@ -0,0 +1,1014 @@
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+ See the file COPYING for copying permission.
+*/
+
+#ifndef Expat_INCLUDED
+#define Expat_INCLUDED 1
+
+#ifdef __VMS
+/* 0 1 2 3 0 1 2 3
+ 1234567890123456789012345678901 1234567890123456789012345678901 */
+#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler
+#define XML_SetUnparsedEntityDeclHandler XML_SetUnparsedEntDeclHandler
+#define XML_SetStartNamespaceDeclHandler XML_SetStartNamespcDeclHandler
+#define XML_SetExternalEntityRefHandlerArg XML_SetExternalEntRefHandlerArg
+#endif
+
+#include
+#include "expat_external.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct XML_ParserStruct;
+typedef struct XML_ParserStruct *XML_Parser;
+
+/* Should this be defined using stdbool.h when C99 is available? */
+typedef unsigned char XML_Bool;
+#define XML_TRUE ((XML_Bool) 1)
+#define XML_FALSE ((XML_Bool) 0)
+
+/* The XML_Status enum gives the possible return values for several
+ API functions. The preprocessor #defines are included so this
+ stanza can be added to code that still needs to support older
+ versions of Expat 1.95.x:
+
+ #ifndef XML_STATUS_OK
+ #define XML_STATUS_OK 1
+ #define XML_STATUS_ERROR 0
+ #endif
+
+ Otherwise, the #define hackery is quite ugly and would have been
+ dropped.
+*/
+enum XML_Status {
+ XML_STATUS_ERROR = 0,
+#define XML_STATUS_ERROR XML_STATUS_ERROR
+ XML_STATUS_OK = 1,
+#define XML_STATUS_OK XML_STATUS_OK
+ XML_STATUS_SUSPENDED = 2
+#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
+};
+
+enum XML_Error {
+ XML_ERROR_NONE,
+ XML_ERROR_NO_MEMORY,
+ XML_ERROR_SYNTAX,
+ XML_ERROR_NO_ELEMENTS,
+ XML_ERROR_INVALID_TOKEN,
+ XML_ERROR_UNCLOSED_TOKEN,
+ XML_ERROR_PARTIAL_CHAR,
+ XML_ERROR_TAG_MISMATCH,
+ XML_ERROR_DUPLICATE_ATTRIBUTE,
+ XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
+ XML_ERROR_PARAM_ENTITY_REF,
+ XML_ERROR_UNDEFINED_ENTITY,
+ XML_ERROR_RECURSIVE_ENTITY_REF,
+ XML_ERROR_ASYNC_ENTITY,
+ XML_ERROR_BAD_CHAR_REF,
+ XML_ERROR_BINARY_ENTITY_REF,
+ XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+ XML_ERROR_MISPLACED_XML_PI,
+ XML_ERROR_UNKNOWN_ENCODING,
+ XML_ERROR_INCORRECT_ENCODING,
+ XML_ERROR_UNCLOSED_CDATA_SECTION,
+ XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+ XML_ERROR_NOT_STANDALONE,
+ XML_ERROR_UNEXPECTED_STATE,
+ XML_ERROR_ENTITY_DECLARED_IN_PE,
+ XML_ERROR_FEATURE_REQUIRES_XML_DTD,
+ XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
+ /* Added in 1.95.7. */
+ XML_ERROR_UNBOUND_PREFIX,
+ /* Added in 1.95.8. */
+ XML_ERROR_UNDECLARING_PREFIX,
+ XML_ERROR_INCOMPLETE_PE,
+ XML_ERROR_XML_DECL,
+ XML_ERROR_TEXT_DECL,
+ XML_ERROR_PUBLICID,
+ XML_ERROR_SUSPENDED,
+ XML_ERROR_NOT_SUSPENDED,
+ XML_ERROR_ABORTED,
+ XML_ERROR_FINISHED,
+ XML_ERROR_SUSPEND_PE,
+ /* Added in 2.0. */
+ XML_ERROR_RESERVED_PREFIX_XML,
+ XML_ERROR_RESERVED_PREFIX_XMLNS,
+ XML_ERROR_RESERVED_NAMESPACE_URI
+};
+
+enum XML_Content_Type {
+ XML_CTYPE_EMPTY = 1,
+ XML_CTYPE_ANY,
+ XML_CTYPE_MIXED,
+ XML_CTYPE_NAME,
+ XML_CTYPE_CHOICE,
+ XML_CTYPE_SEQ
+};
+
+enum XML_Content_Quant {
+ XML_CQUANT_NONE,
+ XML_CQUANT_OPT,
+ XML_CQUANT_REP,
+ XML_CQUANT_PLUS
+};
+
+/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
+ XML_CQUANT_NONE, and the other fields will be zero or NULL.
+ If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
+ numchildren will contain number of elements that may be mixed in
+ and children point to an array of XML_Content cells that will be
+ all of XML_CTYPE_NAME type with no quantification.
+
+ If type == XML_CTYPE_NAME, then the name points to the name, and
+ the numchildren field will be zero and children will be NULL. The
+ quant fields indicates any quantifiers placed on the name.
+
+ CHOICE and SEQ will have name NULL, the number of children in
+ numchildren and children will point, recursively, to an array
+ of XML_Content cells.
+
+ The EMPTY, ANY, and MIXED types will only occur at top level.
+*/
+
+typedef struct XML_cp XML_Content;
+
+struct XML_cp {
+ enum XML_Content_Type type;
+ enum XML_Content_Quant quant;
+ XML_Char * name;
+ unsigned int numchildren;
+ XML_Content * children;
+};
+
+
+/* This is called for an element declaration. See above for
+ description of the model argument. It's the caller's responsibility
+ to free model when finished with it.
+*/
+typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,
+ const XML_Char *name,
+ XML_Content *model);
+
+XMLPARSEAPI(void)
+XML_SetElementDeclHandler(XML_Parser parser,
+ XML_ElementDeclHandler eldecl);
+
+/* The Attlist declaration handler is called for *each* attribute. So
+ a single Attlist declaration with multiple attributes declared will
+ generate multiple calls to this handler. The "default" parameter
+ may be NULL in the case of the "#IMPLIED" or "#REQUIRED"
+ keyword. The "isrequired" parameter will be true and the default
+ value will be NULL in the case of "#REQUIRED". If "isrequired" is
+ true and default is non-NULL, then this is a "#FIXED" default.
+*/
+typedef void (XMLCALL *XML_AttlistDeclHandler) (
+ void *userData,
+ const XML_Char *elname,
+ const XML_Char *attname,
+ const XML_Char *att_type,
+ const XML_Char *dflt,
+ int isrequired);
+
+XMLPARSEAPI(void)
+XML_SetAttlistDeclHandler(XML_Parser parser,
+ XML_AttlistDeclHandler attdecl);
+
+/* The XML declaration handler is called for *both* XML declarations
+ and text declarations. The way to distinguish is that the version
+ parameter will be NULL for text declarations. The encoding
+ parameter may be NULL for XML declarations. The standalone
+ parameter will be -1, 0, or 1 indicating respectively that there
+ was no standalone parameter in the declaration, that it was given
+ as no, or that it was given as yes.
+*/
+typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData,
+ const XML_Char *version,
+ const XML_Char *encoding,
+ int standalone);
+
+XMLPARSEAPI(void)
+XML_SetXmlDeclHandler(XML_Parser parser,
+ XML_XmlDeclHandler xmldecl);
+
+
+typedef struct {
+ void *(*malloc_fcn)(size_t size);
+ void *(*realloc_fcn)(void *ptr, size_t size);
+ void (*free_fcn)(void *ptr);
+} XML_Memory_Handling_Suite;
+
+/* Constructs a new parser; encoding is the encoding specified by the
+ external protocol or NULL if there is none specified.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate(const XML_Char *encoding);
+
+/* Constructs a new parser and namespace processor. Element type
+ names and attribute names that belong to a namespace will be
+ expanded; unprefixed attribute names are never expanded; unprefixed
+ element type names are expanded only if there is a default
+ namespace. The expanded name is the concatenation of the namespace
+ URI, the namespace separator character, and the local part of the
+ name. If the namespace separator is '\0' then the namespace URI
+ and the local part will be concatenated without any separator.
+ It is a programming error to use the separator '\0' with namespace
+ triplets (see XML_SetReturnNSTriplet).
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
+
+
+/* Constructs a new parser using the memory management suite referred to
+ by memsuite. If memsuite is NULL, then use the standard library memory
+ suite. If namespaceSeparator is non-NULL it creates a parser with
+ namespace processing as described above. The character pointed at
+ will serve as the namespace separator.
+
+ All further memory operations used for the created parser will come from
+ the given suite.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate_MM(const XML_Char *encoding,
+ const XML_Memory_Handling_Suite *memsuite,
+ const XML_Char *namespaceSeparator);
+
+/* Prepare a parser object to be re-used. This is particularly
+ valuable when memory allocation overhead is disproportionatly high,
+ such as when a large number of small documnents need to be parsed.
+ All handlers are cleared from the parser, except for the
+ unknownEncodingHandler. The parser's external state is re-initialized
+ except for the values of ns and ns_triplets.
+
+ Added in Expat 1.95.3.
+*/
+XMLPARSEAPI(XML_Bool)
+XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
+
+/* atts is array of name/value pairs, terminated by 0;
+ names and values are 0 terminated.
+*/
+typedef void (XMLCALL *XML_StartElementHandler) (void *userData,
+ const XML_Char *name,
+ const XML_Char **atts);
+
+typedef void (XMLCALL *XML_EndElementHandler) (void *userData,
+ const XML_Char *name);
+
+
+/* s is not 0 terminated. */
+typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData,
+ const XML_Char *s,
+ int len);
+
+/* target and data are 0 terminated */
+typedef void (XMLCALL *XML_ProcessingInstructionHandler) (
+ void *userData,
+ const XML_Char *target,
+ const XML_Char *data);
+
+/* data is 0 terminated */
+typedef void (XMLCALL *XML_CommentHandler) (void *userData,
+ const XML_Char *data);
+
+typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData);
+typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);
+
+/* This is called for any characters in the XML document for which
+ there is no applicable handler. This includes both characters that
+ are part of markup which is of a kind that is not reported
+ (comments, markup declarations), or characters that are part of a
+ construct which could be reported but for which no handler has been
+ supplied. The characters are passed exactly as they were in the XML
+ document except that they will be encoded in UTF-8 or UTF-16.
+ Line boundaries are not normalized. Note that a byte order mark
+ character is not passed to the default handler. There are no
+ guarantees about how characters are divided between calls to the
+ default handler: for example, a comment might be split between
+ multiple calls.
+*/
+typedef void (XMLCALL *XML_DefaultHandler) (void *userData,
+ const XML_Char *s,
+ int len);
+
+/* This is called for the start of the DOCTYPE declaration, before
+ any DTD or internal subset is parsed.
+*/
+typedef void (XMLCALL *XML_StartDoctypeDeclHandler) (
+ void *userData,
+ const XML_Char *doctypeName,
+ const XML_Char *sysid,
+ const XML_Char *pubid,
+ int has_internal_subset);
+
+/* This is called for the start of the DOCTYPE declaration when the
+ closing > is encountered, but after processing any external
+ subset.
+*/
+typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
+
+/* This is called for entity declarations. The is_parameter_entity
+ argument will be non-zero if the entity is a parameter entity, zero
+ otherwise.
+
+ For internal entities (), value will
+ be non-NULL and systemId, publicID, and notationName will be NULL.
+ The value string is NOT nul-terminated; the length is provided in
+ the value_length argument. Since it is legal to have zero-length
+ values, do not use this argument to test for internal entities.
+
+ For external entities, value will be NULL and systemId will be
+ non-NULL. The publicId argument will be NULL unless a public
+ identifier was provided. The notationName argument will have a
+ non-NULL value only for unparsed entity declarations.
+
+ Note that is_parameter_entity can't be changed to XML_Bool, since
+ that would break binary compatibility.
+*/
+typedef void (XMLCALL *XML_EntityDeclHandler) (
+ void *userData,
+ const XML_Char *entityName,
+ int is_parameter_entity,
+ const XML_Char *value,
+ int value_length,
+ const XML_Char *base,
+ const XML_Char *systemId,
+ const XML_Char *publicId,
+ const XML_Char *notationName);
+
+XMLPARSEAPI(void)
+XML_SetEntityDeclHandler(XML_Parser parser,
+ XML_EntityDeclHandler handler);
+
+/* OBSOLETE -- OBSOLETE -- OBSOLETE
+ This handler has been superceded by the EntityDeclHandler above.
+ It is provided here for backward compatibility.
+
+ This is called for a declaration of an unparsed (NDATA) entity.
+ The base argument is whatever was set by XML_SetBase. The
+ entityName, systemId and notationName arguments will never be
+ NULL. The other arguments may be.
+*/
+typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) (
+ void *userData,
+ const XML_Char *entityName,
+ const XML_Char *base,
+ const XML_Char *systemId,
+ const XML_Char *publicId,
+ const XML_Char *notationName);
+
+/* This is called for a declaration of notation. The base argument is
+ whatever was set by XML_SetBase. The notationName will never be
+ NULL. The other arguments can be.
+*/
+typedef void (XMLCALL *XML_NotationDeclHandler) (
+ void *userData,
+ const XML_Char *notationName,
+ const XML_Char *base,
+ const XML_Char *systemId,
+ const XML_Char *publicId);
+
+/* When namespace processing is enabled, these are called once for
+ each namespace declaration. The call to the start and end element
+ handlers occur between the calls to the start and end namespace
+ declaration handlers. For an xmlns attribute, prefix will be
+ NULL. For an xmlns="" attribute, uri will be NULL.
+*/
+typedef void (XMLCALL *XML_StartNamespaceDeclHandler) (
+ void *userData,
+ const XML_Char *prefix,
+ const XML_Char *uri);
+
+typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (
+ void *userData,
+ const XML_Char *prefix);
+
+/* This is called if the document is not standalone, that is, it has an
+ external subset or a reference to a parameter entity, but does not
+ have standalone="yes". If this handler returns XML_STATUS_ERROR,
+ then processing will not continue, and the parser will return a
+ XML_ERROR_NOT_STANDALONE error.
+ If parameter entity parsing is enabled, then in addition to the
+ conditions above this handler will only be called if the referenced
+ entity was actually read.
+*/
+typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);
+
+/* This is called for a reference to an external parsed general
+ entity. The referenced entity is not automatically parsed. The
+ application can parse it immediately or later using
+ XML_ExternalEntityParserCreate.
+
+ The parser argument is the parser parsing the entity containing the
+ reference; it can be passed as the parser argument to
+ XML_ExternalEntityParserCreate. The systemId argument is the
+ system identifier as specified in the entity declaration; it will
+ not be NULL.
+
+ The base argument is the system identifier that should be used as
+ the base for resolving systemId if systemId was relative; this is
+ set by XML_SetBase; it may be NULL.
+
+ The publicId argument is the public identifier as specified in the
+ entity declaration, or NULL if none was specified; the whitespace
+ in the public identifier will have been normalized as required by
+ the XML spec.
+
+ The context argument specifies the parsing context in the format
+ expected by the context argument to XML_ExternalEntityParserCreate;
+ context is valid only until the handler returns, so if the
+ referenced entity is to be parsed later, it must be copied.
+ context is NULL only when the entity is a parameter entity.
+
+ The handler should return XML_STATUS_ERROR if processing should not
+ continue because of a fatal error in the handling of the external
+ entity. In this case the calling parser will return an
+ XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
+
+ Note that unlike other handlers the first argument is the parser,
+ not userData.
+*/
+typedef int (XMLCALL *XML_ExternalEntityRefHandler) (
+ XML_Parser parser,
+ const XML_Char *context,
+ const XML_Char *base,
+ const XML_Char *systemId,
+ const XML_Char *publicId);
+
+/* This is called in two situations:
+ 1) An entity reference is encountered for which no declaration
+ has been read *and* this is not an error.
+ 2) An internal entity reference is read, but not expanded, because
+ XML_SetDefaultHandler has been called.
+ Note: skipped parameter entities in declarations and skipped general
+ entities in attribute values cannot be reported, because
+ the event would be out of sync with the reporting of the
+ declarations or attribute values
+*/
+typedef void (XMLCALL *XML_SkippedEntityHandler) (
+ void *userData,
+ const XML_Char *entityName,
+ int is_parameter_entity);
+
+/* This structure is filled in by the XML_UnknownEncodingHandler to
+ provide information to the parser about encodings that are unknown
+ to the parser.
+
+ The map[b] member gives information about byte sequences whose
+ first byte is b.
+
+ If map[b] is c where c is >= 0, then b by itself encodes the
+ Unicode scalar value c.
+
+ If map[b] is -1, then the byte sequence is malformed.
+
+ If map[b] is -n, where n >= 2, then b is the first byte of an
+ n-byte sequence that encodes a single Unicode scalar value.
+
+ The data member will be passed as the first argument to the convert
+ function.
+
+ The convert function is used to convert multibyte sequences; s will
+ point to a n-byte sequence where map[(unsigned char)*s] == -n. The
+ convert function must return the Unicode scalar value represented
+ by this byte sequence or -1 if the byte sequence is malformed.
+
+ The convert function may be NULL if the encoding is a single-byte
+ encoding, that is if map[b] >= -1 for all bytes b.
+
+ When the parser is finished with the encoding, then if release is
+ not NULL, it will call release passing it the data member; once
+ release has been called, the convert function will not be called
+ again.
+
+ Expat places certain restrictions on the encodings that are supported
+ using this mechanism.
+
+ 1. Every ASCII character that can appear in a well-formed XML document,
+ other than the characters
+
+ $@\^`{}~
+
+ must be represented by a single byte, and that byte must be the
+ same byte that represents that character in ASCII.
+
+ 2. No character may require more than 4 bytes to encode.
+
+ 3. All characters encoded must have Unicode scalar values <=
+ 0xFFFF, (i.e., characters that would be encoded by surrogates in
+ UTF-16 are not allowed). Note that this restriction doesn't
+ apply to the built-in support for UTF-8 and UTF-16.
+
+ 4. No Unicode character may be encoded by more than one distinct
+ sequence of bytes.
+*/
+typedef struct {
+ int map[256];
+ void *data;
+ int (XMLCALL *convert)(void *data, const char *s);
+ void (XMLCALL *release)(void *data);
+} XML_Encoding;
+
+/* This is called for an encoding that is unknown to the parser.
+
+ The encodingHandlerData argument is that which was passed as the
+ second argument to XML_SetUnknownEncodingHandler.
+
+ The name argument gives the name of the encoding as specified in
+ the encoding declaration.
+
+ If the callback can provide information about the encoding, it must
+ fill in the XML_Encoding structure, and return XML_STATUS_OK.
+ Otherwise it must return XML_STATUS_ERROR.
+
+ If info does not describe a suitable encoding, then the parser will
+ return an XML_UNKNOWN_ENCODING error.
+*/
+typedef int (XMLCALL *XML_UnknownEncodingHandler) (
+ void *encodingHandlerData,
+ const XML_Char *name,
+ XML_Encoding *info);
+
+XMLPARSEAPI(void)
+XML_SetElementHandler(XML_Parser parser,
+ XML_StartElementHandler start,
+ XML_EndElementHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartElementHandler(XML_Parser parser,
+ XML_StartElementHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetEndElementHandler(XML_Parser parser,
+ XML_EndElementHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetCharacterDataHandler(XML_Parser parser,
+ XML_CharacterDataHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetProcessingInstructionHandler(XML_Parser parser,
+ XML_ProcessingInstructionHandler handler);
+XMLPARSEAPI(void)
+XML_SetCommentHandler(XML_Parser parser,
+ XML_CommentHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetCdataSectionHandler(XML_Parser parser,
+ XML_StartCdataSectionHandler start,
+ XML_EndCdataSectionHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartCdataSectionHandler(XML_Parser parser,
+ XML_StartCdataSectionHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndCdataSectionHandler(XML_Parser parser,
+ XML_EndCdataSectionHandler end);
+
+/* This sets the default handler and also inhibits expansion of
+ internal entities. These entity references will be passed to the
+ default handler, or to the skipped entity handler, if one is set.
+*/
+XMLPARSEAPI(void)
+XML_SetDefaultHandler(XML_Parser parser,
+ XML_DefaultHandler handler);
+
+/* This sets the default handler but does not inhibit expansion of
+ internal entities. The entity reference will not be passed to the
+ default handler.
+*/
+XMLPARSEAPI(void)
+XML_SetDefaultHandlerExpand(XML_Parser parser,
+ XML_DefaultHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetDoctypeDeclHandler(XML_Parser parser,
+ XML_StartDoctypeDeclHandler start,
+ XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,
+ XML_StartDoctypeDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndDoctypeDeclHandler(XML_Parser parser,
+ XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+ XML_UnparsedEntityDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNotationDeclHandler(XML_Parser parser,
+ XML_NotationDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+ XML_StartNamespaceDeclHandler start,
+ XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,
+ XML_StartNamespaceDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,
+ XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetNotStandaloneHandler(XML_Parser parser,
+ XML_NotStandaloneHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+ XML_ExternalEntityRefHandler handler);
+
+/* If a non-NULL value for arg is specified here, then it will be
+ passed as the first argument to the external entity ref handler
+ instead of the parser object.
+*/
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser,
+ void *arg);
+
+XMLPARSEAPI(void)
+XML_SetSkippedEntityHandler(XML_Parser parser,
+ XML_SkippedEntityHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+ XML_UnknownEncodingHandler handler,
+ void *encodingHandlerData);
+
+/* This can be called within a handler for a start element, end
+ element, processing instruction or character data. It causes the
+ corresponding markup to be passed to the default handler.
+*/
+XMLPARSEAPI(void)
+XML_DefaultCurrent(XML_Parser parser);
+
+/* If do_nst is non-zero, and namespace processing is in effect, and
+ a name has a prefix (i.e. an explicit namespace qualifier) then
+ that name is returned as a triplet in a single string separated by
+ the separator character specified when the parser was created: URI
+ + sep + local_name + sep + prefix.
+
+ If do_nst is zero, then namespace information is returned in the
+ default manner (URI + sep + local_name) whether or not the name
+ has a prefix.
+
+ Note: Calling XML_SetReturnNSTriplet after XML_Parse or
+ XML_ParseBuffer has no effect.
+*/
+
+XMLPARSEAPI(void)
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
+
+/* This value is passed as the userData argument to callbacks. */
+XMLPARSEAPI(void)
+XML_SetUserData(XML_Parser parser, void *userData);
+
+/* Returns the last value set by XML_SetUserData or NULL. */
+#define XML_GetUserData(parser) (*(void **)(parser))
+
+/* This is equivalent to supplying an encoding argument to
+ XML_ParserCreate. On success XML_SetEncoding returns non-zero,
+ zero otherwise.
+ Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer
+ has no effect and returns XML_STATUS_ERROR.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
+
+/* If this function is called, then the parser will be passed as the
+ first argument to callbacks instead of userData. The userData will
+ still be accessible using XML_GetUserData.
+*/
+XMLPARSEAPI(void)
+XML_UseParserAsHandlerArg(XML_Parser parser);
+
+/* If useDTD == XML_TRUE is passed to this function, then the parser
+ will assume that there is an external subset, even if none is
+ specified in the document. In such a case the parser will call the
+ externalEntityRefHandler with a value of NULL for the systemId
+ argument (the publicId and context arguments will be NULL as well).
+ Note: For the purpose of checking WFC: Entity Declared, passing
+ useDTD == XML_TRUE will make the parser behave as if the document
+ had a DTD with an external subset.
+ Note: If this function is called, then this must be done before
+ the first call to XML_Parse or XML_ParseBuffer, since it will
+ have no effect after that. Returns
+ XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.
+ Note: If the document does not have a DOCTYPE declaration at all,
+ then startDoctypeDeclHandler and endDoctypeDeclHandler will not
+ be called, despite an external subset being parsed.
+ Note: If XML_DTD is not defined when Expat is compiled, returns
+ XML_ERROR_FEATURE_REQUIRES_XML_DTD.
+*/
+XMLPARSEAPI(enum XML_Error)
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
+
+
+/* Sets the base to be used for resolving relative URIs in system
+ identifiers in declarations. Resolving relative identifiers is
+ left to the application: this value will be passed through as the
+ base argument to the XML_ExternalEntityRefHandler,
+ XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base
+ argument will be copied. Returns XML_STATUS_ERROR if out of memory,
+ XML_STATUS_OK otherwise.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_SetBase(XML_Parser parser, const XML_Char *base);
+
+XMLPARSEAPI(const XML_Char *)
+XML_GetBase(XML_Parser parser);
+
+/* Returns the number of the attribute/value pairs passed in last call
+ to the XML_StartElementHandler that were specified in the start-tag
+ rather than defaulted. Each attribute/value pair counts as 2; thus
+ this correspondds to an index into the atts array passed to the
+ XML_StartElementHandler.
+*/
+XMLPARSEAPI(int)
+XML_GetSpecifiedAttributeCount(XML_Parser parser);
+
+/* Returns the index of the ID attribute passed in the last call to
+ XML_StartElementHandler, or -1 if there is no ID attribute. Each
+ attribute/value pair counts as 2; thus this correspondds to an
+ index into the atts array passed to the XML_StartElementHandler.
+*/
+XMLPARSEAPI(int)
+XML_GetIdAttributeIndex(XML_Parser parser);
+
+/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
+ detected. The last call to XML_Parse must have isFinal true; len
+ may be zero for this call (or any other).
+
+ Though the return values for these functions has always been
+ described as a Boolean value, the implementation, at least for the
+ 1.95.x series, has always returned exactly one of the XML_Status
+ values.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
+
+XMLPARSEAPI(void *)
+XML_GetBuffer(XML_Parser parser, int len);
+
+XMLPARSEAPI(enum XML_Status)
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
+
+/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
+ Must be called from within a call-back handler, except when aborting
+ (resumable = 0) an already suspended parser. Some call-backs may
+ still follow because they would otherwise get lost. Examples:
+ - endElementHandler() for empty elements when stopped in
+ startElementHandler(),
+ - endNameSpaceDeclHandler() when stopped in endElementHandler(),
+ and possibly others.
+
+ Can be called from most handlers, including DTD related call-backs,
+ except when parsing an external parameter entity and resumable != 0.
+ Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
+ Possible error codes:
+ - XML_ERROR_SUSPENDED: when suspending an already suspended parser.
+ - XML_ERROR_FINISHED: when the parser has already finished.
+ - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
+
+ When resumable != 0 (true) then parsing is suspended, that is,
+ XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
+ Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
+ return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
+
+ *Note*:
+ This will be applied to the current parser instance only, that is, if
+ there is a parent parser then it will continue parsing when the
+ externalEntityRefHandler() returns. It is up to the implementation of
+ the externalEntityRefHandler() to call XML_StopParser() on the parent
+ parser (recursively), if one wants to stop parsing altogether.
+
+ When suspended, parsing can be resumed by calling XML_ResumeParser().
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_StopParser(XML_Parser parser, XML_Bool resumable);
+
+/* Resumes parsing after it has been suspended with XML_StopParser().
+ Must not be called from within a handler call-back. Returns same
+ status codes as XML_Parse() or XML_ParseBuffer().
+ Additional error code XML_ERROR_NOT_SUSPENDED possible.
+
+ *Note*:
+ This must be called on the most deeply nested child parser instance
+ first, and on its parent parser only after the child parser has finished,
+ to be applied recursively until the document entity's parser is restarted.
+ That is, the parent parser will not resume by itself and it is up to the
+ application to call XML_ResumeParser() on it at the appropriate moment.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_ResumeParser(XML_Parser parser);
+
+enum XML_Parsing {
+ XML_INITIALIZED,
+ XML_PARSING,
+ XML_FINISHED,
+ XML_SUSPENDED
+};
+
+typedef struct {
+ enum XML_Parsing parsing;
+ XML_Bool finalBuffer;
+} XML_ParsingStatus;
+
+/* Returns status of parser with respect to being initialized, parsing,
+ finished, or suspended and processing the final buffer.
+ XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
+ XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
+*/
+XMLPARSEAPI(void)
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
+
+/* Creates an XML_Parser object that can parse an external general
+ entity; context is a '\0'-terminated string specifying the parse
+ context; encoding is a '\0'-terminated string giving the name of
+ the externally specified encoding, or NULL if there is no
+ externally specified encoding. The context string consists of a
+ sequence of tokens separated by formfeeds (\f); a token consisting
+ of a name specifies that the general entity of the name is open; a
+ token of the form prefix=uri specifies the namespace for a
+ particular prefix; a token of the form =uri specifies the default
+ namespace. This can be called at any point after the first call to
+ an ExternalEntityRefHandler so longer as the parser has not yet
+ been freed. The new parser is completely independent and may
+ safely be used in a separate thread. The handlers and userData are
+ initialized from the parser argument. Returns NULL if out of memory.
+ Otherwise returns a new XML_Parser object.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ExternalEntityParserCreate(XML_Parser parser,
+ const XML_Char *context,
+ const XML_Char *encoding);
+
+enum XML_ParamEntityParsing {
+ XML_PARAM_ENTITY_PARSING_NEVER,
+ XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
+ XML_PARAM_ENTITY_PARSING_ALWAYS
+};
+
+/* Controls parsing of parameter entities (including the external DTD
+ subset). If parsing of parameter entities is enabled, then
+ references to external parameter entities (including the external
+ DTD subset) will be passed to the handler set with
+ XML_SetExternalEntityRefHandler. The context passed will be 0.
+
+ Unlike external general entities, external parameter entities can
+ only be parsed synchronously. If the external parameter entity is
+ to be parsed, it must be parsed during the call to the external
+ entity ref handler: the complete sequence of
+ XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
+ XML_ParserFree calls must be made during this call. After
+ XML_ExternalEntityParserCreate has been called to create the parser
+ for the external parameter entity (context must be 0 for this
+ call), it is illegal to make any calls on the old parser until
+ XML_ParserFree has been called on the newly created parser.
+ If the library has been compiled without support for parameter
+ entity parsing (ie without XML_DTD being defined), then
+ XML_SetParamEntityParsing will return 0 if parsing of parameter
+ entities is requested; otherwise it will return non-zero.
+ Note: If XML_SetParamEntityParsing is called after XML_Parse or
+ XML_ParseBuffer, then it has no effect and will always return 0.
+*/
+XMLPARSEAPI(int)
+XML_SetParamEntityParsing(XML_Parser parser,
+ enum XML_ParamEntityParsing parsing);
+
+/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
+ XML_GetErrorCode returns information about the error.
+*/
+XMLPARSEAPI(enum XML_Error)
+XML_GetErrorCode(XML_Parser parser);
+
+/* These functions return information about the current parse
+ location. They may be called from any callback called to report
+ some parse event; in this case the location is the location of the
+ first of the sequence of characters that generated the event. When
+ called from callbacks generated by declarations in the document
+ prologue, the location identified isn't as neatly defined, but will
+ be within the relevant markup. When called outside of the callback
+ functions, the position indicated will be just past the last parse
+ event (regardless of whether there was an associated callback).
+
+ They may also be called after returning from a call to XML_Parse
+ or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then
+ the location is the location of the character at which the error
+ was detected; otherwise the location is the location of the last
+ parse event, as described above.
+*/
+XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
+XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
+XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
+
+/* Return the number of bytes in the current event.
+ Returns 0 if the event is in an internal entity.
+*/
+XMLPARSEAPI(int)
+XML_GetCurrentByteCount(XML_Parser parser);
+
+/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
+ the integer pointed to by offset to the offset within this buffer
+ of the current parse position, and sets the integer pointed to by size
+ to the size of this buffer (the number of input bytes). Otherwise
+ returns a NULL pointer. Also returns a NULL pointer if a parse isn't
+ active.
+
+ NOTE: The character pointer returned should not be used outside
+ the handler that makes the call.
+*/
+XMLPARSEAPI(const char *)
+XML_GetInputContext(XML_Parser parser,
+ int *offset,
+ int *size);
+
+/* For backwards compatibility with previous versions. */
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
+#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
+
+/* Frees the content model passed to the element declaration handler */
+XMLPARSEAPI(void)
+XML_FreeContentModel(XML_Parser parser, XML_Content *model);
+
+/* Exposing the memory handling functions used in Expat */
+XMLPARSEAPI(void *)
+XML_MemMalloc(XML_Parser parser, size_t size);
+
+XMLPARSEAPI(void *)
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
+
+XMLPARSEAPI(void)
+XML_MemFree(XML_Parser parser, void *ptr);
+
+/* Frees memory used by the parser. */
+XMLPARSEAPI(void)
+XML_ParserFree(XML_Parser parser);
+
+/* Returns a string describing the error. */
+XMLPARSEAPI(const XML_LChar *)
+XML_ErrorString(enum XML_Error code);
+
+/* Return a string containing the version number of this expat */
+XMLPARSEAPI(const XML_LChar *)
+XML_ExpatVersion(void);
+
+typedef struct {
+ int major;
+ int minor;
+ int micro;
+} XML_Expat_Version;
+
+/* Return an XML_Expat_Version structure containing numeric version
+ number information for this version of expat.
+*/
+XMLPARSEAPI(XML_Expat_Version)
+XML_ExpatVersionInfo(void);
+
+/* Added in Expat 1.95.5. */
+enum XML_FeatureEnum {
+ XML_FEATURE_END = 0,
+ XML_FEATURE_UNICODE,
+ XML_FEATURE_UNICODE_WCHAR_T,
+ XML_FEATURE_DTD,
+ XML_FEATURE_CONTEXT_BYTES,
+ XML_FEATURE_MIN_SIZE,
+ XML_FEATURE_SIZEOF_XML_CHAR,
+ XML_FEATURE_SIZEOF_XML_LCHAR,
+ XML_FEATURE_NS,
+ XML_FEATURE_LARGE_SIZE
+ /* Additional features must be added to the end of this enum. */
+};
+
+typedef struct {
+ enum XML_FeatureEnum feature;
+ const XML_LChar *name;
+ long int value;
+} XML_Feature;
+
+XMLPARSEAPI(const XML_Feature *)
+XML_GetFeatureList(void);
+
+
+/* Expat follows the GNU/Linux convention of odd number minor version for
+ beta/development releases and even number minor version for stable
+ releases. Micro is bumped with each release, and set to 0 with each
+ change to major or minor version.
+*/
+#define XML_MAJOR_VERSION 2
+#define XML_MINOR_VERSION 0
+#define XML_MICRO_VERSION 1
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_INCLUDED */
diff --git a/lib/mac32-gcc40/include/expat_external.h b/lib/mac32-gcc40/include/expat_external.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c03284ea265bc62bbae15e29e48f7b0df4cef0d
--- /dev/null
+++ b/lib/mac32-gcc40/include/expat_external.h
@@ -0,0 +1,115 @@
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+ See the file COPYING for copying permission.
+*/
+
+#ifndef Expat_External_INCLUDED
+#define Expat_External_INCLUDED 1
+
+/* External API definitions */
+
+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
+#define XML_USE_MSC_EXTENSIONS 1
+#endif
+
+/* Expat tries very hard to make the API boundary very specifically
+ defined. There are two macros defined to control this boundary;
+ each of these can be defined before including this header to
+ achieve some different behavior, but doing so it not recommended or
+ tested frequently.
+
+ XMLCALL - The calling convention to use for all calls across the
+ "library boundary." This will default to cdecl, and
+ try really hard to tell the compiler that's what we
+ want.
+
+ XMLIMPORT - Whatever magic is needed to note that a function is
+ to be imported from a dynamically loaded library
+ (.dll, .so, or .sl, depending on your platform).
+
+ The XMLCALL macro was added in Expat 1.95.7. The only one which is
+ expected to be directly useful in client code is XMLCALL.
+
+ Note that on at least some Unix versions, the Expat library must be
+ compiled with the cdecl calling convention as the default since
+ system headers may assume the cdecl convention.
+*/
+#ifndef XMLCALL
+#if defined(_MSC_VER)
+#define XMLCALL __cdecl
+#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
+#define XMLCALL __attribute__((cdecl))
+#else
+/* For any platform which uses this definition and supports more than
+ one calling convention, we need to extend this definition to
+ declare the convention used on that platform, if it's possible to
+ do so.
+
+ If this is the case for your platform, please file a bug report
+ with information on how to identify your platform via the C
+ pre-processor and how to specify the same calling convention as the
+ platform's malloc() implementation.
+*/
+#define XMLCALL
+#endif
+#endif /* not defined XMLCALL */
+
+
+#if !defined(XML_STATIC) && !defined(XMLIMPORT)
+#ifndef XML_BUILDING_EXPAT
+/* using Expat from an application */
+
+#ifdef XML_USE_MSC_EXTENSIONS
+#define XMLIMPORT __declspec(dllimport)
+#endif
+
+#endif
+#endif /* not defined XML_STATIC */
+
+
+/* If we didn't define it above, define it away: */
+#ifndef XMLIMPORT
+#define XMLIMPORT
+#endif
+
+
+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#define XML_UNICODE
+#endif
+
+#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
+#ifdef XML_UNICODE_WCHAR_T
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+#else
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+#endif /* XML_UNICODE_WCHAR_T */
+#else /* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+#endif /* XML_UNICODE */
+
+#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
+typedef __int64 XML_Index;
+typedef unsigned __int64 XML_Size;
+#else
+typedef long long XML_Index;
+typedef unsigned long long XML_Size;
+#endif
+#else
+typedef long XML_Index;
+typedef unsigned long XML_Size;
+#endif /* XML_LARGE_SIZE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_External_INCLUDED */
diff --git a/lib/mac32-gcc40/lib/libcurl.4.dylib b/lib/mac32-gcc40/lib/libcurl.4.dylib
new file mode 100755
index 0000000000000000000000000000000000000000..62381ddd4922993b0118b6caebc567ffcae6339e
Binary files /dev/null and b/lib/mac32-gcc40/lib/libcurl.4.dylib differ
diff --git a/lib/mac32-gcc40/lib/libcurl.a b/lib/mac32-gcc40/lib/libcurl.a
new file mode 100644
index 0000000000000000000000000000000000000000..d118ed3279b72f351e2a65fa4fbf843974de1338
Binary files /dev/null and b/lib/mac32-gcc40/lib/libcurl.a differ
diff --git a/lib/mac32-gcc40/lib/libcurl.dylib b/lib/mac32-gcc40/lib/libcurl.dylib
new file mode 120000
index 0000000000000000000000000000000000000000..8d7cf043ebc4a9832d3a970dfd1ef377c3b08b90
--- /dev/null
+++ b/lib/mac32-gcc40/lib/libcurl.dylib
@@ -0,0 +1 @@
+libcurl.4.dylib
\ No newline at end of file
diff --git a/lib/mac32-gcc40/lib/libcurl.la b/lib/mac32-gcc40/lib/libcurl.la
new file mode 100755
index 0000000000000000000000000000000000000000..d3c791b1823ef5299854990f7d797874b3f44486
--- /dev/null
+++ b/lib/mac32-gcc40/lib/libcurl.la
@@ -0,0 +1,41 @@
+# libcurl.la - a libtool library file
+# Generated by ltmain.sh (GNU libtool) 2.2.6b Debian-2.2.6b-2
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='libcurl.4.dylib'
+
+# Names of this library.
+library_names='libcurl.4.dylib libcurl.dylib'
+
+# The name of the static archive.
+old_library='libcurl.a'
+
+# Linker flags that can not go in dependency_libs.
+inherited_linker_flags=' '
+
+# Libraries that this one depends upon.
+dependency_libs=' -R/opt/local/lib -L/opt/local/lib /opt/local/lib/libidn.la /opt/local/lib/libintl.la -lc /opt/local/lib/libiconv.la -lldap -lssl -lcrypto -lz'
+
+# Names of additional weak libraries provided by this library
+weak_library_names=''
+
+# Version information for libcurl.
+current=6
+age=2
+revision=0
+
+# Is this an already installed library?
+installed=yes
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=no
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='/Users/user/Documents/pixhawk/curl-7.21.2/fakeinstall/lib'
diff --git a/lib/mac32-gcc40/lib/libexpat.1.5.2.dylib b/lib/mac32-gcc40/lib/libexpat.1.5.2.dylib
new file mode 100755
index 0000000000000000000000000000000000000000..cde150b83e43e9fa121fa7973bf819dba767b632
Binary files /dev/null and b/lib/mac32-gcc40/lib/libexpat.1.5.2.dylib differ
diff --git a/lib/mac32-gcc40/lib/libexpat.1.dylib b/lib/mac32-gcc40/lib/libexpat.1.dylib
new file mode 120000
index 0000000000000000000000000000000000000000..87c4b1cd75bb803e042bbd69b31a6f18dad92419
--- /dev/null
+++ b/lib/mac32-gcc40/lib/libexpat.1.dylib
@@ -0,0 +1 @@
+libexpat.1.5.2.dylib
\ No newline at end of file
diff --git a/lib/mac32-gcc40/lib/libexpat.a b/lib/mac32-gcc40/lib/libexpat.a
new file mode 100644
index 0000000000000000000000000000000000000000..e00ee072b962ed543d8eca14b6e322d9db48fb5c
Binary files /dev/null and b/lib/mac32-gcc40/lib/libexpat.a differ
diff --git a/lib/mac32-gcc40/lib/libexpat.dylib b/lib/mac32-gcc40/lib/libexpat.dylib
new file mode 120000
index 0000000000000000000000000000000000000000..87c4b1cd75bb803e042bbd69b31a6f18dad92419
--- /dev/null
+++ b/lib/mac32-gcc40/lib/libexpat.dylib
@@ -0,0 +1 @@
+libexpat.1.5.2.dylib
\ No newline at end of file
diff --git a/lib/mac32-gcc40/lib/libexpat.la b/lib/mac32-gcc40/lib/libexpat.la
new file mode 100755
index 0000000000000000000000000000000000000000..68f357aed0cbbe65fded15ed1288bef7f1317e7f
--- /dev/null
+++ b/lib/mac32-gcc40/lib/libexpat.la
@@ -0,0 +1,35 @@
+# libexpat.la - a libtool library file
+# Generated by ltmain.sh - GNU libtool 1.5.22 (1.1220.2.365 2005/12/18 22:14:06)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='libexpat.1.dylib'
+
+# Names of this library.
+library_names='libexpat.1.5.2.dylib libexpat.1.dylib libexpat.dylib'
+
+# The name of the static archive.
+old_library='libexpat.a'
+
+# Libraries that this one depends upon.
+dependency_libs=''
+
+# Version information for libexpat.
+current=6
+age=5
+revision=2
+
+# Is this an already installed library?
+installed=yes
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=no
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='/Users/user/Documents/pixhawk/expat-2.0.1/fakeinstall/lib'
diff --git a/lib/msinttypes/inttypes.h b/lib/msinttypes/inttypes.h
new file mode 100644
index 0000000000000000000000000000000000000000..25542771f591c3b2161df8171f18bf7a2b66a530
--- /dev/null
+++ b/lib/msinttypes/inttypes.h
@@ -0,0 +1,305 @@
+// ISO C9x compliant inttypes.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+// Copyright (c) 2006 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. The name of the author may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_INTTYPES_H_ // [
+#define _MSC_INTTYPES_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include "stdint.h"
+
+// 7.8 Format conversion of integer types
+
+typedef struct {
+ intmax_t quot;
+ intmax_t rem;
+} imaxdiv_t;
+
+// 7.8.1 Macros for format specifiers
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [ See footnote 185 at page 198
+
+// The fprintf macros for signed integers are:
+#define PRId8 "d"
+#define PRIi8 "i"
+#define PRIdLEAST8 "d"
+#define PRIiLEAST8 "i"
+#define PRIdFAST8 "d"
+#define PRIiFAST8 "i"
+
+#define PRId16 "hd"
+#define PRIi16 "hi"
+#define PRIdLEAST16 "hd"
+#define PRIiLEAST16 "hi"
+#define PRIdFAST16 "hd"
+#define PRIiFAST16 "hi"
+
+#define PRId32 "I32d"
+#define PRIi32 "I32i"
+#define PRIdLEAST32 "I32d"
+#define PRIiLEAST32 "I32i"
+#define PRIdFAST32 "I32d"
+#define PRIiFAST32 "I32i"
+
+#define PRId64 "I64d"
+#define PRIi64 "I64i"
+#define PRIdLEAST64 "I64d"
+#define PRIiLEAST64 "I64i"
+#define PRIdFAST64 "I64d"
+#define PRIiFAST64 "I64i"
+
+#define PRIdMAX "I64d"
+#define PRIiMAX "I64i"
+
+#define PRIdPTR "Id"
+#define PRIiPTR "Ii"
+
+// The fprintf macros for unsigned integers are:
+#define PRIo8 "o"
+#define PRIu8 "u"
+#define PRIx8 "x"
+#define PRIX8 "X"
+#define PRIoLEAST8 "o"
+#define PRIuLEAST8 "u"
+#define PRIxLEAST8 "x"
+#define PRIXLEAST8 "X"
+#define PRIoFAST8 "o"
+#define PRIuFAST8 "u"
+#define PRIxFAST8 "x"
+#define PRIXFAST8 "X"
+
+#define PRIo16 "ho"
+#define PRIu16 "hu"
+#define PRIx16 "hx"
+#define PRIX16 "hX"
+#define PRIoLEAST16 "ho"
+#define PRIuLEAST16 "hu"
+#define PRIxLEAST16 "hx"
+#define PRIXLEAST16 "hX"
+#define PRIoFAST16 "ho"
+#define PRIuFAST16 "hu"
+#define PRIxFAST16 "hx"
+#define PRIXFAST16 "hX"
+
+#define PRIo32 "I32o"
+#define PRIu32 "I32u"
+#define PRIx32 "I32x"
+#define PRIX32 "I32X"
+#define PRIoLEAST32 "I32o"
+#define PRIuLEAST32 "I32u"
+#define PRIxLEAST32 "I32x"
+#define PRIXLEAST32 "I32X"
+#define PRIoFAST32 "I32o"
+#define PRIuFAST32 "I32u"
+#define PRIxFAST32 "I32x"
+#define PRIXFAST32 "I32X"
+
+#define PRIo64 "I64o"
+#define PRIu64 "I64u"
+#define PRIx64 "I64x"
+#define PRIX64 "I64X"
+#define PRIoLEAST64 "I64o"
+#define PRIuLEAST64 "I64u"
+#define PRIxLEAST64 "I64x"
+#define PRIXLEAST64 "I64X"
+#define PRIoFAST64 "I64o"
+#define PRIuFAST64 "I64u"
+#define PRIxFAST64 "I64x"
+#define PRIXFAST64 "I64X"
+
+#define PRIoMAX "I64o"
+#define PRIuMAX "I64u"
+#define PRIxMAX "I64x"
+#define PRIXMAX "I64X"
+
+#define PRIoPTR "Io"
+#define PRIuPTR "Iu"
+#define PRIxPTR "Ix"
+#define PRIXPTR "IX"
+
+// The fscanf macros for signed integers are:
+#define SCNd8 "d"
+#define SCNi8 "i"
+#define SCNdLEAST8 "d"
+#define SCNiLEAST8 "i"
+#define SCNdFAST8 "d"
+#define SCNiFAST8 "i"
+
+#define SCNd16 "hd"
+#define SCNi16 "hi"
+#define SCNdLEAST16 "hd"
+#define SCNiLEAST16 "hi"
+#define SCNdFAST16 "hd"
+#define SCNiFAST16 "hi"
+
+#define SCNd32 "ld"
+#define SCNi32 "li"
+#define SCNdLEAST32 "ld"
+#define SCNiLEAST32 "li"
+#define SCNdFAST32 "ld"
+#define SCNiFAST32 "li"
+
+#define SCNd64 "I64d"
+#define SCNi64 "I64i"
+#define SCNdLEAST64 "I64d"
+#define SCNiLEAST64 "I64i"
+#define SCNdFAST64 "I64d"
+#define SCNiFAST64 "I64i"
+
+#define SCNdMAX "I64d"
+#define SCNiMAX "I64i"
+
+#ifdef _WIN64 // [
+# define SCNdPTR "I64d"
+# define SCNiPTR "I64i"
+#else // _WIN64 ][
+# define SCNdPTR "ld"
+# define SCNiPTR "li"
+#endif // _WIN64 ]
+
+// The fscanf macros for unsigned integers are:
+#define SCNo8 "o"
+#define SCNu8 "u"
+#define SCNx8 "x"
+#define SCNX8 "X"
+#define SCNoLEAST8 "o"
+#define SCNuLEAST8 "u"
+#define SCNxLEAST8 "x"
+#define SCNXLEAST8 "X"
+#define SCNoFAST8 "o"
+#define SCNuFAST8 "u"
+#define SCNxFAST8 "x"
+#define SCNXFAST8 "X"
+
+#define SCNo16 "ho"
+#define SCNu16 "hu"
+#define SCNx16 "hx"
+#define SCNX16 "hX"
+#define SCNoLEAST16 "ho"
+#define SCNuLEAST16 "hu"
+#define SCNxLEAST16 "hx"
+#define SCNXLEAST16 "hX"
+#define SCNoFAST16 "ho"
+#define SCNuFAST16 "hu"
+#define SCNxFAST16 "hx"
+#define SCNXFAST16 "hX"
+
+#define SCNo32 "lo"
+#define SCNu32 "lu"
+#define SCNx32 "lx"
+#define SCNX32 "lX"
+#define SCNoLEAST32 "lo"
+#define SCNuLEAST32 "lu"
+#define SCNxLEAST32 "lx"
+#define SCNXLEAST32 "lX"
+#define SCNoFAST32 "lo"
+#define SCNuFAST32 "lu"
+#define SCNxFAST32 "lx"
+#define SCNXFAST32 "lX"
+
+#define SCNo64 "I64o"
+#define SCNu64 "I64u"
+#define SCNx64 "I64x"
+#define SCNX64 "I64X"
+#define SCNoLEAST64 "I64o"
+#define SCNuLEAST64 "I64u"
+#define SCNxLEAST64 "I64x"
+#define SCNXLEAST64 "I64X"
+#define SCNoFAST64 "I64o"
+#define SCNuFAST64 "I64u"
+#define SCNxFAST64 "I64x"
+#define SCNXFAST64 "I64X"
+
+#define SCNoMAX "I64o"
+#define SCNuMAX "I64u"
+#define SCNxMAX "I64x"
+#define SCNXMAX "I64X"
+
+#ifdef _WIN64 // [
+# define SCNoPTR "I64o"
+# define SCNuPTR "I64u"
+# define SCNxPTR "I64x"
+# define SCNXPTR "I64X"
+#else // _WIN64 ][
+# define SCNoPTR "lo"
+# define SCNuPTR "lu"
+# define SCNxPTR "lx"
+# define SCNXPTR "lX"
+#endif // _WIN64 ]
+
+#endif // __STDC_FORMAT_MACROS ]
+
+// 7.8.2 Functions for greatest-width integer types
+
+// 7.8.2.1 The imaxabs function
+#define imaxabs _abs64
+
+// 7.8.2.2 The imaxdiv function
+
+// This is modified version of div() function from Microsoft's div.c found
+// in %MSVC.NET%\crt\src\div.c
+#ifdef STATIC_IMAXDIV // [
+static
+#else // STATIC_IMAXDIV ][
+_inline
+#endif // STATIC_IMAXDIV ]
+imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
+{
+ imaxdiv_t result;
+
+ result.quot = numer / denom;
+ result.rem = numer % denom;
+
+ if (numer < 0 && result.rem > 0) {
+ // did division wrong; must fix up
+ ++result.quot;
+ result.rem -= denom;
+ }
+
+ return result;
+}
+
+// 7.8.2.3 The strtoimax and strtoumax functions
+#define strtoimax _strtoi64
+#define strtoumax _strtoui64
+
+// 7.8.2.4 The wcstoimax and wcstoumax functions
+#define wcstoimax _wcstoi64
+#define wcstoumax _wcstoui64
+
+
+#endif // _MSC_INTTYPES_H_ ]
diff --git a/lib/msinttypes/stdint.h b/lib/msinttypes/stdint.h
new file mode 100644
index 0000000000000000000000000000000000000000..59d067302fcfe1f5ec82cd7534f89c18167dd895
--- /dev/null
+++ b/lib/msinttypes/stdint.h
@@ -0,0 +1,247 @@
+// ISO C9x compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+// Copyright (c) 2006-2008 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. The name of the author may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we should wrap include with 'extern "C++" {}'
+// or compiler give many errors like this:
+// error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#ifdef __cplusplus
+extern "C" {
+#endif
+# include
+#ifdef __cplusplus
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+# define _W64 __w64
+# else
+# define _W64
+# endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+ typedef signed char int8_t;
+ typedef signed short int16_t;
+ typedef signed int int32_t;
+ typedef unsigned char uint8_t;
+ typedef unsigned short uint16_t;
+ typedef unsigned int uint32_t;
+#else
+ typedef signed __int8 int8_t;
+ typedef signed __int16 int16_t;
+ typedef signed __int32 int32_t;
+ typedef unsigned __int8 uint8_t;
+ typedef unsigned __int16 uint16_t;
+ typedef unsigned __int32 uint32_t;
+#endif
+typedef signed __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t int_least8_t;
+typedef int16_t int_least16_t;
+typedef int32_t int_least32_t;
+typedef int64_t int_least64_t;
+typedef uint8_t uint_least8_t;
+typedef uint16_t uint_least16_t;
+typedef uint32_t uint_least32_t;
+typedef uint64_t uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t int_fast8_t;
+typedef int16_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef int64_t int_fast64_t;
+typedef uint8_t uint_fast8_t;
+typedef uint16_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+typedef uint64_t uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+ typedef signed __int64 intptr_t;
+ typedef unsigned __int64 uintptr_t;
+#else // _WIN64 ][
+ typedef _W64 signed int intptr_t;
+ typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t intmax_t;
+typedef uint64_t uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN ((int8_t)_I8_MIN)
+#define INT8_MAX _I8_MAX
+#define INT16_MIN ((int16_t)_I16_MIN)
+#define INT16_MAX _I16_MAX
+#define INT32_MIN ((int32_t)_I32_MIN)
+#define INT32_MAX _I32_MAX
+#define INT64_MIN ((int64_t)_I64_MIN)
+#define INT64_MAX _I64_MAX
+#define UINT8_MAX _UI8_MAX
+#define UINT16_MAX _UI16_MAX
+#define UINT32_MAX _UI32_MAX
+#define UINT64_MAX _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN INT8_MIN
+#define INT_LEAST8_MAX INT8_MAX
+#define INT_LEAST16_MIN INT16_MIN
+#define INT_LEAST16_MAX INT16_MAX
+#define INT_LEAST32_MIN INT32_MIN
+#define INT_LEAST32_MAX INT32_MAX
+#define INT_LEAST64_MIN INT64_MIN
+#define INT_LEAST64_MAX INT64_MAX
+#define UINT_LEAST8_MAX UINT8_MAX
+#define UINT_LEAST16_MAX UINT16_MAX
+#define UINT_LEAST32_MAX UINT32_MAX
+#define UINT_LEAST64_MAX UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN INT8_MIN
+#define INT_FAST8_MAX INT8_MAX
+#define INT_FAST16_MIN INT16_MIN
+#define INT_FAST16_MAX INT16_MAX
+#define INT_FAST32_MIN INT32_MIN
+#define INT_FAST32_MAX INT32_MAX
+#define INT_FAST64_MIN INT64_MIN
+#define INT_FAST64_MAX INT64_MAX
+#define UINT_FAST8_MAX UINT8_MAX
+#define UINT_FAST16_MAX UINT16_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+#define UINT_FAST64_MAX UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+# define INTPTR_MIN INT64_MIN
+# define INTPTR_MAX INT64_MAX
+# define UINTPTR_MAX UINT64_MAX
+#else // _WIN64 ][
+# define INTPTR_MIN INT32_MIN
+# define INTPTR_MAX INT32_MAX
+# define UINTPTR_MAX UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN INT64_MIN
+#define INTMAX_MAX INT64_MAX
+#define UINTMAX_MAX UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+# define PTRDIFF_MIN _I64_MIN
+# define PTRDIFF_MAX _I64_MAX
+#else // _WIN64 ][
+# define PTRDIFF_MIN _I32_MIN
+# define PTRDIFF_MAX _I32_MAX
+#endif // _WIN64 ]
+
+#define SIG_ATOMIC_MIN INT_MIN
+#define SIG_ATOMIC_MAX INT_MAX
+
+#ifndef SIZE_MAX // [
+# ifdef _WIN64 // [
+# define SIZE_MAX _UI64_MAX
+# else // _WIN64 ][
+# define SIZE_MAX _UI32_MAX
+# endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in
+#ifndef WCHAR_MIN // [
+# define WCHAR_MIN 0
+#endif // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+# define WCHAR_MAX _UI16_MAX
+#endif // WCHAR_MAX ]
+
+#define WINT_MIN 0
+#define WINT_MAX _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val) val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val) val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C INT64_C
+#define UINTMAX_C UINT64_C
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+
+#endif // _MSC_STDINT_H_ ]
diff --git a/lib/sdl/msvc/BUGS b/lib/sdl/msvc/BUGS
new file mode 100644
index 0000000000000000000000000000000000000000..d7058f6209652e755278c634d441965bca2b51e8
--- /dev/null
+++ b/lib/sdl/msvc/BUGS
@@ -0,0 +1,18 @@
+
+Bugs are now managed in the SDL bug tracker, here:
+
+ http://bugzilla.libsdl.org/
+
+You may report bugs there, and search to see if a given issue has already
+ been reported, discussed, and maybe even fixed.
+
+
+
+You may also find help at the SDL mailing list. Subscription information:
+
+ http://lists.libsdl.org/listinfo.cgi/sdl-libsdl.org
+
+Bug reports are welcome here, but we really appreciate if you use Bugzilla, as
+ bugs discussed on the mailing list may be forgotten or missed.
+
+
diff --git a/lib/sdl/msvc/COPYING b/lib/sdl/msvc/COPYING
new file mode 100644
index 0000000000000000000000000000000000000000..8904ea404ee3011471006a5b6bbf6eb7e5b4ee07
--- /dev/null
+++ b/lib/sdl/msvc/COPYING
@@ -0,0 +1,458 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
diff --git a/lib/sdl/msvc/README b/lib/sdl/msvc/README
new file mode 100644
index 0000000000000000000000000000000000000000..e9e1d1a98338c3e37847eaee0d8a096bc7d40c64
--- /dev/null
+++ b/lib/sdl/msvc/README
@@ -0,0 +1,49 @@
+
+ Simple DirectMedia Layer
+
+ (SDL)
+
+ Version 1.2
+
+---
+http://www.libsdl.org/
+
+This is the Simple DirectMedia Layer, a general API that provides low
+level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL,
+and 2D framebuffer across multiple platforms.
+
+The current version supports Linux, Windows CE/95/98/ME/XP/Vista, BeOS,
+MacOS Classic, Mac OS X, FreeBSD, NetBSD, OpenBSD, BSD/OS, Solaris, IRIX,
+and QNX. The code contains support for Dreamcast, Atari, AIX, OSF/Tru64,
+RISC OS, SymbianOS, Nintendo DS, and OS/2, but these are not officially
+supported.
+
+SDL is written in C, but works with C++ natively, and has bindings to
+several other languages, including Ada, C#, Eiffel, Erlang, Euphoria,
+Guile, Haskell, Java, Lisp, Lua, ML, Objective C, Pascal, Perl, PHP,
+Pike, Pliant, Python, Ruby, and Smalltalk.
+
+This library is distributed under GNU LGPL version 2, which can be
+found in the file "COPYING". This license allows you to use SDL
+freely in commercial programs as long as you link with the dynamic
+library.
+
+The best way to learn how to use SDL is to check out the header files in
+the "include" subdirectory and the programs in the "test" subdirectory.
+The header files and test programs are well commented and always up to date.
+More documentation is available in HTML format in "docs/index.html", and
+a documentation wiki is available online at:
+ http://www.libsdl.org/cgi/docwiki.cgi
+
+The test programs in the "test" subdirectory are in the public domain.
+
+Frequently asked questions are answered online:
+ http://www.libsdl.org/faq.php
+
+If you need help with the library, or just want to discuss SDL related
+issues, you can join the developers mailing list:
+ http://www.libsdl.org/mailing-list.php
+
+Enjoy!
+ Sam Lantinga (slouken@libsdl.org)
+
diff --git a/lib/sdl/msvc/README-SDL.txt b/lib/sdl/msvc/README-SDL.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1669736cb52b18cd12ab58171f18886600620b85
--- /dev/null
+++ b/lib/sdl/msvc/README-SDL.txt
@@ -0,0 +1,13 @@
+
+Please distribute this file with the SDL runtime environment:
+
+The Simple DirectMedia Layer (SDL for short) is a cross-platfrom library
+designed to make it easy to write multi-media software, such as games and
+emulators.
+
+The Simple DirectMedia Layer library source code is available from:
+http://www.libsdl.org/
+
+This library is distributed under the terms of the GNU LGPL license:
+http://www.gnu.org/copyleft/lesser.html
+
diff --git a/lib/sdl/msvc/VisualC.html b/lib/sdl/msvc/VisualC.html
new file mode 100644
index 0000000000000000000000000000000000000000..ad2ed97a603d70d21a4a15054ba333269b0111c5
--- /dev/null
+++ b/lib/sdl/msvc/VisualC.html
@@ -0,0 +1,171 @@
+
+
+ Using SDL with Microsoft Visual C++
+
+
+
+ Unzip the VisualC.zip file into the directory that contains this
+ file (VisualC.html).
+
+
+ Be certain that you unzip the zip file for your compiler into this
+ directory and not any other directory. If you are using WinZip, be careful to
+ make sure that it extracts to this folder, because it's
+ convenient feature of unzipping to a folder with the name of the file currently
+ being unzipped will get you in trouble if you use it right now. And that's all
+ I have to say about that.
+
+
+ Now that it's unzipped, go into the VisualC
+ directory that is created, and double-click on the VC++ file "SDL.dsw"
+ ("SDL.sln"). This should open up the IDE.
+
+
+ You may be prompted at this point to upgrade the workspace, should you be using
+ a more recent version of Visual C++. If so, allow the workspace to be upgraded.
+
+
+ Build the .dll and .lib files.
+
+
+ This is done by right clicking on each project in turn (Projects are listed in
+ the Workspace panel in the FileView tab), and selecting "Build".
+
+
+ If you get an error about SDL_config.h being missing, you should
+ copy include/SDL_config.h.default to include/SDL_config.h and try again.
+
+
+ You may get a few warnings, but you should not get any errors. You do have to
+ have at least the DirectX 5 SDK installed, however. The latest
+ version of DirectX can be downloaded or purchased on a cheap CD (my
+ recommendation) from Microsoft .
+
+
+ Later, we will refer to the following .lib and .dll files that have just been
+ generated:
+
+
+
SDL.dll
+
SDL.lib
+
SDLmain.lib
+
+
+ Search for these using the Windows Find (Windows-F) utility, if you don't
+ already know where they should be. For those of you with a clue, look inside
+ the Debug or Release directories of the subdirectories of the Project folder.
+ (It might be easier to just use Windows Find if this sounds confusing. And
+ don't worry about needing a clue; we all need visits from the clue fairy
+ frequently.)
+
+
+ Creating a Project with SDL
+
+
+ Create a project as a Win32 Application.
+
+
+ Create a C++ file for your project.
+
+
+ Set the C runtime to "Multi-threaded DLL" in the menu: Project|Settings|C/C++
+ tab|Code Generation|Runtime Library .
+
+
+ Add the SDL include directory to your list of includes in the
+ menu: Project|Settings|C/C++ tab|Preprocessor|Additional include directories
+ .
+
+ VC7 Specific: Instead of doing this I find it easier to
+ add the include and library directories to the list that VC7 keeps. Do this by
+ selecting Tools|Options|Projects|VC++ Directories and under the "Show
+ Directories For:" dropbox select "Include Files", and click the "New Directory
+ Icon" and add the [SDLROOT]\include directory (ex. If you installed to
+ c:\SDL-1.2.5\ add c:\SDL-1.2.5\include). Proceed to change the
+ dropbox selection to "Library Files" and add [SDLROOT]\lib.
+
+
+ The "include directory" I am referring to is the include folder
+ within the main SDL directory (the one that this HTML file located within).
+
+
+ Now we're going to use the files that we had created earlier in the Build SDL
+ step.
+
+
+ Copy the following files into your Project directory:
+
+
+
SDL.dll
+
+
+ Add the following files to your project (It is not necessary to copy them to
+ your project directory):
+
+
+
SDL.lib
+
SDLmain.lib
+
+
+ (To add them to your project, right click on your project, and select "Add
+ files to project")
+
+
Instead of adding the files to your project it is more
+ desireable to add them to the linker options: Project|Properties|Linker|Command
+ Line and type the names of the libraries to link with in the "Additional
+ Options:" box. Note: This must be done for each build
+ configuration (eg. Release,Debug).
+
+ SDL 101, First Day of Class
+
+
+ Now create the basic body of your project. The body of your program should take
+ the following form:
+
+#include "SDL.h"
+
+int main( int argc, char* argv[] )
+{
+ // Body of the program goes here.
+ return 0;
+}
+
+
+
+
+ That's it!
+
+
+ I hope that this document has helped you get through the most difficult part of
+ using the SDL: installing it. Suggestions for improvements to this document
+ should be sent to the writers of this document.
+
+
+ Thanks to Paulus Esterhazy (pesterhazy@gmx.net), for the work on VC++ port.
+
+
+ This document was originally called "VisualC.txt", and was written by
+ Sam Lantinga.
+
+
+ Later, it was converted to HTML and expanded into the document that you see
+ today by Lion Kimbro.
+
+
Minor Fixes and Visual C++ 7 Information (In Green) was added by James Turk
+
+
+
diff --git a/lib/sdl/msvc/WhatsNew b/lib/sdl/msvc/WhatsNew
new file mode 100644
index 0000000000000000000000000000000000000000..7fae760f7ca43a2f86129ec8573daa2ae17877ef
--- /dev/null
+++ b/lib/sdl/msvc/WhatsNew
@@ -0,0 +1,727 @@
+
+This is a list of API changes in SDL's version history.
+
+Version 1.0:
+
+1.2.14:
+ Added cast macros for correct usage with C++:
+ SDL_reinterpret_cast(type, expression)
+ SDL_static_cast(type, expression)
+
+ Added SDL_VIDEO_FULLSCREEN_DISPLAY as a preferred synonym for
+ SDL_VIDEO_FULLSCREEN_HEAD on X11.
+
+ Added SDL_DISABLE_LOCK_KEYS environment variable to enable normal
+ up/down events for Caps-Lock and Num-Lock keys.
+
+1.2.13:
+ Added SDL_BUTTON_X1 and SDL_BUTTON_X2 constants.
+
+1.2.12:
+ Added SDL_VIDEO_ALLOW_SCREENSAVER to override SDL's disabling
+ of the screensaver on Mac OS X and X11.
+
+1.2.10:
+ If SDL_OpenAudio() is passed zero for the desired format
+ fields, the following environment variables will be used
+ to fill them in:
+ SDL_AUDIO_FREQUENCY
+ SDL_AUDIO_FORMAT
+ SDL_AUDIO_CHANNELS
+ SDL_AUDIO_SAMPLES
+ If an environment variable is not specified, it will be set
+ to a reasonable default value.
+
+ Added support for the SDL_VIDEO_FULLSCREEN_HEAD environment
+ variable, currently supported on X11 Xinerama configurations.
+
+ Added SDL_GL_SWAP_CONTROL to wait for vsync in OpenGL applications.
+
+ Added SDL_GL_ACCELERATED_VISUAL to guarantee hardware acceleration.
+
+ Added current_w and current_h to the SDL_VideoInfo structure,
+ which is set to the desktop resolution during video intialization,
+ and then set to the current resolution when a video mode is set.
+
+ SDL_SetVideoMode() now accepts 0 for width or height and will use
+ the current video mode (or the desktop mode if no mode has been set.)
+
+ Added SDL_GetKeyRepeat()
+
+ Added SDL_config.h, with defaults for various build environments.
+
+1.2.7:
+ Added CPU feature detection functions to SDL_cpuinfo.h:
+ SDL_HasRDTSC(), SDL_HasMMX(), SDL_Has3DNow(), SDL_HasSSE(),
+ SDL_HasAltiVec()
+ Added function to create RWops from const memory: SDL_RWFromConstMem()
+
+1.2.6:
+ Added SDL_LoadObject(), SDL_LoadFunction(), and SDL_UnloadObject()
+
+ Added SDL_GL_MULTISAMPLEBUFFERS and SDL_GL_MULTISAMPLESAMPLES for FSAA
+
+1.2.5:
+ Added SDL_BUTTON_WHEELUP (4) and SDL_BUTTON_WHEELDOWN (5)
+
+ Added SDL_GL_STEREO for stereoscopic OpenGL contexts
+
+1.2.0:
+ Added SDL_VIDEOEXPOSE event to signal that the screen needs to
+ be redrawn. This is currently only delivered to OpenGL windows
+ on X11, though it may be delivered in the future when the video
+ memory is lost under DirectX.
+
+1.1.8:
+ You can pass SDL_NOFRAME to SDL_VideoMode() to create a window
+ that has no title bar or frame decoration. Fullscreen video
+ modes automatically have this flag set.
+
+ Added a function to query the clipping rectangle for a surface:
+ void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect)
+
+ Added a function to query the current event filter:
+ SDL_EventFilter SDL_GetEventFilter(void)
+
+ If you pass -1 to SDL_ShowCursor(), it won't change the current
+ cursor visibility state, but will still return it.
+
+ SDL_LockSurface() and SDL_UnlockSurface() are recursive, meaning
+ you can nest them as deep as you want, as long as each lock call
+ has a matching unlock call. The surface remains locked until the
+ last matching unlock call.
+
+ Note that you may not blit to or from a locked surface.
+
+1.1.7:
+ The SDL_SetGammaRamp() and SDL_GetGammaRamp() functions now take
+ arrays of Uint16 values instead of Uint8 values. For the most part,
+ you can just take your old values and shift them up 8 bits to get
+ new correct values for your gamma ramps.
+
+ You can pass SDL_RLEACCEL in flags passed to SDL_ConvertSurface()
+ and SDL will try to RLE accelerate colorkey and alpha blits in the
+ resulting surface.
+
+1.1.6:
+ Added a function to return the thread ID of a specific thread:
+ Uint32 SDL_GetThreadID(SDL_Thread *thread)
+ If 'thread' is NULL, this function returns the id for this thread.
+
+1.1.5:
+ The YUV overlay structure has been changed to use an array of
+ pitches and pixels representing the planes of a YUV image, to
+ better enable hardware acceleration. The YV12 and IYUV formats
+ each have three planes, corresponding to the Y, U, and V portions
+ of the image, while packed pixel YUV formats just have one plane.
+
+ For palettized mode (8bpp), the screen colormap is now split in
+ a physical and a logical palette. The physical palette determines
+ what colours the screen pixels will get when displayed, and the
+ logical palette controls the mapping from blits to/from the screen.
+ A new function, SDL_SetPalette() has been added to change
+ logical and physical palettes separately. SDL_SetColors() works
+ just as before, and is equivalent to calling SDL_SetPalette() with
+ a flag argument of (SDL_LOGPAL|SDL_PHYSPAL).
+
+ SDL_BlitSurface() no longer modifies the source rectangle, only the
+ destination rectangle. The width/height members of the destination
+ rectangle are ignored, only the position is used.
+
+ The old source clipping function SDL_SetClipping() has been replaced
+ with a more useful function to set the destination clipping rectangle:
+ SDL_bool SDL_SetClipRect(SDL_Surface *surface, SDL_Rect *rect)
+
+ Added a function to see what subsystems have been initialized:
+ Uint32 SDL_WasInit(Uint32 flags)
+
+ The Big Alpha Flip: SDL now treats alpha as opacity like everybody
+ else, and not as transparency:
+
+ A new cpp symbol: SDL_ALPHA_OPAQUE is defined as 255
+ A new cpp symbol: SDL_ALPHA_TRANSPARENT is defined as 0
+ Values between 0 and 255 vary from fully transparent to fully opaque.
+
+ New functions:
+ SDL_DisplayFormatAlpha()
+ Returns a surface converted to a format with alpha-channel
+ that can be blit efficiently to the screen. (In other words,
+ like SDL_DisplayFormat() but the resulting surface has
+ an alpha channel.) This is useful for surfaces with alpha.
+ SDL_MapRGBA()
+ Works as SDL_MapRGB() but takes an additional alpha parameter.
+ SDL_GetRGBA()
+ Works as SDL_GetRGB() but also returns the alpha value
+ (SDL_ALPHA_OPAQUE for formats without an alpha channel)
+
+ Both SDL_GetRGB() and SDL_GetRGBA() now always return values in
+ the [0..255] interval. Previously, SDL_GetRGB() would return
+ (0xf8, 0xfc, 0xf8) for a completely white pixel in RGB565 format.
+ (N.B.: This is broken for bit fields < 3 bits.)
+
+ SDL_MapRGB() returns pixels in which the alpha channel is set opaque.
+
+ SDL_SetAlpha() can now be used for both setting the per-surface
+ alpha, using the new way of thinking of alpha, and also to enable
+ and disable per-pixel alpha blending for surfaces with an alpha
+ channel:
+ To disable alpha blending:
+ SDL_SetAlpha(surface, 0, 0);
+ To re-enable alpha blending:
+ SDL_SetAlpha(surface, SDL_SRCALPHA, 0);
+ Surfaces with an alpha channel have blending enabled by default.
+
+ SDL_SetAlpha() now accepts SDL_RLEACCEL as a flag, which requests
+ RLE acceleration of blits, just as like with SDL_SetColorKey().
+ This flag can be set for both surfaces with an alpha channel
+ and surfaces with an alpha value set by SDL_SetAlpha().
+ As always, RLE surfaces must be locked before pixel access is
+ allowed, and unlocked before any other SDL operations are done
+ on it.
+
+ The blit semantics for surfaces with and without alpha and colorkey
+ have now been defined:
+
+ RGBA->RGB:
+ SDL_SRCALPHA set:
+ alpha-blend (using alpha-channel).
+ SDL_SRCCOLORKEY ignored.
+ SDL_SRCALPHA not set:
+ copy RGB.
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ RGB values of the source colour key, ignoring alpha in the
+ comparison.
+
+ RGB->RGBA:
+ SDL_SRCALPHA set:
+ alpha-blend (using the source per-surface alpha value);
+ set destination alpha to opaque.
+ SDL_SRCALPHA not set:
+ copy RGB, set destination alpha to opaque.
+ both:
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ source colour key.
+
+ RGBA->RGBA:
+ SDL_SRCALPHA set:
+ alpha-blend (using the source alpha channel) the RGB values;
+ leave destination alpha untouched. [Note: is this correct?]
+ SDL_SRCCOLORKEY ignored.
+ SDL_SRCALPHA not set:
+ copy all of RGBA to the destination.
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ RGB values of the source colour key, ignoring alpha in the
+ comparison.
+
+ RGB->RGB:
+ SDL_SRCALPHA set:
+ alpha-blend (using the source per-surface alpha value).
+ SDL_SRCALPHA not set:
+ copy RGB.
+ both:
+ if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ source colour key.
+
+ As a special case, blits from surfaces with per-surface alpha
+ value of 128 (50% transparency) are optimised and much faster
+ than other alpha values. This does not apply to surfaces with
+ alpha channels (per-pixel alpha).
+
+ New functions for manipulating the gamma of the display have
+ been added:
+ int SDL_SetGamma(float red, float green, float blue);
+ int SDL_SetGammaRamp(Uint8 *red, Uint8 *green, Uint8 *blue);
+ int SDL_GetGammaRamp(Uint8 *red, Uint8 *green, Uint8 *blue);
+ Gamma ramps are tables with 256 entries which map the screen color
+ components into actually displayed colors. For an example of
+ implementing gamma correction and gamma fades, see test/testgamma.c
+ Gamma control is not supported on all hardware.
+
+1.1.4:
+ The size of the SDL_CDtrack structure changed from 8 to 12 bytes
+ as the size of the length member was extended to 32 bits.
+
+ You can now use SDL for 2D blitting with a GL mode by passing the
+ SDL_OPENGLBLIT flag to SDL_SetVideoMode(). You can specify 16 or
+ 32 bpp, and the data in the framebuffer is put into the GL scene
+ when you call SDL_UpdateRects(), and the scene will be visible
+ when you call SDL_GL_SwapBuffers().
+
+ Run the "testgl" test program with the -logo command line option
+ to see an example of this blending of 2D and 3D in SDL.
+
+1.1.3:
+ Added SDL_FreeRW() to the API, to complement SDL_AllocRW()
+
+ Added resizable window support - just add SDL_RESIZABLE to the
+ SDL_SetVideoMode() flags, and then wait for SDL_VIDEORESIZE events.
+ See SDL_events.h for details on the new SDL_ResizeEvent structure.
+
+ Added condition variable support, based on mutexes and semaphores.
+ SDL_CreateCond()
+ SDL_DestroyCond()
+ SDL_CondSignal()
+ SDL_CondBroadcast()
+ SDL_CondWait()
+ SDL_CondTimedWait()
+ The new function prototypes are in SDL_mutex.h
+
+ Added counting semaphore support, based on the mutex primitive.
+ SDL_CreateSemaphore()
+ SDL_DestroySemaphore()
+ SDL_SemWait()
+ SDL_SemTryWait()
+ SDL_SemWaitTimeout()
+ SDL_SemPost()
+ SDL_SemValue()
+ The new function prototypes are in SDL_mutex.h
+
+ Added support for asynchronous blitting. To take advantage of this,
+ you must set the SDL_ASYNCBLIT flag when setting the video mode and
+ creating surfaces that you want accelerated in this way. You must
+ lock surfaces that have this flag set, and the lock will block until
+ any queued blits have completed.
+
+ Added YUV video overlay support.
+ The supported YUV formats are: YV12, IYUV, YUY2, UYVY, and YVYU.
+ This function creates an overlay surface:
+ SDL_CreateYUVOverlay()
+ You must lock and unlock the overlay to get access to the data:
+ SDL_LockYUVOverlay() SDL_UnlockYUVOverlay()
+ You can then display the overlay:
+ SDL_DisplayYUVOverlay()
+ You must free the overlay when you are done using it:
+ SDL_FreeYUVOverlay()
+ See SDL_video.h for the full function prototypes.
+
+ The joystick hat position constants have been changed:
+ Old constant New constant
+ ------------ ------------
+ 0 SDL_HAT_CENTERED
+ 1 SDL_HAT_UP
+ 2 SDL_HAT_RIGHTUP
+ 3 SDL_HAT_RIGHT
+ 4 SDL_HAT_RIGHTDOWN
+ 5 SDL_HAT_DOWN
+ 6 SDL_HAT_LEFTDOWN
+ 7 SDL_HAT_LEFT
+ 8 SDL_HAT_LEFTUP
+ The new constants are bitmasks, so you can check for the
+ individual axes like this:
+ if ( hat_position & SDL_HAT_UP ) {
+ }
+ and you'll catch left-up, up, and right-up.
+
+1.1.2:
+ Added multiple timer support:
+ SDL_AddTimer() and SDL_RemoveTimer()
+
+ SDL_WM_SetIcon() now respects the icon colorkey if mask is NULL.
+
+1.1.0:
+ Added initial OpenGL support.
+ First set GL attributes (such as RGB depth, alpha depth, etc.)
+ SDL_GL_SetAttribute()
+ Then call SDL_SetVideoMode() with the SDL_OPENGL flag.
+ Perform all of your normal GL drawing.
+ Finally swap the buffers with the new SDL function:
+ SDL_GL_SwapBuffers()
+ See the new 'testgl' test program for an example of using GL with SDL.
+
+ You can load GL extension functions by using the function:
+ SDL_GL_LoadProcAddress()
+
+ Added functions to initialize and cleanup specific SDL subsystems:
+ SDL_InitSubSystem() and SDL_QuitSubSystem()
+
+ Added user-defined event type:
+ typedef struct {
+ Uint8 type;
+ int code;
+ void *data1;
+ void *data2;
+ } SDL_UserEvent;
+ This structure is in the "user" member of an SDL_Event.
+
+ Added a function to push events into the event queue:
+ SDL_PushEvent()
+
+ Example of using the new SDL user-defined events:
+ {
+ SDL_Event event;
+
+ event.type = SDL_USEREVENT;
+ event.user.code = my_event_code;
+ event.user.data1 = significant_data;
+ event.user.data2 = 0;
+ SDL_PushEvent(&event);
+ }
+
+ Added a function to get mouse deltas since last query:
+ SDL_GetRelativeMouseState()
+
+ Added a boolean datatype to SDL_types.h:
+ SDL_bool = { SDL_TRUE, SDL_FALSE }
+
+ Added a function to get the current audio status:
+ SDL_GetAudioState();
+ It returns one of:
+ SDL_AUDIO_STOPPED,
+ SDL_AUDIO_PLAYING,
+ SDL_AUDIO_PAUSED
+
+ Added an AAlib driver (ASCII Art) - by Stephane Peter.
+
+1.0.6:
+ The input grab state is reset after each call to SDL_SetVideoMode().
+ The input is grabbed by default in fullscreen mode, and ungrabbed in
+ windowed mode. If you want to set input grab to a particular value,
+ you should set it after each call to SDL_SetVideoMode().
+
+1.0.5:
+ Exposed SDL_AudioInit(), SDL_VideoInit()
+ Added SDL_AudioDriverName() and SDL_VideoDriverName()
+
+ Added new window manager function:
+ SDL_WM_ToggleFullScreen()
+ This is currently implemented only on Linux
+
+ The ALT-ENTER code has been removed - it's not appropriate for a
+ lib to bind keys when they aren't even emergency escape sequences.
+
+ ALT-ENTER functionality can be implemented with the following code:
+
+ int Handle_AltEnter(const SDL_Event *event)
+ {
+ if ( event->type == SDL_KEYDOWN ) {
+ if ( (event->key.keysym.sym == SDLK_RETURN) &&
+ (event->key.keysym.mod & KMOD_ALT) ) {
+ SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
+ return(0);
+ }
+ }
+ return(1);
+ }
+ SDL_SetEventFilter(Handle_AltEnter);
+
+1.0.3:
+ Under X11, if you grab the input and hide the mouse cursor,
+ the mouse will go into a "relative motion" mode where you
+ will always get relative motion events no matter how far in
+ each direction you move the mouse - relative motion is not
+ bounded by the edges of the window (though the absolute values
+ of the mouse positions are clamped by the size of the window).
+ The SVGAlib, framebuffer console, and DirectInput drivers all
+ have this behavior naturally, and the GDI and BWindow drivers
+ never go into "relative motion" mode.
+
+1.0.2:
+ Added a function to enable keyboard repeat:
+ SDL_EnableKeyRepeat()
+
+ Added a function to grab the mouse and keyboard input
+ SDL_WM_GrabInput()
+
+ Added a function to iconify the window.
+ SDL_WM_IconifyWindow()
+ If this function succeeds, the application will receive an event
+ signaling SDL_APPACTIVE event
+
+1.0.1:
+ Added constants to SDL_audio.h for 16-bit native byte ordering:
+ AUDIO_U16SYS, AUDIO_S16SYS
+
+1.0.0:
+ New public release
+
+Version 0.11:
+
+0.11.5:
+ A new function SDL_GetVideoSurface() has been added, and returns
+ a pointer to the current display surface.
+
+ SDL_AllocSurface() has been renamed SDL_CreateRGBSurface(), and
+ a new function SDL_CreateRGBSurfaceFrom() has been added to allow
+ creating an SDL surface from an existing pixel data buffer.
+
+ Added SDL_GetRGB() to the headers and documentation.
+
+0.11.4:
+ SDL_SetLibraryPath() is no longer meaningful, and has been removed.
+
+0.11.3:
+ A new flag for SDL_Init(), SDL_INIT_NOPARACHUTE, prevents SDL from
+ installing fatal signal handlers on operating systems that support
+ them.
+
+Version 0.9:
+
+0.9.15:
+ SDL_CreateColorCursor() has been removed. Color cursors should
+ be implemented as sprites, blitted by the application when the
+ cursor moves. To get smooth color cursor updates when the app
+ is busy, pass the SDL_INIT_EVENTTHREAD flag to SDL_Init(). This
+ allows you to handle the mouse motion in another thread from an
+ event filter function, but is currently only supported by Linux
+ and BeOS. Note that you'll have to protect the display surface
+ from multi-threaded access by using mutexes if you do this.
+
+ Thread-safe surface support has been removed from SDL.
+ This makes blitting somewhat faster, by removing SDL_MiddleBlit().
+ Code that used SDL_MiddleBlit() should use SDL_LowerBlit() instead.
+ You can make your surfaces thread-safe by allocating your own
+ mutex and making lock/unlock calls around accesses to your surface.
+
+0.9.14:
+ SDL_GetMouseState() now takes pointers to int rather than Uint16.
+
+ If you set the SDL_WINDOWID environment variable under UNIX X11,
+ SDL will use that as the main window instead of creating it's own.
+ This is an unsupported extension to SDL, and not portable at all.
+
+0.9.13:
+ Added a function SDL_SetLibraryPath() which can be used to specify
+ the directory containing the SDL dynamic libraries. This is useful
+ for commercial applications which ship with particular versions
+ of the libraries, and for security on multi-user systems.
+ If this function is not used, the default system directories are
+ searched using the native dynamic object loading mechanism.
+
+ In order to support C linkage under Visual C++, you must declare
+ main() without any return type:
+ main(int argc, char *argv[]) {
+ /* Do the program... */
+ return(0);
+ }
+ C++ programs should also return a value if compiled under VC++.
+
+ The blit_endian member of the SDL_VideoInfo struct has been removed.
+
+ SDL_SymToASCII() has been replaced with SDL_GetKeyName(), so there
+ is now no longer any function to translate a keysym to a character.
+
+ The SDL_keysym structure has been extended with a 'scancode' and
+ 'unicode' member. The 'scancode' is a hardware specific scancode
+ for the key that was pressed, and may be 0. The 'unicode' member
+ is a 16-bit UNICODE translation of the key that was pressed along
+ with any modifiers or compose keys that have been pressed.
+ If no UNICODE translation exists for the key, 'unicode' will be 0.
+
+ Added a function SDL_EnableUNICODE() to enable/disable UNICODE
+ translation of character keypresses. Translation defaults off.
+
+ To convert existing code to use the new API, change code which
+ uses SDL_SymToASCII() to get the keyname to use SDL_GetKeyName(),
+ and change code which uses it to get the ASCII value of a sym to
+ use the 'unicode' member of the event keysym.
+
+0.9.12:
+ There is partial support for 64-bit datatypes. I don't recommend
+ you use this if you have a choice, because 64-bit datatypes are not
+ supported on many platforms. On platforms for which it is supported,
+ the SDL_HAS_64BIT_TYPE C preprocessor define will be enabled, and
+ you can use the Uint64 and Sint64 datatypes.
+
+ Added functions to SDL_endian.h to support 64-bit datatypes:
+ SDL_SwapLE64(), SDL_SwapBE64(),
+ SDL_ReadLE64(), SDL_ReadBE64(), SDL_WriteLE64(), SDL_WriteBE64()
+
+ A new member "len_ratio" has been added to the SDL_AudioCVT structure,
+ and allows you to determine either the original buffer length or the
+ converted buffer length, given the other.
+
+ A new function SDL_FreeWAV() has been added to the API to free data
+ allocated by SDL_LoadWAV_RW(). This is necessary under Win32 since
+ the gcc compiled DLL uses a different heap than VC++ compiled apps.
+
+ SDL now has initial support for international keyboards using the
+ Latin character set.
+ If a particular mapping is desired, you can set the DEFAULT_KEYBOARD
+ compile-time variable, or you can set the environment variable
+ "SDL_KEYBOARD" to a string identifying the keyboard mapping you desire.
+ The valid values for these variables can be found in SDL_keyboard.c
+
+ Full support for German and French keyboards under X11 is implemented.
+
+0.9.11:
+ The THREADED_EVENTS compile-time define has been replaced with the
+ SDL_INIT_EVENTTHREAD flag. If this flag is passed to SDL_Init(),
+ SDL will create a separate thread to perform input event handling.
+ If this flag is passed to SDL_Init(), and the OS doesn't support
+ event handling in a separate thread, SDL_Init() will fail.
+ Be sure to add calls to SDL_Delay() in your main thread to allow
+ the OS to schedule your event thread, or it may starve, leading
+ to slow event delivery and/or dropped events.
+ Currently MacOS and Win32 do not support this flag, while BeOS
+ and Linux do support it. I recommend that your application only
+ use this flag if absolutely necessary.
+
+ The SDL thread function passed to SDL_CreateThread() now returns a
+ status. This status can be retrieved by passing a non-NULL pointer
+ as the 'status' argument to SDL_WaitThread().
+
+ The volume parameter to SDL_MixAudio() has been increased in range
+ from (0-8) to (0-128)
+
+ SDL now has a data source abstraction which can encompass a file,
+ an area of memory, or any custom object you can envision. It uses
+ these abstractions, SDL_RWops, in the endian read/write functions,
+ and the built-in WAV and BMP file loaders. This means you can load
+ WAV chunks from memory mapped files, compressed archives, network
+ pipes, or anything else that has a data read abstraction.
+
+ There are three built-in data source abstractions:
+ SDL_RWFromFile(), SDL_RWFromFP(), SDL_RWFromMem()
+ along with a generic data source allocation function:
+ SDL_AllocRW()
+ These data sources can be used like stdio file pointers with the
+ following convenience functions:
+ SDL_RWseek(), SDL_RWread(), SDL_RWwrite(), SDL_RWclose()
+ These functions are defined in the new header file "SDL_rwops.h"
+
+ The endian swapping functions have been turned into macros for speed
+ and SDL_CalculateEndian() has been removed. SDL_endian.h now defines
+ SDL_BYTEORDER as either SDL_BIG_ENDIAN or SDL_LIL_ENDIAN depending on
+ the endianness of the host system.
+
+ The endian read/write functions now take an SDL_RWops pointer
+ instead of a stdio FILE pointer, to support the new data source
+ abstraction.
+
+ The SDL_*LoadWAV() functions have been replaced with a single
+ SDL_LoadWAV_RW() function that takes a SDL_RWops pointer as it's
+ first parameter, and a flag whether or not to automatically
+ free it as the second parameter. SDL_LoadWAV() is a macro for
+ backward compatibility and convenience:
+ SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
+
+ The SDL_*LoadBMP()/SDL_*SaveBMP() functions have each been replaced
+ with a single function that takes a SDL_RWops pointer as it's
+ first parameter, and a flag whether or not to automatically
+ free it as the second parameter. SDL_LoadBMP() and SDL_SaveBMP()
+ are macros for backward compatibility and convenience:
+ SDL_LoadBMP_RW(SDL_RWFromFile("sample.bmp", "rb"), 1, ...);
+ SDL_SaveBMP_RW(SDL_RWFromFile("sample.bmp", "wb"), 1, ...);
+ Note that these functions use SDL_RWseek() extensively, and should
+ not be used on pipes or other non-seekable data sources.
+
+0.9.10:
+ The Linux SDL_SysWMInfo and SDL_SysWMMsg structures have been
+ extended to support multiple types of display drivers, as well as
+ safe access to the X11 display when THREADED_EVENTS is enabled.
+ The new structures are documented in the SDL_syswm.h header file.
+
+ Thanks to John Elliott , the UK keyboard
+ should now work properly, as well as the "Windows" keys on US
+ keyboards.
+
+ The Linux CD-ROM code now reads the CD-ROM devices from /etc/fstab
+ instead of trying to open each block device on the system.
+ The CD must be listed in /etc/fstab as using the iso9660 filesystem.
+
+ On Linux, if you define THREADED_EVENTS at compile time, a separate
+ thread will be spawned to gather X events asynchronously from the
+ graphics updates. This hasn't been extensively tested, but it does
+ provide a means of handling keyboard and mouse input in a separate
+ thread from the graphics thread. (This is now enabled by default.)
+
+ A special access function SDL_PeepEvents() allows you to manipulate
+ the event queue in a thread-safe manner, including peeking at events,
+ removing events of a specified type, and adding new events of arbitrary
+ type to the queue (use the new 'user' member of the SDL_Event type).
+
+ If you use SDL_PeepEvents() to gather events, then the main graphics
+ thread needs to call SDL_PumpEvents() periodically to drive the event
+ loop and generate input events. This is not necessary if SDL has been
+ compiled with THREADED_EVENTS defined, but doesn't hurt.
+
+ A new function SDL_ThreadID() returns the identifier associated with
+ the current thread.
+
+0.9.9:
+ The AUDIO_STEREO format flag has been replaced with a new 'channels'
+ member of the SDL_AudioSpec structure. The channels are 1 for mono
+ audio, and 2 for stereo audio. In the future more channels may be
+ supported for 3D surround sound.
+
+ The SDL_MixAudio() function now takes an additional volume parameter,
+ which should be set to SDL_MIX_MAXVOLUME for compatibility with the
+ original function.
+
+ The CD-ROM functions which take a 'cdrom' parameter can now be
+ passed NULL, and will act on the last successfully opened CD-ROM.
+
+0.9.8:
+ No changes, bugfixes only.
+
+0.9.7:
+ No changes, bugfixes only.
+
+0.9.6:
+ Added a fast rectangle fill function: SDL_FillRect()
+
+ Addition of a useful function for getting info on the video hardware:
+ const SDL_VideoInfo *SDL_GetVideoInfo(void)
+ This function replaces SDL_GetDisplayFormat().
+
+ Initial support for double-buffering:
+ Use the SDL_DOUBLEBUF flag in SDL_SetVideoMode()
+ Update the screen with a new function: SDL_Flip()
+
+ SDL_AllocSurface() takes two new flags:
+ SDL_SRCCOLORKEY means that the surface will be used for colorkey blits
+ and if the hardware supports hardware acceleration of colorkey blits
+ between two surfaces in video memory, to place the surface in video
+ memory if possible, otherwise it will be placed in system memory.
+ SDL_SRCALPHA means that the surface will be used for alpha blits and
+ if the hardware supports hardware acceleration of alpha blits between
+ two surfaces in video memory, to place the surface in video memory
+ if possible, otherwise it will be placed in system memory.
+ SDL_HWSURFACE now means that the surface will be created with the
+ same format as the display surface, since having surfaces in video
+ memory is only useful for fast blitting to the screen, and you can't
+ blit surfaces with different surface formats in video memory.
+
+0.9.5:
+ You can now pass a NULL mask to SDL_WM_SetIcon(), and it will assume
+ that the icon consists of the entire image.
+
+ SDL_LowerBlit() is back -- but don't use it on the display surface.
+ It is exactly the same as SDL_MiddleBlit(), but doesn't check for
+ thread safety.
+
+ Added SDL_FPLoadBMP(), SDL_FPSaveBMP(), SDL_FPLoadWAV(), which take
+ a FILE pointer instead of a file name.
+
+ Added CD-ROM audio control API:
+ SDL_CDNumDrives()
+ SDL_CDName()
+ SDL_CDOpen()
+ SDL_CDStatus()
+ SDL_CDPlayTracks()
+ SDL_CDPlay()
+ SDL_CDPause()
+ SDL_CDResume()
+ SDL_CDStop()
+ SDL_CDEject()
+ SDL_CDClose()
+
+0.9.4:
+ No changes, bugfixes only.
+
+0.9.3:
+ Mouse motion event now includes relative motion information:
+ Sint16 event->motion.xrel, Sint16 event->motion.yrel
+
+ X11 keyrepeat handling can be disabled by defining IGNORE_X_KEYREPEAT
+ (Add -DIGNORE_X_KEYREPEAT to CFLAGS line in obj/x11Makefile)
+
+0.9.2:
+ No changes, bugfixes only.
+
+0.9.1:
+ Removed SDL_MapSurface() and SDL_UnmapSurface() -- surfaces are now
+ automatically mapped on blit.
+
+0.8.0:
+ SDL stable release
diff --git a/lib/sdl/msvc/docs.html b/lib/sdl/msvc/docs.html
new file mode 100644
index 0000000000000000000000000000000000000000..66ca9235ab9719efb2df64ac424665e8c3deffc3
--- /dev/null
+++ b/lib/sdl/msvc/docs.html
@@ -0,0 +1,629 @@
+
+SDL Stable Release
+
+
+
+
+This source is stable, and is fully tested on all supported platforms.
+Please send bug reports or questions to the SDL mailing list:
+http://www.libsdl.org/mailing-list.php
+The latest stable release may be found on the
+ SDL website.
+
+ Fixed SDL_VIDEO_WINDOW_POS environment variable for Quartz target.
+
+
+ Fixed setting the starting working directory in release builds.
+
+
+
+
+
+
SDL 1.2.13 Release Notes
+
+SDL 1.2.13 is a minor bug fix release.
+
+
+
General Notes
+
+
+
+ Fixed link error when building with Intel Compiler 10.
+
+
+ Removed stray C++ comment from public headers.
+
+
+
+
Unix Notes
+
+
+
+ Fixed crash in SDL_SoftStretch() on secure operating systems.
+
+
+ Fixed undefined symbol on X11 implementations without UTF-8 support.
+
+
+ Worked around BadAlloc error when using XVideo on the XFree86 Intel Integrated Graphics driver.
+
+
+ Scan for all joysticks on Linux instead of stopping at one that was removed.
+
+
+ Fixed use of sdl-config arguments in sdl.m4
+
+
+
+
Windows Notes
+
+
+
+ Fixed crash when a video driver reports higher than 32 bpp video modes.
+
+
+ Fixed restoring the desktop after setting a 24-bit OpenGL video mode.
+
+
+ Fixed window titles on Windows 95/98/ME.
+
+
+ Added SDL_BUTTON_X1 and SDL_BUTTON_X2 constants for extended mouse buttons.
+
+
+ Added support for quoted command line arguments.
+
+
+
+
Mac OS X Notes
+
+
+
+ SDL now builds on Mac OS X 10.5 (Leopard).
+
+
+ Fixed high frequency crash involving text input.
+
+
+ Fixed beeping when the escape key is pressed and UNICODE translation is enabled.
+
+
+ Improved trackpad scrolling support.
+
+
+ Fixed joystick hat reporting for certain joysticks.
+
+
+
+
+
+
SDL 1.2.12 Release Notes
+
+SDL 1.2.12 is a minor bug fix release.
+
+
+
General Notes
+
+
+
+ Added support for the PulseAudio sound server: http://www.pulseaudio.org/
+
+
+ Added SDL_VIDEO_ALLOW_SCREENSAVER to override SDL's disabling of the screensaver on Mac OS X, Windows, and X11.
+
+
+ Fixed buffer overrun crash when resampling audio rates.
+
+
+ Fixed audio bug where converting to mono was doubling the volume.
+
+
+ Fixed off-by-one error in the C implementation of SDL_revcpy()
+
+
+ Fixed compiling with Sun Studio.
+
+
+ Support for AmigaOS has been removed from the main SDL code.
+
+
+ Support for Nokia 9210 "EPOC" driver has been removed from the main SDL code.
+
+
+ Unofficial support for the S60/SymbianOS platform has been added.
+
+
+ Unofficial support for the Nintendo DS platform has been added.
+
+
+ Reenabled MMX assembly for YUV overlay processing (GNU C Compiler only).
+
+
+
+
Unix Notes
+
+
+
+ Fixed detection of X11 DGA mouse support.
+
+
+ Improved XIM support for asian character sets.
+
+
+ The GFX_Display has been added to the X11 window information in SDL_syswm.h.
+
+
+ Fixed PAGE_SIZE compile error in the fbcon video driver on newer Linux kernels.
+
+
+ Fixed hang or crash at startup if aRts can't access the hardware.
+
+
+ Fixed relative mouse mode when the cursor starts outside the X11 window.
+
+
+ Fixed accidental free of stack memory in X11 mouse acceleration code.
+
+
+ Closed minor memory leak in XME code.
+
+
+ Fixed TEXTRELs in the library to resolve some PIC issues.
+
+
+
+
Windows Notes
+
+
+
+ The GDI video driver makes better use of the palette in 8-bit modes.
+
+
+ The windib driver now supports more mouse buttons with WM_XBUTTON events.
+
+
+ On Windows, SDL_SetVideoMode() will re-create the window instead of failing if the multisample settings are changed.
+
+
+ Added support for UTF-8 window titles on Windows.
+
+
+ Fixed joystick detection on Windows.
+
+
+ Improved performance with Win32 file I/O.
+
+
+ Fixed HBITMAP leak in GAPI driver.
+
+
+
+
Mac OS X Notes
+
+
+
+ Added support for multi-axis controllers like 3Dconnxion's SpaceNavigator on Mac OS X.
+
+
+ Fixed YUV overlay crash inside Quicktime on Intel Mac OS X.
+
+
+ Fixed blitting alignment in Altivec alpha blit functions.
+
+
+ Keys F13, F14, and F15 are now usable on Apple keyboards under Mac OS X.
+
+
+ Fixed joystick calibration code on Mac OS X.
+
+
+ Fixed mouse jitter when multiple motion events are queued up in Mac OS X.
+
+
+ Fixed changing the cursor in fullscreen mode on Mac OS X.
+
+
+
+
Mac OS Classic Notes
+
+
+
+ Added support for gamma ramps to both toolbox and DrawSprocket video drivers.
+
+
+
+
BeOS Notes
+
+
+
+ Implemented mouse grabbing and mouse relative mode on BeOS.
+
+
+
+
+
+
SDL 1.2.11 Release Notes
+
+SDL 1.2.11 is a minor bug fix release.
+
+
+
Unix Notes
+
+
+
+ Dynamic X11 loading is only enabled with gcc 4 supporting -fvisibility=hidden. This fixes crashes related to symbol collisions, and allows building on Solaris and IRIX.
+
+
+ Fixed building SDL with Xinerama disabled.
+
+
+ Fixed DRI OpenGL library loading, using RTLD_GLOBAL in dlopen().
+
+
+ Added pkgconfig configuration support.
+
+
+
+
Windows Notes
+
+
+
+ Setting SDL_GL_SWAP_CONTROL now works with Windows OpenGL.
+
+
+ The Win32 window positioning code works properly for windows with menus.
+
+
+ DirectSound audio quality has been improved on certain sound cards.
+
+
+ Fixed 5.1 audio channel ordering on Windows and Mac OS X.
+
+
+ Plugged a couple of minor memory leaks in the windib video driver.
+
+
+ Fixed type collision with stdint.h when building with gcc on Win32.
+
+
+ Fixed building with the Digital Mars Compiler on Win32.
+
+
+
+
Mac OS X Notes
+
+
+
+ The Quartz video driver supports 32x32 cursors on Mac OS X 10.3 and above.
+
+
+
+
+
+
SDL 1.2.10 Release Notes
+
+SDL 1.2.10 is a major release, featuring a revamp of the build system and many API improvements and bug fixes.
+
+
API enhancements
+
+
+ If SDL_OpenAudio() is passed zero for the desired format
+ fields, the following environment variables will be used
+ to fill them in:
+
+ If an environment variable is not specified, it will be set
+ to a reasonable default value.
+
+ SDL_SetVideoMode() now accepts 0 for width or height and will use
+ the current video mode (or the desktop mode if no mode has been set.)
+
+ Added current_w and current_h to the SDL_VideoInfo structure,
+ which is set to the desktop resolution during video intialization,
+ and then set to the current resolution when a video mode is set.
+
+ SDL_GL_LoadLibrary() will load the system default OpenGL library
+ if it is passed NULL as a parameter.
+
+ Added SDL_GL_SWAP_CONTROL to wait for vsync in OpenGL applications.
+
+ Added SDL_GL_ACCELERATED_VISUAL to guarantee hardware acceleration.
+
+ SDL_WM_SetCaption() now officially takes UTF-8 title and icon strings, and displays international characters on supported platforms.
+
+ Added SDL_GetKeyRepeat() to query the key repeat settings.
+
+ Added the "dummy" audio driver, which can be used to emulate audio
+ output without a sound card.
+
+ Added SDL_config.h, with defaults for various build environments.
+
+ SDL is licensed under version 2.1 of the GNU Lesser General Public License.
+
+ The entire build system has been revamped to make it much more portable, including versions of C library functions to make it possible to run SDL on a minimal embedded environment. See README.Porting in the SDL source distribution for information on how to port SDL to a new platform.
+
+ The X11 libraries are dynamically loaded at runtime by default. This allows the distributed version of SDL to run on systems without X11 libraries installed.
+
+ The XiG XME extension code is now included in the X11 video driver by default.
+
+ XRandR support for video mode switching has been added to the X11 driver, but is disabled because of undesired interactions with window managers. You can enable this by setting the environment variable SDL_VIDEO_X11_XRANDR to 1.
+
+ Xinerama multi-head displays are properly handled now, and the SDL_VIDEO_FULLSCREEN_HEAD environment variable can be used to select the screen used for fullscreen video modes. Note that changing the video modes only works on screen 0.
+
+ XVidMode video modes are now sorted so they maintain the refresh rates specified in the X11 configuration file.
+
+ SDL windows are no longer transparent in X11 compositing systems like XGL.
+
+ The mouse is properly released by the X11 video driver if the fullscreen window loses focus.
+
+ The X11 input driver now uses XIM to handle international input.
+
+ The screensaver and DPMS monitor blanking are disabled while SDL games are running under the X11 and DGA video drivers. This behavior will be formalized and selectable in SDL 1.3.
+
+ Fixed a bug preventing stereo OpenGL contexts from being selected on the X11 driver.
+
+ The DGA video driver now waits for pending blits involving surfaces before they are freed. This prevents display oddities when using SDL_DisplayFormat() to convert many images.
+
+ The framebuffer console video driver now has a parser for /etc/fb.modes for improved video mode handling.
+
+ The framebuffer console video driver now allows asynchronous VT switching, and restores the full contents of the screen when switched back.
+
+ The framebuffer console now uses CTRL-ALT-FN to switch virtual terminals, to avoid collisions with application key bindings.
+
+ The framebuffer console input driver correctly sets IMPS/2 mode for wheel mice. It also properly detects when gpm is in IMPS/2 protocol mode, or passing raw protocol from an IMPS/2 mouse.
+
+ The SVGAlib video driver now has support for banked (non-linear) video modes.
+
+ A video driver for OpenBSD on the Sharp Zaurus has been contributed by Staffan Ulfberg. See the file README.wscons in the SDL source distribution for details.
+
+ Many patches have been incorporated from *BSD ports.
+
+
+
Windows Notes
+
+
+
+ The "windib" video driver is the default now, to prevent problems with certain laptops, 64-bit Windows, and Windows Vista. The DirectX driver is still available, and can be selected by setting the environment variable SDL_VIDEODRIVER to "directx".
+
+ SDL has been ported to 64-bit Windows.
+
+ Dmitry Yakimov contributed a GAPI video driver for Windows CE.
+
+ The default fullscreen refresh rate has been increased to match the desktop refresh rate, when using equivalent resolutions. A full API for querying and selecting refresh rates is planned for SDL 1.3.
+
+ Dialog boxes are now shown when SDL is in windowed OpenGL mode.
+
+ The SDL window is recreated when necessary to maintain OpenGL context attributes, when switching between windowed and fullscreen modes.
+
+ An SDL_VIDEORESIZE event is properly sent when the SDL window is maximized and restored.
+
+ Window positions are retained when switching between fullscreen and windowed modes.
+
+ ToUnicode() is used, when available, for improved handling of international keyboard input.
+
+ The PrtScrn is now treated normally with both key down and key up events.
+
+ Pressing ALT-F4 now delivers an SDL_QUIT event to SDL applications.
+
+ Joystick names are now correct for joysticks which have been unplugged and then plugged back in since booting.
+
+ An MCI error when playing the last track on a CD-ROM has been fixed.
+
+ OpenWatcom projects for building SDL have been provided by Marc Peter.
+
+
+
Mac OS X Notes
+
+
+
+ SDL now supports building Universal binaries, both through Xcode projects and when using configure/make. See README.MacOSX in the SDL source archive for details.
+
+ The X11 video driver with GLX support can be built on Mac OS X, if the X11 development SDK is installed.
+
+ Transitions between fullscreen resolutions and windowed mode now use a much faster asynchronous fade to hide desktop flicker.
+
+ Icons set with SDL_WM_SetIcon() now have the proper colors on Intel Macs.
+
+
+
OS/2 Notes
+
+
+
+ Projects for building SDL on OS/2 with OpenWatcom have been contributed by Doodle. See the file README.OS2 in the SDL source distribution for details.
+
SDL_CloseAudio -- Shuts down audio processing and closes the audio device.
Sound on the computer is translated from waves that you hear into a series of
+values, or samples, each representing the amplitude of the wave. When these
+samples are sent in a stream to a sound card, an approximation of the original
+wave can be recreated. The more bits used to represent the amplitude, and the
+greater frequency these samples are gathered, the closer the approximated
+sound is to the original, and the better the quality of sound.
This library supports both 8 and 16 bit signed and unsigned sound samples,
+at frequencies ranging from 11025 Hz to 44100 Hz, depending on the
+underlying hardware. If the hardware doesn't support the desired audio
+format or frequency, it can be emulated if desired (See
+SDL_OpenAudio())
A commonly supported audio format is 16 bits per sample at 22050 Hz.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/cdrom.html b/lib/sdl/msvc/docs/html/cdrom.html
new file mode 100644
index 0000000000000000000000000000000000000000..bdd6bfd827252c479bb6af20b2bb9e5c1d89e96e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/cdrom.html
@@ -0,0 +1,260 @@
+CD-ROM
SDL supports audio control of up to 32 local CD-ROM drives at once.
You use this API to perform all the basic functions of a CD player,
+including listing the tracks, playing, stopping, and ejecting the CD-ROM.
+(Currently, multi-changer CD drives are not supported.)
Before you call any of the SDL CD-ROM functions, you must first call
+"SDL_Init(SDL_INIT_CDROM)", which scans the system for
+CD-ROM drives, and sets the program up for audio control. Check the
+return code, which should be 0, to see if there
+were any errors in starting up.
After you have initialized the library, you can find out how many drives
+are available using the SDL_CDNumDrives() function.
+The first drive listed is the system default CD-ROM drive. After you have
+chosen a drive, and have opened it with SDL_CDOpen(),
+you can check the status and start playing if there's a CD in the drive.
A CD-ROM is organized into one or more tracks, each consisting of a certain
+number of "frames". Each frame is ~2K in size, and at normal playing speed,
+a CD plays 75 frames per second. SDL works with the number of frames on a
+CD, but this can easily be converted to the more familiar minutes/seconds
+format by using the FRAMES_TO_MSF() macro.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/event.html b/lib/sdl/msvc/docs/html/event.html
new file mode 100644
index 0000000000000000000000000000000000000000..f2bddb2c0ab67b02b750f51d4cb26ac9e74d8e9f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/event.html
@@ -0,0 +1,216 @@
+Events
Event handling allows your application to receive input from the user. Event handling is initalised (along with video) with a call to:
+
SDL_Init(SDL_INIT_VIDEO);
+Internally, SDL stores all the events waiting to be handled in an event queue. Using functions like SDL_PollEvent and SDL_PeepEvents you can observe and handle waiting input events.
The key to event handling in SDL is the SDL_Event union. The event queue itself is composed of a series of SDL_Event unions, one for each waiting event. SDL_Event unions are read from the queue with the SDL_PollEvent function and it is then up to the application to process the information stored with them.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/eventfunctions.html b/lib/sdl/msvc/docs/html/eventfunctions.html
new file mode 100644
index 0000000000000000000000000000000000000000..f68a29a3bf174bc37ee7e94a6ad398688f553a8b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/eventfunctions.html
@@ -0,0 +1,481 @@
+Event Functions.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/eventstructures.html b/lib/sdl/msvc/docs/html/eventstructures.html
new file mode 100644
index 0000000000000000000000000000000000000000..c95929622039acd86961fe3d766deec5018a2bb2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/eventstructures.html
@@ -0,0 +1,233 @@
+SDL Event Structures.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/general.html b/lib/sdl/msvc/docs/html/general.html
new file mode 100644
index 0000000000000000000000000000000000000000..0beb5919f8b3d02aa6eee04b4fccbc93c0564b1d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/general.html
@@ -0,0 +1,225 @@
+General
Before SDL can be used in a program it must be initialized with SDL_Init. SDL_Init initializes all the subsystems that the user requests (video, audio, joystick, timers and/or cdrom). Once SDL is initialized with SDL_Init subsystems can be shut down and initialized as needed using SDL_InitSubSystem and SDL_QuitSubSystem.
SDL must also be shut down before the program exits to make sure it cleans up correctly. Calling SDL_Quit shuts down all subsystems and frees any resources allocated to SDL.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guide.html b/lib/sdl/msvc/docs/html/guide.html
new file mode 100644
index 0000000000000000000000000000000000000000..2c1297ee2bd2c35715324e0339a28513a7f9790c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guide.html
@@ -0,0 +1,174 @@
+SDL Guide
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideaboutsdldoc.html b/lib/sdl/msvc/docs/html/guideaboutsdldoc.html
new file mode 100644
index 0000000000000000000000000000000000000000..cdb0d783c2bc3307040d7764865fb297484af0ae
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideaboutsdldoc.html
@@ -0,0 +1,148 @@
+About SDLdoc
SDLdoc (The SDL Documentation Project) was formed to completely rewrite the SDL documentation and to keep it continually up to date. The team consists completely of volunteers ranging from people working with SDL in their spare time to people who use SDL in their everyday working lives.
The latest version of this documentation can always be found here: http://sdldoc.csn.ul.ie Downloadable PS, man pages and html tarballs are available at http://sdldoc.csn.ul.ie/pub/
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideaudioexamples.html b/lib/sdl/msvc/docs/html/guideaudioexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..afb7522be7d2367b1b47a5cc90392bab68bc3a3b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideaudioexamples.html
@@ -0,0 +1,228 @@
+Audio Examples
SDL_AudioSpec wanted;
+ extern void fill_audio(void *udata, Uint8 *stream, int len);
+
+ /* Set the audio format */
+ wanted.freq = 22050;
+ wanted.format = AUDIO_S16;
+ wanted.channels = 2; /* 1 = mono, 2 = stereo */
+ wanted.samples = 1024; /* Good low-latency value for callback */
+ wanted.callback = fill_audio;
+ wanted.userdata = NULL;
+
+ /* Open the audio device, forcing the desired format */
+ if ( SDL_OpenAudio(&wanted, NULL) < 0 ) {
+ fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+ return(-1);
+ }
+ return(0);
Playing audio
static Uint8 *audio_chunk;
+ static Uint32 audio_len;
+ static Uint8 *audio_pos;
+
+ /* The audio function callback takes the following parameters:
+ stream: A pointer to the audio buffer to be filled
+ len: The length (in bytes) of the audio buffer
+ */
+ void fill_audio(void *udata, Uint8 *stream, int len)
+ {
+ /* Only play if we have data left */
+ if ( audio_len == 0 )
+ return;
+
+ /* Mix as much data as possible */
+ len = ( len > audio_len ? audio_len : len );
+ SDL_MixAudio(stream, audio_pos, len, SDL_MIX_MAXVOLUME);
+ audio_pos += len;
+ audio_len -= len;
+ }
+
+ /* Load the audio data ... */
+
+ ;;;;;
+
+ audio_pos = audio_chunk;
+
+ /* Let the callback function play the audio chunk */
+ SDL_PauseAudio(0);
+
+ /* Do some processing */
+
+ ;;;;;
+
+ /* Wait for sound to complete */
+ while ( audio_len > 0 ) {
+ SDL_Delay(100); /* Sleep 1/10 second */
+ }
+ SDL_CloseAudio();
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidebasicsinit.html b/lib/sdl/msvc/docs/html/guidebasicsinit.html
new file mode 100644
index 0000000000000000000000000000000000000000..faafdbd9204ab3a3070f2f2d5daa1af0c9e1a8f3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidebasicsinit.html
@@ -0,0 +1,240 @@
+Initializing SDL
SDL is composed of eight subsystems - Audio, CDROM, Event Handling, File I/O, Joystick Handling, Threading, Timers and Video. Before you can use any of these subsystems they must be initialized by calling SDL_Init (or SDL_InitSubSystem). SDL_Init must be called before any other SDL function. It automatically initializes the Event Handling, File I/O and Threading subsystems and it takes a parameter specifying which other subsystems to initialize. So, to initialize the default subsystems and the Video subsystems you would call:
+
SDL_Init ( SDL_INIT_VIDEO );
+To initialize the default subsystems, the Video subsystem and the Timers subsystem you would call:
+
SDL_Init ( SDL_INIT_VIDEO | SDL_INIT_TIMER );
SDL_Init is complemented by SDL_Quit (and SDL_QuitSubSystem). SDL_Quit shuts down all subsystems, including the default ones. It should always be called before a SDL application exits.
With SDL_Init and SDL_Quit firmly embedded in your programmers toolkit you can write your first and most basic SDL application. However, we must be prepare to handle errors. Many SDL functions return a value and indicates whether the function has succeeded or failed, SDL_Init, for instance, returns -1 if it could not initialize a subsystem. SDL provides a useful facility that allows you to determine exactly what the problem was, every time an error occurs within SDL an error message is stored which can be retrieved using SDL_GetError. Use this often, you can never know too much about an error.
Example 1-1. Initializing SDL
#include "SDL.h" /* All SDL App's need this */
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+
+ printf("Initializing SDL.\n");
+
+ /* Initialize defaults, Video and Audio */
+ if((SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO)==-1)) {
+ printf("Could not initialize SDL: %s.\n", SDL_GetError());
+ exit(-1);
+ }
+
+ printf("SDL initialized.\n");
+
+ printf("Quiting SDL.\n");
+
+ /* Shutdown all subsystems */
+ SDL_Quit();
+
+ printf("Quiting....\n");
+
+ exit(0);
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidecdromexamples.html b/lib/sdl/msvc/docs/html/guidecdromexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..2bc5a16cb53f20d54e26436d00f46f5a53f68434
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidecdromexamples.html
@@ -0,0 +1,275 @@
+CDROM Examples
#include "SDL.h"
+
+ /* Initialize SDL first */
+ if ( SDL_Init(SDL_INIT_CDROM) < 0 ) {
+ fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
+ exit(1);
+ }
+ atexit(SDL_Quit);
+
+ /* Find out how many CD-ROM drives are connected to the system */
+ printf("Drives available: %d\n", SDL_CDNumDrives());
+ for ( i=0; i<SDL_CDNumDrives(); ++i ) {
+ printf("Drive %d: \"%s\"\n", i, SDL_CDName(i));
+ }
Opening the default drive
SDL_CD *cdrom;
+ CDstatus status;
+ char *status_str;
+
+ cdrom = SDL_CDOpen(0);
+ if ( cdrom == NULL ) {
+ fprintf(stderr, "Couldn't open default CD-ROM drive: %s\n",
+ SDL_GetError());
+ exit(2);
+ }
+
+ status = SDL_CDStatus(cdrom);
+ switch (status) {
+ case CD_TRAYEMPTY:
+ status_str = "tray empty";
+ break;
+ case CD_STOPPED:
+ status_str = "stopped";
+ break;
+ case CD_PLAYING:
+ status_str = "playing";
+ break;
+ case CD_PAUSED:
+ status_str = "paused";
+ break;
+ case CD_ERROR:
+ status_str = "error state";
+ break;
+ }
+ printf("Drive status: %s\n", status_str);
+ if ( status >= CD_PLAYING ) {
+ int m, s, f;
+ FRAMES_TO_MSF(cdrom->cur_frame, &m, &s, &f);
+ printf("Currently playing track %d, %d:%2.2d\n",
+ cdrom->track[cdrom->cur_track].id, m, s);
+ }
Listing the tracks on a CD
SDL_CD *cdrom; /* Assuming this has already been set.. */
+ int i;
+ int m, s, f;
+
+ SDL_CDStatus(cdrom);
+ printf("Drive tracks: %d\n", cdrom->numtracks);
+ for ( i=0; i<cdrom->numtracks; ++i ) {
+ FRAMES_TO_MSF(cdrom->track[i].length, &m, &s, &f);
+ if ( f > 0 )
+ ++s;
+ printf("\tTrack (index %d) %d: %d:%2.2d\n", i,
+ cdrom->track[i].id, m, s);
+ }
Play an entire CD
SDL_CD *cdrom; /* Assuming this has already been set.. */
+
+ // Play entire CD:
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
+ SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
+
+ // Play last track:
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) {
+ SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0);
+ }
+
+ // Play first and second track and 10 seconds of third track:
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
+ SDL_CDPlayTracks(cdrom, 0, 0, 2, CD_FPS * 10);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidecredits.html b/lib/sdl/msvc/docs/html/guidecredits.html
new file mode 100644
index 0000000000000000000000000000000000000000..b66b28f54dbcad18dcaad6d8f783ebc7621789f2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidecredits.html
@@ -0,0 +1,195 @@
+Credits
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideeventexamples.html b/lib/sdl/msvc/docs/html/guideeventexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..300136947cb7286820691982296bd70b171f2a16
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideeventexamples.html
@@ -0,0 +1,247 @@
+Event Examples
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideexamples.html b/lib/sdl/msvc/docs/html/guideexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..5b9a8471df853828c8c48f22145cc43ae69b9106
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideexamples.html
@@ -0,0 +1,188 @@
+Examples
For the moment these examples are taken directly from the old SDL documentation. By the 1.2 release these examples should hopefully deal with most common SDL programming problems.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideinput.html b/lib/sdl/msvc/docs/html/guideinput.html
new file mode 100644
index 0000000000000000000000000000000000000000..4a82b6761abdcebce1b4c165337d60967dff1224
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideinput.html
@@ -0,0 +1,739 @@
+Input handling
The first step in using a joystick in a SDL program is to initialize the Joystick subsystems of SDL. This done by passing the SDL_INIT_JOYSTICK flag to SDL_Init. The joystick flag will usually be used in conjunction with other flags (like the video flag) because the joystick is usually used to control something.
Example 3-1. Initializing SDL with Joystick Support
This will attempt to start SDL with both the video and the joystick subsystems activated.
Querying
If we have reached this point then we can safely assume that the SDL library has been initialized and that the Joystick subsystem is active. We can now call some video and/or sound functions to get things going before we need the joystick. Eventually we have to make sure that there is actually a joystick to work with. It's wise to always check even if you know a joystick will be present on the system because it can also help detect when the joystick is unplugged. The function used to check for joysticks is SDL_NumJoysticks.
This function simply returns the number of joysticks available on the system. If it is at least one then we are in good shape. The next step is to determine which joystick the user wants to use. If the number of joysticks available is only one then it is safe to assume that one joystick is the one the user wants to use. SDL has a function to get the name of the joysticks as assigned by the operations system and that function is SDL_JoystickName. The joystick is specified by an index where 0 is the first joystick and the last joystick is the number returned by SDL_NumJoysticks - 1. In the demonstration a list of all available joysticks is printed to stdout.
Example 3-2. Querying the Number of Available Joysticks
printf("%i joysticks were found.\n\n", SDL_NumJoysticks() );
+ printf("The names of the joysticks are:\n");
+
+ for( i=0; i < SDL_NumJoysticks(); i++ )
+ {
+ printf(" %s\n", SDL_JoystickName(i));
+ }
Opening a Joystick and Receiving Joystick Events
SDL's event driven architecture makes working with joysticks a snap. Joysticks can trigger 4 different types of events:
+
Events are received from all joysticks opened. The first thing that needs to be done in order to receive joystick events is to call SDL_JoystickEventState with the SDL_ENABLE flag. Next you must open the joysticks that you want to receive envents from. This is done with the SDL_JoystickOpen function. For the example we are only interested in events from the first joystick on the system, regardless of what it may be. To receive events from it we would do this:
If we wanted to receive events for other joysticks we would open them with calls to SDL_JoystickOpen just like we opened joystick 0, except we would store the SDL_Joystick structure they return in a different pointer. We only need the joystick pointer when we are querying the joysticks or when we are closing the joystick.
Up to this point all the code we have is used just to initialize the joysticks in order to read values at run time. All we need now is an event loop, which is something that all SDL programs should have anyway to receive the systems quit events. We must now add code to check the event loop for at least some of the above mentioned events. Let's assume our event loop looks like this:
+
SDL_Event event;
+ /* Other initializtion code goes here */
+
+ /* Start main game loop here */
+
+ while(SDL_PollEvent(&event))
+ {
+ switch(event.type)
+ {
+ case SDL_KEYDOWN:
+ /* handle keyboard stuff here */
+ break;
+
+ case SDL_QUIT:
+ /* Set whatever flags are necessary to */
+ /* end the main game loop here */
+ break;
+ }
+ }
+
+ /* End loop here */
+To handle Joystick events we merely add cases for them, first we'll add axis handling code. Axis checks can get kinda of tricky because alot of the joystick events received are junk. Joystick axis have a tendency to vary just a little between polling due to the way they are designed. To compensate for this you have to set a threshold for changes and ignore the events that have'nt exceeded the threshold. 10% is usually a good threshold value. This sounds a lot more complicated than it is. Here is the Axis event handler:
Another trick with axis events is that up-down and left-right movement are two different sets of axes. The most important axis is axis 0 (left-right) and axis 1 (up-down). To handle them seperatly in the code we do the following:
Ideally the code here should use event.jaxis.value to scale something. For example lets assume you are using the joystick to control the movement of a spaceship. If the user is using an analog joystick and they push the stick a little bit they expect to move less than if they pushed it a lot. Designing your code for this situation is preferred because it makes the experience for users of analog controls better and remains the same for users of digital controls.
If your joystick has any additional axis then they may be used for other sticks or throttle controls and those axis return values too just with different event.jaxis.axis values.
Button handling is simple compared to the axis checking.
Example 3-6. Joystick Button Events
case SDL_JOYBUTTONDOWN: /* Handle Joystick Button Presses */
+ if ( event.jbutton.button == 0 )
+ {
+ /* code goes here */
+ }
+ break;
Button checks are simpler than axis checks because a button can only be pressed or not pressed. The SDL_JOYBUTTONDOWN event is triggered when a button is pressed and the SDL_JOYBUTTONUP event is fired when a button is released. We do have to know what button was pressed though, that is done by reading the event.jbutton.button field.
Lastly when we are through using our joysticks we should close them with a call to SDL_JoystickClose. To close our opened joystick 0 we would do this at the end of our program:
+
SDL_JoystickClose(joystick);
Advanced Joystick Functions
That takes care of the controls that you can count on being on every joystick under the sun, but there are a few extra things that SDL can support. Joyballs are next on our list, they are alot like axis with a few minor differences. Joyballs store relative changes unlike the the absolute postion stored in a axis event. Also one trackball event contains both the change in x and they change in y. Our case for it is as follows:
The above checks the first joyball on the joystick. The change in position will be stored in event.jball.xrel and event.jball.yrel.
Finally we have the hat event. Hats report only the direction they are pushed in. We check hat's position with the bitmasks:
+
+
SDL_HAT_CENTERED
SDL_HAT_UP
SDL_HAT_RIGHT
SDL_HAT_DOWN
SDL_HAT_LEFT
+
+Also there are some predefined combinations of the above:
+
SDL_HAT_RIGHTUP
SDL_HAT_RIGHTDOWN
SDL_HAT_LEFTUP
SDL_HAT_LEFTDOWN
+
+Our case for the hat may resemble the following:
Example 3-8. Joystick Hat Events
case SDL_JOYHATMOTION: /* Handle Hat Motion */
+ if ( event.jhat.value & SDL_HAT_UP )
+ {
+ /* Do up stuff here */
+ }
+
+ if ( event.jhat.value & SDL_HAT_LEFT )
+ {
+ /* Do left stuff here */
+ }
+
+ if ( event.jhat.value & SDL_HAT_RIGHTDOWN )
+ {
+ /* Do right and down together stuff here */
+ }
+ break;
In addition to the queries for number of joysticks on the system and their names there are additional functions to query the capabilities of attached joysticks:
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guideinputkeyboard.html b/lib/sdl/msvc/docs/html/guideinputkeyboard.html
new file mode 100644
index 0000000000000000000000000000000000000000..787036c7f2ad3b8e35dfb6dd578d2b9e5085b4c8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guideinputkeyboard.html
@@ -0,0 +1,746 @@
+Handling the Keyboard
It should make it a lot easier to understand this tutorial is you are familiar with the data types involved in keyboard access, so I'll explain them first.
SDLKey
SDLKey is an enumerated type defined in SDL/include/SDL_keysym.h and detailed here. Each SDLKey symbol represents a key, SDLK_a corresponds to the 'a' key on a keyboard, SDLK_SPACE corresponds to the space bar, and so on.
SDLMod
SDLMod is an enumerated type, similar to SDLKey, however it enumerates keyboard modifiers (Control, Alt, Shift). The full list of modifier symbols is here. SDLMod values can be AND'd together to represent several modifiers.
The SDL_keysym structure describes a key press or a key release. The scancode field is hardware specific and should be ignored unless you know what your doing. The sym field is the SDLKey value of the key being pressed or released. The mod field describes the state of the keyboard modifiers at the time the key press or release occurred. So a value of KMOD_NUM | KMOD_CAPS | KMOD_LSHIFT would mean that Numlock, Capslock and the left shift key were all press (or enabled in the case of the lock keys). Finally, the unicode field stores the 16-bit unicode value of the key.
Note: It should be noted and understood that this field is only valid when the SDL_keysym is describing a key press, not a key release. Unicode values only make sense on a key press because the unicode value describes an international character and only key presses produce characters. More information on Unicode can be found at www.unicode.org
Note: Unicode translation must be enabled using the SDL_EnableUNICODE function.
The SDL_KeyboardEvent describes a keyboard event (obviously). The key member of the SDL_Event union is a SDL_KeyboardEvent structure. The type field specifies whether the event is a key release (SDL_KEYUP) or a key press (SDL_KEYDOWN) event. The state is largely redundant, it reports the same information as the type field but uses different values (SDL_RELEASED and SDL_PRESSED). The keysym contains information of the key press or release that this event represents (see above).
Reading Keyboard Events
Reading keybaord events from the event queue is quite simple (the event queue and using it is described here). We read events using SDL_PollEvent in a while() loop and check for SDL_KEYUP and SDL_KEYDOWN events using a switch statement, like so:
Example 3-10. Reading Keyboard Events
SDL_Event event;
+ .
+ .
+ /* Poll for events. SDL_PollEvent() returns 0 when there are no */
+ /* more events on the event queue, our while loop will exit when */
+ /* that occurs. */
+ while( SDL_PollEvent( &event ) ){
+ /* We are only worried about SDL_KEYDOWN and SDL_KEYUP events */
+ switch( event.type ){
+ case SDL_KEYDOWN:
+ printf( "Key press detected\n" );
+ break;
+
+ case SDL_KEYUP:
+ printf( "Key release detected\n" );
+ break;
+
+ default:
+ break;
+ }
+ }
+ .
+ .
This is a very basic example. No information about the key press or release is interpreted. We will explore the other extreme out our first full example below - reporting all available information about a keyboard event.
A More Detailed Look
Before we can read events SDL must be initialised with SDL_Init and a video mode must be set using SDL_SetVideoMode. There are, however, two other functions we must use to obtain all the information required. We must enable unicode translation by calling SDL_EnableUNICODE(1) and we must convert SDLKey values into something printable, using SDL_GetKeyName
Note: It is useful to note that unicode values < 0x80 translate directly a characters ASCII value. THis is used in the example below
Example 3-11. Interpreting Key Event Information
#include "SDL.h"
+
+ /* Function Prototypes */
+ void PrintKeyInfo( SDL_KeyboardEvent *key );
+ void PrintModifiers( SDLMod mod );
+
+ /* main */
+ int main( int argc, char *argv[] ){
+
+ SDL_Event event;
+ int quit = 0;
+
+ /* Initialise SDL */
+ if( SDL_Init( SDL_INIT_VIDEO ) < 0){
+ fprintf( stderr, "Could not initialise SDL: %s\n", SDL_GetError() );
+ exit( -1 );
+ }
+
+ /* Set a video mode */
+ if( !SDL_SetVideoMode( 320, 200, 0, 0 ) ){
+ fprintf( stderr, "Could not set video mode: %s\n", SDL_GetError() );
+ SDL_Quit();
+ exit( -1 );
+ }
+
+ /* Enable Unicode translation */
+ SDL_EnableUNICODE( 1 );
+
+ /* Loop until an SDL_QUIT event is found */
+ while( !quit ){
+
+ /* Poll for events */
+ while( SDL_PollEvent( &event ) ){
+
+ switch( event.type ){
+ /* Keyboard event */
+ /* Pass the event data onto PrintKeyInfo() */
+ case SDL_KEYDOWN:
+ case SDL_KEYUP:
+ PrintKeyInfo( &event.key );
+ break;
+
+ /* SDL_QUIT event (window close) */
+ case SDL_QUIT:
+ quit = 1;
+ break;
+
+ default:
+ break;
+ }
+
+ }
+
+ }
+
+ /* Clean up */
+ SDL_Quit();
+ exit( 0 );
+ }
+
+ /* Print all information about a key event */
+ void PrintKeyInfo( SDL_KeyboardEvent *key ){
+ /* Is it a release or a press? */
+ if( key->type == SDL_KEYUP )
+ printf( "Release:- " );
+ else
+ printf( "Press:- " );
+
+ /* Print the hardware scancode first */
+ printf( "Scancode: 0x%02X", key->keysym.scancode );
+ /* Print the name of the key */
+ printf( ", Name: %s", SDL_GetKeyName( key->keysym.sym ) );
+ /* We want to print the unicode info, but we need to make */
+ /* sure its a press event first (remember, release events */
+ /* don't have unicode info */
+ if( key->type == SDL_KEYDOWN ){
+ /* If the Unicode value is less than 0x80 then the */
+ /* unicode value can be used to get a printable */
+ /* representation of the key, using (char)unicode. */
+ printf(", Unicode: " );
+ if( key->keysym.unicode < 0x80 && key->keysym.unicode > 0 ){
+ printf( "%c (0x%04X)", (char)key->keysym.unicode,
+ key->keysym.unicode );
+ }
+ else{
+ printf( "? (0x%04X)", key->keysym.unicode );
+ }
+ }
+ printf( "\n" );
+ /* Print modifier info */
+ PrintModifiers( key->keysym.mod );
+ }
+
+ /* Print modifier info */
+ void PrintModifiers( SDLMod mod ){
+ printf( "Modifers: " );
+
+ /* If there are none then say so and return */
+ if( mod == KMOD_NONE ){
+ printf( "None\n" );
+ return;
+ }
+
+ /* Check for the presence of each SDLMod value */
+ /* This looks messy, but there really isn't */
+ /* a clearer way. */
+ if( mod & KMOD_NUM ) printf( "NUMLOCK " );
+ if( mod & KMOD_CAPS ) printf( "CAPSLOCK " );
+ if( mod & KMOD_LCTRL ) printf( "LCTRL " );
+ if( mod & KMOD_RCTRL ) printf( "RCTRL " );
+ if( mod & KMOD_RSHIFT ) printf( "RSHIFT " );
+ if( mod & KMOD_LSHIFT ) printf( "LSHIFT " );
+ if( mod & KMOD_RALT ) printf( "RALT " );
+ if( mod & KMOD_LALT ) printf( "LALT " );
+ if( mod & KMOD_CTRL ) printf( "CTRL " );
+ if( mod & KMOD_SHIFT ) printf( "SHIFT " );
+ if( mod & KMOD_ALT ) printf( "ALT " );
+ printf( "\n" );
+ }
Game-type Input
I have found that people using keyboard events for games and other interactive applications don't always understand one fundemental point.
Keyboard events only take place when a keys state changes from being unpressed to pressed, and vice versa.
Imagine you have an image of an alien that you wish to move around using the cursor keys: when you pressed the left arrow key you want him to slide over to the left, and when you press the down key you want him to slide down the screen. Examine the following code; it highlights an error that many people have made.
+
/* Alien screen coordinates */
+ int alien_x=0, alien_y=0;
+ .
+ .
+ /* Initialise SDL and video modes and all that */
+ .
+ /* Main game loop */
+ /* Check for events */
+ while( SDL_PollEvent( &event ) ){
+ switch( event.type ){
+ /* Look for a keypress */
+ case SDL_KEYDOWN:
+ /* Check the SDLKey values and move change the coords */
+ switch( event.key.keysym.sym ){
+ case SDLK_LEFT:
+ alien_x -= 1;
+ break;
+ case SDLK_RIGHT:
+ alien_x += 1;
+ break;
+ case SDLK_UP:
+ alien_y -= 1;
+ break;
+ case SDLK_DOWN:
+ alien_y += 1;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ .
+ .
+At first glance you may think this is a perfectly reasonable piece of code for the task, but it isn't. Like I said keyboard events only occur when a key changes state, so the user would have to press and release the left cursor key 100 times to move the alien 100 pixels to the left.
To get around this problem we must not use the events to change the position of the alien, we use the events to set flags which are then used in a seperate section of code to move the alien. Something like this:
Example 3-12. Proper Game Movement
/* Alien screen coordinates */
+ int alien_x=0, alien_y=0;
+ int alien_xvel=0, alien_yvel=0;
+ .
+ .
+ /* Initialise SDL and video modes and all that */
+ .
+ /* Main game loop */
+ /* Check for events */
+ while( SDL_PollEvent( &event ) ){
+ switch( event.type ){
+ /* Look for a keypress */
+ case SDL_KEYDOWN:
+ /* Check the SDLKey values and move change the coords */
+ switch( event.key.keysym.sym ){
+ case SDLK_LEFT:
+ alien_xvel = -1;
+ break;
+ case SDLK_RIGHT:
+ alien_xvel = 1;
+ break;
+ case SDLK_UP:
+ alien_yvel = -1;
+ break;
+ case SDLK_DOWN:
+ alien_yvel = 1;
+ break;
+ default:
+ break;
+ }
+ break;
+ /* We must also use the SDL_KEYUP events to zero the x */
+ /* and y velocity variables. But we must also be */
+ /* careful not to zero the velocities when we shouldn't*/
+ case SDL_KEYUP:
+ switch( event.key.keysym.sym ){
+ case SDLK_LEFT:
+ /* We check to make sure the alien is moving */
+ /* to the left. If it is then we zero the */
+ /* velocity. If the alien is moving to the */
+ /* right then the right key is still press */
+ /* so we don't tocuh the velocity */
+ if( alien_xvel < 0 )
+ alien_xvel = 0;
+ break;
+ case SDLK_RIGHT:
+ if( alien_xvel > 0 )
+ alien_xvel = 0;
+ break;
+ case SDLK_UP:
+ if( alien_yvel < 0 )
+ alien_yvel = 0;
+ break;
+ case SDLK_DOWN:
+ if( alien_yvel > 0 )
+ alien_yvel = 0;
+ break;
+ default:
+ break;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ .
+ .
+ /* Update the alien position */
+ alien_x += alien_xvel;
+ alien_y += alien_yvel;
As can be seen, we use two extra variables, alien_xvel and alien_yvel, which represent the motion of the ship, it is these variables that we update when we detect keypresses and releases.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidepreface.html b/lib/sdl/msvc/docs/html/guidepreface.html
new file mode 100644
index 0000000000000000000000000000000000000000..9986fc6b75392c35a7975476c1dfa10f75a3ec02
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidepreface.html
@@ -0,0 +1,178 @@
+Preface
The SDL library is designed to make it easy to write games that run on Linux, *BSD, MacOS, Win32 and BeOS using the various native high-performance media interfaces, (for video, audio, etc) and presenting a single source-code level API to your application. SDL is a fairly low level API, but using it, completely portable applications can be written with a great deal of flexibility.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidethebasics.html b/lib/sdl/msvc/docs/html/guidethebasics.html
new file mode 100644
index 0000000000000000000000000000000000000000..4f32363f38a08821678f115e7c5e7a6c10ea92b9
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidethebasics.html
@@ -0,0 +1,173 @@
+The Basics
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidetimeexamples.html b/lib/sdl/msvc/docs/html/guidetimeexamples.html
new file mode 100644
index 0000000000000000000000000000000000000000..42b5019ebf0443e3f91e5f4475eb6d2589031b72
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidetimeexamples.html
@@ -0,0 +1,183 @@
+Time Examples
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidevideo.html b/lib/sdl/msvc/docs/html/guidevideo.html
new file mode 100644
index 0000000000000000000000000000000000000000..85da77d1fd162c4f420f1f41b2f98ad0577e0740
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidevideo.html
@@ -0,0 +1,463 @@
+Graphics and Video
Video is probably the most common thing that SDL is used for, and
+so it has the most complete subsystem. Here are a few
+examples to demonstrate the basics.
Initializing the Video Display
This is what almost all SDL programs have to do in one way or
+another.
Example 2-1. Initializing the Video Display
SDL_Surface *screen;
+
+ /* Initialize the SDL library */
+ if( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
+ fprintf(stderr,
+ "Couldn't initialize SDL: %s\n", SDL_GetError());
+ exit(1);
+ }
+
+ /* Clean up on exit */
+ atexit(SDL_Quit);
+
+ /*
+ * Initialize the display in a 640x480 8-bit palettized mode,
+ * requesting a software surface
+ */
+ screen = SDL_SetVideoMode(640, 480, 8, SDL_SWSURFACE);
+ if ( screen == NULL ) {
+ fprintf(stderr, "Couldn't set 640x480x8 video mode: %s\n",
+ SDL_GetError());
+ exit(1);
+ }
Initializing the Best Video Mode
If you have a preference for a certain pixel depth but will accept any
+other, use SDL_SetVideoMode with SDL_ANYFORMAT as below. You can also
+use SDL_VideoModeOK() to find the native video mode that is closest to
+the mode you request.
Example 2-2. Initializing the Best Video Mode
/* Have a preference for 8-bit, but accept any depth */
+ screen = SDL_SetVideoMode(640, 480, 8, SDL_SWSURFACE|SDL_ANYFORMAT);
+ if ( screen == NULL ) {
+ fprintf(stderr, "Couldn't set 640x480x8 video mode: %s\n",
+ SDL_GetError());
+ exit(1);
+ }
+ printf("Set 640x480 at %d bits-per-pixel mode\n",
+ screen->format->BitsPerPixel);
Loading and Displaying a BMP File
The following function loads and displays a BMP file given as
+argument, once SDL is initialised and a video mode has been set.
Example 2-3. Loading and Displaying a BMP File
void display_bmp(char *file_name)
+{
+ SDL_Surface *image;
+
+ /* Load the BMP file into a surface */
+ image = SDL_LoadBMP(file_name);
+ if (image == NULL) {
+ fprintf(stderr, "Couldn't load %s: %s\n", file_name, SDL_GetError());
+ return;
+ }
+
+ /*
+ * Palettized screen modes will have a default palette (a standard
+ * 8*8*4 colour cube), but if the image is palettized as well we can
+ * use that palette for a nicer colour matching
+ */
+ if (image->format->palette && screen->format->palette) {
+ SDL_SetColors(screen, image->format->palette->colors, 0,
+ image->format->palette->ncolors);
+ }
+
+ /* Blit onto the screen surface */
+ if(SDL_BlitSurface(image, NULL, screen, NULL) < 0)
+ fprintf(stderr, "BlitSurface error: %s\n", SDL_GetError());
+
+ SDL_UpdateRect(screen, 0, 0, image->w, image->h);
+
+ /* Free the allocated BMP surface */
+ SDL_FreeSurface(image);
+}
Drawing Directly to the Display
The following two functions can be used to get and set single
+pixels of a surface. They are carefully written to work with any depth
+currently supported by SDL. Remember to lock the surface before
+calling them, and to unlock it before calling any other SDL
+functions.
To convert between pixel values and their red, green, blue
+components, use SDL_GetRGB() and SDL_MapRGB().
Example 2-4. getpixel()
/*
+ * Return the pixel value at (x, y)
+ * NOTE: The surface must be locked before calling this!
+ */
+Uint32 getpixel(SDL_Surface *surface, int x, int y)
+{
+ int bpp = surface->format->BytesPerPixel;
+ /* Here p is the address to the pixel we want to retrieve */
+ Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
+
+ switch(bpp) {
+ case 1:
+ return *p;
+
+ case 2:
+ return *(Uint16 *)p;
+
+ case 3:
+ if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
+ return p[0] << 16 | p[1] << 8 | p[2];
+ else
+ return p[0] | p[1] << 8 | p[2] << 16;
+
+ case 4:
+ return *(Uint32 *)p;
+
+ default:
+ return 0; /* shouldn't happen, but avoids warnings */
+ }
+}
Example 2-5. putpixel()
/*
+ * Set the pixel at (x, y) to the given value
+ * NOTE: The surface must be locked before calling this!
+ */
+void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
+{
+ int bpp = surface->format->BytesPerPixel;
+ /* Here p is the address to the pixel we want to set */
+ Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
+
+ switch(bpp) {
+ case 1:
+ *p = pixel;
+ break;
+
+ case 2:
+ *(Uint16 *)p = pixel;
+ break;
+
+ case 3:
+ if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+ p[0] = (pixel >> 16) & 0xff;
+ p[1] = (pixel >> 8) & 0xff;
+ p[2] = pixel & 0xff;
+ } else {
+ p[0] = pixel & 0xff;
+ p[1] = (pixel >> 8) & 0xff;
+ p[2] = (pixel >> 16) & 0xff;
+ }
+ break;
+
+ case 4:
+ *(Uint32 *)p = pixel;
+ break;
+ }
+}
The following code uses the putpixel() function above to set a
+yellow pixel in the middle of the screen.
Example 2-6. Using putpixel()
/* Code to set a yellow pixel at the center of the screen */
+
+ int x, y;
+ Uint32 yellow;
+
+ /* Map the color yellow to this display (R=0xff, G=0xFF, B=0x00)
+ Note: If the display is palettized, you must set the palette first.
+ */
+ yellow = SDL_MapRGB(screen->format, 0xff, 0xff, 0x00);
+
+ x = screen->w / 2;
+ y = screen->h / 2;
+
+ /* Lock the screen for direct access to the pixels */
+ if ( SDL_MUSTLOCK(screen) ) {
+ if ( SDL_LockSurface(screen) < 0 ) {
+ fprintf(stderr, "Can't lock screen: %s\n", SDL_GetError());
+ return;
+ }
+ }
+
+ putpixel(screen, x, y, yellow);
+
+ if ( SDL_MUSTLOCK(screen) ) {
+ SDL_UnlockSurface(screen);
+ }
+ /* Update just the part of the display that we've changed */
+ SDL_UpdateRect(screen, x, y, 1, 1);
+
+ return;
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/guidevideoopengl.html b/lib/sdl/msvc/docs/html/guidevideoopengl.html
new file mode 100644
index 0000000000000000000000000000000000000000..0abd5671861a5ac85167e532550c7ae60b43a0fc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/guidevideoopengl.html
@@ -0,0 +1,730 @@
+Using OpenGL With SDL
SDL has the ability to create and use OpenGL contexts on several platforms(Linux/X11, Win32, BeOS, MacOS Classic/Toolbox, Mac OS X, FreeBSD/X11 and Solaris/X11). This allows you to use SDL's audio, event handling, threads and times in your OpenGL applications (a function often performed by GLUT).
Initialisation
Initialising SDL to use OpenGL is not very different to initialising SDL normally. There are three differences; you must pass SDL_OPENGL to SDL_SetVideoMode, you must specify several GL attributes (depth buffer size, framebuffer sizes) using SDL_GL_SetAttribute and finally, if you wish to use double buffering you must specify it as a GL attribute, not by passing the SDL_DOUBLEBUF flag to SDL_SetVideoMode.
Example 2-7. Initializing SDL with OpenGL
/* Information about the current video settings. */
+ const SDL_VideoInfo* info = NULL;
+ /* Dimensions of our window. */
+ int width = 0;
+ int height = 0;
+ /* Color depth in bits of our window. */
+ int bpp = 0;
+ /* Flags we will pass into SDL_SetVideoMode. */
+ int flags = 0;
+
+ /* First, initialize SDL's video subsystem. */
+ if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
+ /* Failed, exit. */
+ fprintf( stderr, "Video initialization failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /* Let's get some video information. */
+ info = SDL_GetVideoInfo( );
+
+ if( !info ) {
+ /* This should probably never happen. */
+ fprintf( stderr, "Video query failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /*
+ * Set our width/height to 640/480 (you would
+ * of course let the user decide this in a normal
+ * app). We get the bpp we will request from
+ * the display. On X11, VidMode can't change
+ * resolution, so this is probably being overly
+ * safe. Under Win32, ChangeDisplaySettings
+ * can change the bpp.
+ */
+ width = 640;
+ height = 480;
+ bpp = info->vfmt->BitsPerPixel;
+
+ /*
+ * Now, we want to setup our requested
+ * window attributes for our OpenGL window.
+ * We want *at least* 5 bits of red, green
+ * and blue. We also want at least a 16-bit
+ * depth buffer.
+ *
+ * The last thing we do is request a double
+ * buffered window. '1' turns on double
+ * buffering, '0' turns it off.
+ *
+ * Note that we do not use SDL_DOUBLEBUF in
+ * the flags to SDL_SetVideoMode. That does
+ * not affect the GL attribute state, only
+ * the standard 2D blitting setup.
+ */
+ SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
+ SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+ /*
+ * We want to request that SDL provide us
+ * with an OpenGL window, in a fullscreen
+ * video mode.
+ *
+ * EXERCISE:
+ * Make starting windowed an option, and
+ * handle the resize events properly with
+ * glViewport.
+ */
+ flags = SDL_OPENGL | SDL_FULLSCREEN;
+
+ /*
+ * Set the video mode
+ */
+ if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
+ /*
+ * This could happen for a variety of reasons,
+ * including DISPLAY not being set, the specified
+ * resolution not being available, etc.
+ */
+ fprintf( stderr, "Video mode set failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
Drawing
Apart from initialisation, using OpenGL within SDL is the same as using OpenGL
+with any other API, e.g. GLUT. You still use all the same function calls and
+data types. However if you are using a double-buffered display, then you must
+use
+SDL_GL_SwapBuffers()
+to swap the buffers and update the display. To request double-buffering
+with OpenGL, use
+SDL_GL_SetAttribute
+with SDL_GL_DOUBLEBUFFER, and use
+SDL_GL_GetAttribute
+to see if you actually got it.
A full example code listing is now presented below.
Example 2-8. SDL and OpenGL
/*
+ * SDL OpenGL Tutorial.
+ * (c) Michael Vance, 2000
+ * briareos@lokigames.com
+ *
+ * Distributed under terms of the LGPL.
+ */
+
+#include <SDL/SDL.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static GLboolean should_rotate = GL_TRUE;
+
+static void quit_tutorial( int code )
+{
+ /*
+ * Quit SDL so we can release the fullscreen
+ * mode and restore the previous video settings,
+ * etc.
+ */
+ SDL_Quit( );
+
+ /* Exit program. */
+ exit( code );
+}
+
+static void handle_key_down( SDL_keysym* keysym )
+{
+
+ /*
+ * We're only interested if 'Esc' has
+ * been presssed.
+ *
+ * EXERCISE:
+ * Handle the arrow keys and have that change the
+ * viewing position/angle.
+ */
+ switch( keysym->sym ) {
+ case SDLK_ESCAPE:
+ quit_tutorial( 0 );
+ break;
+ case SDLK_SPACE:
+ should_rotate = !should_rotate;
+ break;
+ default:
+ break;
+ }
+
+}
+
+static void process_events( void )
+{
+ /* Our SDL event placeholder. */
+ SDL_Event event;
+
+ /* Grab all the events off the queue. */
+ while( SDL_PollEvent( &event ) ) {
+
+ switch( event.type ) {
+ case SDL_KEYDOWN:
+ /* Handle key presses. */
+ handle_key_down( &event.key.keysym );
+ break;
+ case SDL_QUIT:
+ /* Handle quit requests (like Ctrl-c). */
+ quit_tutorial( 0 );
+ break;
+ }
+
+ }
+
+}
+
+static void draw_screen( void )
+{
+ /* Our angle of rotation. */
+ static float angle = 0.0f;
+
+ /*
+ * EXERCISE:
+ * Replace this awful mess with vertex
+ * arrays and a call to glDrawElements.
+ *
+ * EXERCISE:
+ * After completing the above, change
+ * it to use compiled vertex arrays.
+ *
+ * EXERCISE:
+ * Verify my windings are correct here ;).
+ */
+ static GLfloat v0[] = { -1.0f, -1.0f, 1.0f };
+ static GLfloat v1[] = { 1.0f, -1.0f, 1.0f };
+ static GLfloat v2[] = { 1.0f, 1.0f, 1.0f };
+ static GLfloat v3[] = { -1.0f, 1.0f, 1.0f };
+ static GLfloat v4[] = { -1.0f, -1.0f, -1.0f };
+ static GLfloat v5[] = { 1.0f, -1.0f, -1.0f };
+ static GLfloat v6[] = { 1.0f, 1.0f, -1.0f };
+ static GLfloat v7[] = { -1.0f, 1.0f, -1.0f };
+ static GLubyte red[] = { 255, 0, 0, 255 };
+ static GLubyte green[] = { 0, 255, 0, 255 };
+ static GLubyte blue[] = { 0, 0, 255, 255 };
+ static GLubyte white[] = { 255, 255, 255, 255 };
+ static GLubyte yellow[] = { 0, 255, 255, 255 };
+ static GLubyte black[] = { 0, 0, 0, 255 };
+ static GLubyte orange[] = { 255, 255, 0, 255 };
+ static GLubyte purple[] = { 255, 0, 255, 0 };
+
+ /* Clear the color and depth buffers. */
+ glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+ /* We don't want to modify the projection matrix. */
+ glMatrixMode( GL_MODELVIEW );
+ glLoadIdentity( );
+
+ /* Move down the z-axis. */
+ glTranslatef( 0.0, 0.0, -5.0 );
+
+ /* Rotate. */
+ glRotatef( angle, 0.0, 1.0, 0.0 );
+
+ if( should_rotate ) {
+
+ if( ++angle > 360.0f ) {
+ angle = 0.0f;
+ }
+
+ }
+
+ /* Send our triangle data to the pipeline. */
+ glBegin( GL_TRIANGLES );
+
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+ glColor4ubv( blue );
+ glVertex3fv( v2 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+
+ glColor4ubv( white );
+ glVertex3fv( v3 );
+ glColor4ubv( orange );
+ glVertex3fv( v6 );
+ glColor4ubv( purple );
+ glVertex3fv( v7 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( red );
+ glVertex3fv( v0 );
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+
+ glColor4ubv( green );
+ glVertex3fv( v1 );
+ glColor4ubv( yellow );
+ glVertex3fv( v4 );
+ glColor4ubv( black );
+ glVertex3fv( v5 );
+
+ glEnd( );
+
+ /*
+ * EXERCISE:
+ * Draw text telling the user that 'Spc'
+ * pauses the rotation and 'Esc' quits.
+ * Do it using vetors and textured quads.
+ */
+
+ /*
+ * Swap the buffers. This this tells the driver to
+ * render the next frame from the contents of the
+ * back-buffer, and to set all rendering operations
+ * to occur on what was the front-buffer.
+ *
+ * Double buffering prevents nasty visual tearing
+ * from the application drawing on areas of the
+ * screen that are being updated at the same time.
+ */
+ SDL_GL_SwapBuffers( );
+}
+
+static void setup_opengl( int width, int height )
+{
+ float ratio = (float) width / (float) height;
+
+ /* Our shading model--Gouraud (smooth). */
+ glShadeModel( GL_SMOOTH );
+
+ /* Culling. */
+ glCullFace( GL_BACK );
+ glFrontFace( GL_CCW );
+ glEnable( GL_CULL_FACE );
+
+ /* Set the clear color. */
+ glClearColor( 0, 0, 0, 0 );
+
+ /* Setup our viewport. */
+ glViewport( 0, 0, width, height );
+
+ /*
+ * Change to the projection matrix and set
+ * our viewing volume.
+ */
+ glMatrixMode( GL_PROJECTION );
+ glLoadIdentity( );
+ /*
+ * EXERCISE:
+ * Replace this with a call to glFrustum.
+ */
+ gluPerspective( 60.0, ratio, 1.0, 1024.0 );
+}
+
+int main( int argc, char* argv[] )
+{
+ /* Information about the current video settings. */
+ const SDL_VideoInfo* info = NULL;
+ /* Dimensions of our window. */
+ int width = 0;
+ int height = 0;
+ /* Color depth in bits of our window. */
+ int bpp = 0;
+ /* Flags we will pass into SDL_SetVideoMode. */
+ int flags = 0;
+
+ /* First, initialize SDL's video subsystem. */
+ if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
+ /* Failed, exit. */
+ fprintf( stderr, "Video initialization failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /* Let's get some video information. */
+ info = SDL_GetVideoInfo( );
+
+ if( !info ) {
+ /* This should probably never happen. */
+ fprintf( stderr, "Video query failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /*
+ * Set our width/height to 640/480 (you would
+ * of course let the user decide this in a normal
+ * app). We get the bpp we will request from
+ * the display. On X11, VidMode can't change
+ * resolution, so this is probably being overly
+ * safe. Under Win32, ChangeDisplaySettings
+ * can change the bpp.
+ */
+ width = 640;
+ height = 480;
+ bpp = info->vfmt->BitsPerPixel;
+
+ /*
+ * Now, we want to setup our requested
+ * window attributes for our OpenGL window.
+ * We want *at least* 5 bits of red, green
+ * and blue. We also want at least a 16-bit
+ * depth buffer.
+ *
+ * The last thing we do is request a double
+ * buffered window. '1' turns on double
+ * buffering, '0' turns it off.
+ *
+ * Note that we do not use SDL_DOUBLEBUF in
+ * the flags to SDL_SetVideoMode. That does
+ * not affect the GL attribute state, only
+ * the standard 2D blitting setup.
+ */
+ SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
+ SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
+ SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+ /*
+ * We want to request that SDL provide us
+ * with an OpenGL window, in a fullscreen
+ * video mode.
+ *
+ * EXERCISE:
+ * Make starting windowed an option, and
+ * handle the resize events properly with
+ * glViewport.
+ */
+ flags = SDL_OPENGL | SDL_FULLSCREEN;
+
+ /*
+ * Set the video mode
+ */
+ if( SDL_SetVideoMode( width, height, bpp, flags ) == 0 ) {
+ /*
+ * This could happen for a variety of reasons,
+ * including DISPLAY not being set, the specified
+ * resolution not being available, etc.
+ */
+ fprintf( stderr, "Video mode set failed: %s\n",
+ SDL_GetError( ) );
+ quit_tutorial( 1 );
+ }
+
+ /*
+ * At this point, we should have a properly setup
+ * double-buffered window for use with OpenGL.
+ */
+ setup_opengl( width, height );
+
+ /*
+ * Now we want to begin our normal app process--
+ * an event loop with a lot of redrawing.
+ */
+ while( 1 ) {
+ /* Process incoming events. */
+ process_events( );
+ /* Draw the screen. */
+ draw_screen( );
+ }
+
+ /*
+ * EXERCISE:
+ * Record timings using SDL_GetTicks() and
+ * and print out frames per second at program
+ * end.
+ */
+
+ /* Never reached. */
+ return 0;
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/index.html b/lib/sdl/msvc/docs/html/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..f86ff191d3208669e4d33384164ccb09d0a73cc9
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/index.html
@@ -0,0 +1,1156 @@
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/joystick.html b/lib/sdl/msvc/docs/html/joystick.html
new file mode 100644
index 0000000000000000000000000000000000000000..abdb28c1979d9166801529ae6ef1cc1f95daac15
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/joystick.html
@@ -0,0 +1,296 @@
+Joystick
Joysticks, and other similar input devices, have a very strong role in game playing and SDL provides comprehensive support for them. Axes, Buttons, POV Hats and trackballs are all supported.
Joystick support is initialized by passed the SDL_INIT_JOYSTICK flag to SDL_Init. Once initilized joysticks must be opened using SDL_JoystickOpen.
While using the functions describe in this secton may seem like the best way to access and read from joysticks, in most cases they aren't. Ideally joysticks should be read using the event system. To enable this, you must set the joystick event processing state with SDL_JoystickEventState. Joysticks must be opened before they can be used of course.
Note: If you are not handling the joystick via the event queue then you must explicitly request a joystick update by calling SDL_JoystickUpdate.
Note: Force Feedback is not yet support. Sam (slouken@libsdl.org) is soliciting suggestions from people with force-feedback experience on the best wat to desgin the API.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/reference.html b/lib/sdl/msvc/docs/html/reference.html
new file mode 100644
index 0000000000000000000000000000000000000000..e7707a7504f9b348279fa1e492c1bac8421386be
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/reference.html
@@ -0,0 +1,194 @@
+SDL Reference
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlactiveevent.html b/lib/sdl/msvc/docs/html/sdlactiveevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..d3f2821e728de69d2219c945cdd3ed61687b3360
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlactiveevent.html
@@ -0,0 +1,335 @@
+SDL_ActiveEvent
SDL_APPMOUSEFOCUS if mouse focus was gained or lost, SDL_APPINPUTFOCUS if input focus was gained or lost, or SDL_APPACTIVE if the application was iconified (gain=0) or restored(gain=1).
Description
SDL_ActiveEvent is a member of the SDL_Event union and is used when an event of type SDL_ACTIVEEVENT is reported.
When the mouse leaves or enters the window area a SDL_APPMOUSEFOCUS type activation event occurs, if the mouse entered the window then gain will be 1, otherwise gain will be 0. A SDL_APPINPUTFOCUS type activation event occurs when the application loses or gains keyboard focus. This usually occurs when another application is made active. Finally, a SDL_APPACTIVE type event occurs when the application is either minimised/iconified (gain=0) or restored.
Note: This event does not occur when an application window is first created.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdladdtimer.html b/lib/sdl/msvc/docs/html/sdladdtimer.html
new file mode 100644
index 0000000000000000000000000000000000000000..81c49e56d655d3b33bae4a1bda9510656cc25de3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdladdtimer.html
@@ -0,0 +1,296 @@
+SDL_AddTimer
/* type definition for the "new" timer callback function */
+typedef Uint32 (*SDL_NewTimerCallback)(Uint32 interval, void *param);
Description
Adds a callback function to be run after the specified number of
+milliseconds has elapsed. The callback function is passed the current
+timer interval and the user supplied parameter from the
+SDL_AddTimer call and returns the next timer
+interval. If the returned value from the callback is the same as the one
+passed in, the periodic alarm continues, otherwise a new alarm is
+scheduled.
To cancel a currently running timer call
+SDL_RemoveTimer with the
+timer ID returned from
+SDL_AddTimer.
The timer callback function may run in a different thread than your
+main program, and so shouldn't call any functions from within itself.
+You may always call SDL_PushEvent, however.
The granularity of the timer is platform-dependent, but you should count
+on it being at least 10 ms as this is the most common number.
+This means that if
+you request a 16 ms timer, your callback will run approximately 20 ms
+later on an unloaded system. If you wanted to set a flag signaling
+a frame update at 30 frames per second (every 33 ms), you might set a
+timer for 30 ms (see example below).
+
+If you use this function, you need to pass SDL_INIT_TIMER
+to SDL_Init.
Return Value
Returns an ID value for the added timer or
+NULL if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlaudiocvt.html b/lib/sdl/msvc/docs/html/sdlaudiocvt.html
new file mode 100644
index 0000000000000000000000000000000000000000..ff39209080e8a8e4de91fdfaa490189516e26675
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlaudiocvt.html
@@ -0,0 +1,556 @@
+SDL_AudioCVT
typedef struct{
+ int needed;
+ Uint16 src_format;
+ Uint16 dest_format;
+ double rate_incr;
+ Uint8 *buf;
+ int len;
+ int len_cvt;
+ int len_mult;
+ double len_ratio;
+ void (*filters[10])(struct SDL_AudioCVT *cvt, Uint16 format);
+ int filter_index;
+} SDL_AudioCVT;
Structure Data
needed
Set to one if the conversion is possible
src_format
Audio format of the source
dest_format
Audio format of the destination
rate_incr
Rate conversion increment
buf
Audio buffer
len
Length of the original audio buffer in bytes
len_cvt
Length of converted audio buffer in bytes (calculated)
len_mult
buf must be len*len_mult bytes in size(calculated)
len_ratio
Final audio size is len*len_ratio
filters[10](..)
Pointers to functions needed for this conversion
filter_index
Current conversion function
Description
The SDL_AudioCVT is used to convert audio data between different formats. A SDL_AudioCVT structure is created with the SDL_BuildAudioCVT function, while the actual conversion is done by the SDL_ConvertAudio function.
Many of the fields in the SDL_AudioCVT structure should be considered private and their function will not be discussed here.
Uint8 *buf
This points to the audio data that will be used in the conversion. It is both the source and the destination, which means the converted audio data overwrites the original data. It also means that the converted data may be larger than the original data (if you were converting from 8-bit to 16-bit, for instance), so you must ensure buf is large enough. See below.
intlen
This is the length of the original audio data in bytes.
intlen_mult
As explained above, the audio buffer needs to be big enough to store the converted data, which may be bigger than the original audio data. The length of buf should be len*len_mult.
doublelen_ratio
When you have finished converting your audio data, you need to know how much of your audio buffer is valid. len*len_ratio is the size of the converted audio data in bytes. This is very similar to len_mult, however when the convert audio data is shorter than the original len_mult would be 1. len_ratio, on the other hand, would be a fractional number between 0 and 1.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlaudiospec.html b/lib/sdl/msvc/docs/html/sdlaudiospec.html
new file mode 100644
index 0000000000000000000000000000000000000000..fc6fa75035d89162989141d22a06148dbcfc5e97
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlaudiospec.html
@@ -0,0 +1,589 @@
+SDL_AudioSpec
Pointer the user data which is passed to the callback function
Description
The SDL_AudioSpec structure is used to describe the format of some audio data. This structure is used by SDL_OpenAudio and SDL_LoadWAV. While all fields are used by SDL_OpenAudio only freq, format, samples and channels are used by SDL_LoadWAV. We will detail these common members here.
freq
The number of samples sent to the sound device every second. Common values are 11025, 22050 and 44100. The higher the better.
format
Specifies the size and type of each sample element
+
AUDIO_U8
Unsigned 8-bit samples
AUDIO_S8
Signed 8-bit samples
AUDIO_U16 or AUDIO_U16LSB
Unsigned 16-bit little-endian samples
AUDIO_S16 or AUDIO_S16LSB
Signed 16-bit little-endian samples
AUDIO_U16MSB
Unsigned 16-bit big-endian samples
AUDIO_S16MSB
Signed 16-bit big-endian samples
AUDIO_U16SYS
Either AUDIO_U16LSB or AUDIO_U16MSB depending on you systems endianness
AUDIO_S16SYS
Either AUDIO_S16LSB or AUDIO_S16MSB depending on you systems endianness
channels
The number of seperate sound channels. 1 is mono (single channel), 2 is stereo (dual channel).
samples
When used with SDL_OpenAudio this refers to the size of the audio buffer in samples. A sample a chunk of audio data of the size specified in format mulitplied by the number of channels. When the SDL_AudioSpec is used with SDL_LoadWAVsamples is set to 4096.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlblitsurface.html b/lib/sdl/msvc/docs/html/sdlblitsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..3123ff5dde119aa773125906a13c19957b7a19f6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlblitsurface.html
@@ -0,0 +1,339 @@
+SDL_BlitSurface
SDL_BlitSurface -- This performs a fast blit from the source surface to the destination surface.
Synopsis
#include "SDL.h"
int SDL_BlitSurface(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);
Description
This performs a fast blit from the source surface to the destination surface.
The width and height in srcrect determine the
+size of the copied rectangle. Only the position is used in the
+dstrect (the width and height are ignored).
If srcrect is NULL, the
+entire surface is copied. If dstrect is
+NULL, then the destination position (upper left
+corner) is (0, 0).
The final blit rectangle is saved in
+dstrect after all clipping is performed
+(srcrect is not modified).
The blit function should not be called on a locked surface.
The results of blitting operations vary greatly depending on whether SDL_SRCAPLHA is set or not. See SDL_SetAlpha for an explaination of how this affects your results. Colorkeying and alpha attributes also interact with surface blitting, as the following pseudo-code should hopefully explain.
+
if (source surface has SDL_SRCALPHA set) {
+ if (source surface has alpha channel (that is, format->Amask != 0))
+ blit using per-pixel alpha, ignoring any colour key
+ else {
+ if (source surface has SDL_SRCCOLORKEY set)
+ blit using the colour key AND the per-surface alpha value
+ else
+ blit using the per-surface alpha value
+ }
+} else {
+ if (source surface has SDL_SRCCOLORKEY set)
+ blit using the colour key
+ else
+ ordinary opaque rectangular blit
+}
Return Value
If the blit is successful, it returns 0,
+otherwise it returns -1.
If either of the surfaces were in video memory, and the blit returns
+-2, the video memory was lost, so it should be
+reloaded with artwork and re-blitted:
+
+This happens under DirectX 5.0 when the system switches away from your
+fullscreen application. Locking the surface will also fail until you
+have access to the video memory again.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlbuildaudiocvt.html b/lib/sdl/msvc/docs/html/sdlbuildaudiocvt.html
new file mode 100644
index 0000000000000000000000000000000000000000..2e8420e8a9ce962189600e17bed60d4479964ee3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlbuildaudiocvt.html
@@ -0,0 +1,291 @@
+SDL_BuildAudioCVT
SDL_BuildAudioCVT -- Initializes a SDL_AudioCVT structure for conversion
Synopsis
#include "SDL.h"
int SDL_BuildAudioCVT(SDL_AudioCVT *cvt, Uint16 src_format, Uint8 src_channels, int src_rate, Uint16 dst_format, Uint8 dst_channels, int dst_rate);
Description
Before an SDL_AudioCVT structure can be used to convert audio data it must be initialized with source and destination information.
src_format and dst_format are the source and destination format of the conversion. (For information on audio formats see SDL_AudioSpec). src_channels and dst_channels are the number of channels in the source and destination formats. Finally, src_rate and dst_rate are the frequency or samples-per-second of the source and destination formats. Once again, see SDL_AudioSpec.
Return Values
Returns -1 if the filter could not be built or 1 if it could.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcd.html b/lib/sdl/msvc/docs/html/sdlcd.html
new file mode 100644
index 0000000000000000000000000000000000000000..6f8a7cdf60d7b329b8d36d831ab6e0f075886664
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcd.html
@@ -0,0 +1,359 @@
+SDL_CD
An SDL_CD structure is returned by SDL_CDOpen. It represents an opened CDROM device and stores information on the layout of the tracks on the disc.
A frame is the base data unit of a CD. CD_FPS frames is equal to 1 second of music. SDL provides two macros for converting between time and frames: FRAMES_TO_MSF(f, M,S,F) and MSF_TO_FRAMES.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdclose.html b/lib/sdl/msvc/docs/html/sdlcdclose.html
new file mode 100644
index 0000000000000000000000000000000000000000..2a984a8b47495587de7ea2169ba4ef37ab353d65
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdclose.html
@@ -0,0 +1,217 @@
+SDL_CDClose
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdeject.html b/lib/sdl/msvc/docs/html/sdlcdeject.html
new file mode 100644
index 0000000000000000000000000000000000000000..03a3b780b5bae2da1dcb4d23731cfdcc5c7499c1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdeject.html
@@ -0,0 +1,226 @@
+SDL_CDEject
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdname.html b/lib/sdl/msvc/docs/html/sdlcdname.html
new file mode 100644
index 0000000000000000000000000000000000000000..55a18e26e3aef1d981721c53e3eb537119e029e6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdname.html
@@ -0,0 +1,239 @@
+SDL_CDName
SDL_CDName -- Returns a human-readable, system-dependent identifier for the CD-ROM.
Synopsis
#include "SDL.h"
const char *SDL_CDName(int drive);
Description
Returns a human-readable, system-dependent identifier for the CD-ROM. drive is the index of the drive. Drive indices start to 0 and end at SDL_CDNumDrives()-1.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdnumdrives.html b/lib/sdl/msvc/docs/html/sdlcdnumdrives.html
new file mode 100644
index 0000000000000000000000000000000000000000..9816a739bbcd598b0bac166092426119e1b15b93
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdnumdrives.html
@@ -0,0 +1,205 @@
+SDL_CDNumDrives
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdopen.html b/lib/sdl/msvc/docs/html/sdlcdopen.html
new file mode 100644
index 0000000000000000000000000000000000000000..09a6bd9f7840b095c78c769354ed2eae34ee56ca
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdopen.html
@@ -0,0 +1,275 @@
+SDL_CDOpen
Opens a CD-ROM drive for access. It returns a SDL_CD structure on success, or NULL if the drive was invalid or busy. This newly opened CD-ROM becomes the default CD used when other CD functions are passed a NULL CD-ROM handle.
Drives are numbered starting with 0.
+Drive 0 is the system default CD-ROM.
Examples
SDL_CD *cdrom;
+int cur_track;
+int min, sec, frame;
+SDL_Init(SDL_INIT_CDROM);
+atexit(SDL_Quit);
+
+/* Check for CD drives */
+if(!SDL_CDNumDrives()){
+ /* None found */
+ fprintf(stderr, "No CDROM devices available\n");
+ exit(-1);
+}
+
+/* Open the default drive */
+cdrom=SDL_CDOpen(0);
+
+/* Did if open? Check if cdrom is NULL */
+if(!cdrom){
+ fprintf(stderr, "Couldn't open drive: %s\n", SDL_GetError());
+ exit(-1);
+}
+
+/* Print Volume info */
+printf("Name: %s\n", SDL_CDName(0));
+printf("Tracks: %d\n", cdrom->numtracks);
+for(cur_track=0;cur_track < cdrom->numtracks; cur_track++){
+ FRAMES_TO_MSF(cdrom->track[cur_track].length, &min, &sec, &frame);
+ printf("\tTrack %d: Length %d:%d\n", cur_track, min, sec);
+}
+
+SDL_CDClose(cdrom);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdpause.html b/lib/sdl/msvc/docs/html/sdlcdpause.html
new file mode 100644
index 0000000000000000000000000000000000000000..4def8e362e8b8a347c862c88c600bfe44a5217cf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdpause.html
@@ -0,0 +1,233 @@
+SDL_CDPause
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdplay.html b/lib/sdl/msvc/docs/html/sdlcdplay.html
new file mode 100644
index 0000000000000000000000000000000000000000..dc6489cc8dc6f1d1249b31e6b0052b9c35104adc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdplay.html
@@ -0,0 +1,243 @@
+SDL_CDPlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdplaytracks.html b/lib/sdl/msvc/docs/html/sdlcdplaytracks.html
new file mode 100644
index 0000000000000000000000000000000000000000..75461819045b61394d9bb9992da82d9391aed512
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdplaytracks.html
@@ -0,0 +1,325 @@
+SDL_CDPlayTracks
int SDL_CDPlayTracks(SDL_CD *cdrom, int start_track, int start_frame, int ntracks, int nframes));
Description
SDL_CDPlayTracks plays the given CD starting at track
+start_track, for ntracks tracks.
start_frame is the frame offset, from the beginning of the start_track, at which to start. nframes is the frame offset, from the beginning of the last track (start_track+ntracks), at which to end playing.
SDL_CDPlayTracks should only be called after calling
+SDL_CDStatus
+to get track information about the CD.
Note: Data tracks are ignored.
Return Value
Returns 0, or -1
+if there was an error.
Examples
/* assuming cdrom is a previously opened device */
+/* Play the entire CD */
+if(CD_INDRIVE(SDL_CDStatus(cdrom)))
+ SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
+
+/* Play the first track */
+if(CD_INDRIVE(SDL_CDStatus(cdrom)))
+ SDL_CDPlayTracks(cdrom, 0, 0, 1, 0);
+
+/* Play first 15 seconds of the 2nd track */
+if(CD_INDRIVE(SDL_CDStatus(cdrom)))
+ SDL_CDPlayTracks(cdrom, 1, 0, 0, CD_FPS*15);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdresume.html b/lib/sdl/msvc/docs/html/sdlcdresume.html
new file mode 100644
index 0000000000000000000000000000000000000000..4a25ab69b6e3b957302de1df5388934a0f395236
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdresume.html
@@ -0,0 +1,233 @@
+SDL_CDResume
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdstatus.html b/lib/sdl/msvc/docs/html/sdlcdstatus.html
new file mode 100644
index 0000000000000000000000000000000000000000..3ebf9657e654c48be1a2d05647fa5ae979d65f78
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdstatus.html
@@ -0,0 +1,273 @@
+SDL_CDStatus
If the drive has a CD in it, the table of contents of the CD and current
+play position of the CD will be stored in the SDL_CD structure.
The macro CD_INDRIVE is provided for convenience,
+and given a status returns true if there's a disk in the drive.
Note: SDL_CDStatus also updates the SDL_CD structure passed to it.
Example
int playTrack(int track)
+{
+ int playing = 0;
+
+ if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) {
+ /* clamp to the actual number of tracks on the CD */
+ if (track >= cdrom->numtracks) {
+ track = cdrom->numtracks-1;
+ }
+
+ if ( SDL_CDPlayTracks(cdrom, track, 0, 1, 0) == 0 ) {
+ playing = 1;
+ }
+ }
+ return playing;
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdstop.html b/lib/sdl/msvc/docs/html/sdlcdstop.html
new file mode 100644
index 0000000000000000000000000000000000000000..68f8d81bed55af4f45a0b3553be0b11c149d2524
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdstop.html
@@ -0,0 +1,226 @@
+SDL_CDStop
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcdtrack.html b/lib/sdl/msvc/docs/html/sdlcdtrack.html
new file mode 100644
index 0000000000000000000000000000000000000000..bbb04bbd252383d72c2bf17db12072f30bb3eb13
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcdtrack.html
@@ -0,0 +1,313 @@
+SDL_CDtrack
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcloseaudio.html b/lib/sdl/msvc/docs/html/sdlcloseaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..599f058e4438c78f78649bed7a87f26f75433be5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcloseaudio.html
@@ -0,0 +1,205 @@
+SDL_CloseAudio
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcolor.html b/lib/sdl/msvc/docs/html/sdlcolor.html
new file mode 100644
index 0000000000000000000000000000000000000000..c8b7d44fc99b169641bc8ae072968ee85de54184
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcolor.html
@@ -0,0 +1,300 @@
+SDL_Color
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondbroadcast.html b/lib/sdl/msvc/docs/html/sdlcondbroadcast.html
new file mode 100644
index 0000000000000000000000000000000000000000..9b0fc83e0f1e42df2962a67e2afee56393eb25df
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondbroadcast.html
@@ -0,0 +1,224 @@
+SDL_CondBroadcast
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondsignal.html b/lib/sdl/msvc/docs/html/sdlcondsignal.html
new file mode 100644
index 0000000000000000000000000000000000000000..24e9175994ec461a93f7856c52371e00161608b5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondsignal.html
@@ -0,0 +1,224 @@
+SDL_CondSignal
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondwait.html b/lib/sdl/msvc/docs/html/sdlcondwait.html
new file mode 100644
index 0000000000000000000000000000000000000000..8f15452589e62e3910b8ab131e7ab88586ab3214
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondwait.html
@@ -0,0 +1,231 @@
+SDL_CondWait
Wait on the condition variable cond and unlock the provided mutex. The mutex must the locked before entering this function. Returns 0 when it is signalled, or -1 on an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcondwaittimeout.html b/lib/sdl/msvc/docs/html/sdlcondwaittimeout.html
new file mode 100644
index 0000000000000000000000000000000000000000..deed50bfe21293c06b67f2d8e98f4309e5f622f2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcondwaittimeout.html
@@ -0,0 +1,230 @@
+SDL_CondWaitTimeout
SDL_CondWaitTimeout -- Wait on a condition variable, with timeout
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms);
Description
Wait on the condition variable cond for, at most, ms milliseconds. mut is unlocked so it must be locked when the function is called. Returns SDL_MUTEX_TIMEDOUT if the condition is not signalled in the allotted time, 0 if it was signalled or -1 on an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlconvertaudio.html b/lib/sdl/msvc/docs/html/sdlconvertaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..52f122968a07cb93ecbfad0a8552649648dcf146
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlconvertaudio.html
@@ -0,0 +1,407 @@
+SDL_ConvertAudio
SDL_ConvertAudio -- Convert audio data to a desired audio format.
Synopsis
#include "SDL.h"
int SDL_ConvertAudio(SDL_AudioCVT *cvt);
Description
SDL_ConvertAudio takes one parameter, cvt, which was previously initilized. Initilizing a SDL_AudioCVT is a two step process. First of all, the structure must be passed to SDL_BuildAudioCVT along with source and destination format parameters. Secondly, the cvt->buf and cvt->len fields must be setup. cvt->buf should point to the audio data and cvt->len should be set to the length of the audio data in bytes. Remember, the length of the buffer pointed to by buf show be len*len_mult bytes in length.
Once the SDL_AudioCVTstructure is initilized then we can pass it to SDL_ConvertAudio, which will convert the audio data pointer to by cvt->buf. If SDL_ConvertAudio returned 0 then the conversion was completed successfully, otherwise -1 is returned.
If the conversion completed successfully then the converted audio data can be read from cvt->buf. The amount of valid, converted, audio data in the buffer is equal to cvt->len*cvt->len_ratio.
Examples
/* Converting some WAV data to hardware format */
+void my_audio_callback(void *userdata, Uint8 *stream, int len);
+
+SDL_AudioSpec *desired, *obtained;
+SDL_AudioSpec wav_spec;
+SDL_AudioCVT wav_cvt;
+Uint32 wav_len;
+Uint8 *wav_buf;
+int ret;
+
+/* Allocated audio specs */
+desired = malloc(sizeof(SDL_AudioSpec));
+obtained = malloc(sizeof(SDL_AudioSpec));
+
+/* Set desired format */
+desired->freq=22050;
+desired->format=AUDIO_S16LSB;
+desired->samples=8192;
+desired->callback=my_audio_callback;
+desired->userdata=NULL;
+
+/* Open the audio device */
+if ( SDL_OpenAudio(desired, obtained) < 0 ){
+ fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+ exit(-1);
+}
+
+free(desired);
+
+/* Load the test.wav */
+if( SDL_LoadWAV("test.wav", &wav_spec, &wav_buf, &wav_len) == NULL ){
+ fprintf(stderr, "Could not open test.wav: %s\n", SDL_GetError());
+ SDL_CloseAudio();
+ free(obtained);
+ exit(-1);
+}
+
+/* Build AudioCVT */
+ret = SDL_BuildAudioCVT(&wav_cvt,
+ wav_spec.format, wav_spec.channels, wav_spec.freq,
+ obtained->format, obtained->channels, obtained->freq);
+
+/* Check that the convert was built */
+if(ret==-1){
+ fprintf(stderr, "Couldn't build converter!\n");
+ SDL_CloseAudio();
+ free(obtained);
+ SDL_FreeWAV(wav_buf);
+}
+
+/* Setup for conversion */
+wav_cvt.buf = malloc(wav_len * wav_cvt.len_mult);
+wav_cvt.len = wav_len;
+memcpy(wav_cvt.buf, wav_buf, wav_len);
+
+/* We can delete to original WAV data now */
+SDL_FreeWAV(wav_buf);
+
+/* And now we're ready to convert */
+SDL_ConvertAudio(&wav_cvt);
+
+/* do whatever */
+.
+.
+.
+.
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlconvertsurface.html b/lib/sdl/msvc/docs/html/sdlconvertsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..cc21f7833ebd7373ae61766e1e47213ce1d9ebc7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlconvertsurface.html
@@ -0,0 +1,271 @@
+SDL_ConvertSurface
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatecond.html b/lib/sdl/msvc/docs/html/sdlcreatecond.html
new file mode 100644
index 0000000000000000000000000000000000000000..02fcdb2b3e57f43526a7c746682d85219c3f4574
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatecond.html
@@ -0,0 +1,240 @@
+SDL_CreateCond
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatecursor.html b/lib/sdl/msvc/docs/html/sdlcreatecursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..a444165ff096d1ceb44e08318e233cc05d343775
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatecursor.html
@@ -0,0 +1,398 @@
+SDL_CreateCursor
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatemutex.html b/lib/sdl/msvc/docs/html/sdlcreatemutex.html
new file mode 100644
index 0000000000000000000000000000000000000000..53ed48bb20ee6f1db76ec5b0d94f782e837638b5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatemutex.html
@@ -0,0 +1,249 @@
+SDL_CreateMutex
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatergbsurface.html b/lib/sdl/msvc/docs/html/sdlcreatergbsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..736ec8f96fff639e2bf0e8e9523c4133f2a0a389
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatergbsurface.html
@@ -0,0 +1,458 @@
+SDL_CreateRGBSurface
SDL_CreateRGBSurface -- Create an empty SDL_Surface
Synopsis
#include "SDL.h"
SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
Description
Allocate an empty surface (must be called after SDL_SetVideoMode)
If depth is 8 bits an empty palette is allocated for the surface, otherwise a 'packed-pixel' SDL_PixelFormat is created using the [RGBA]mask's provided (see SDL_PixelFormat). The flags specifies the type of surface that should be created, it is an OR'd combination of the following possible values.
SDL_SWSURFACE
SDL will create the surface in system memory. This improves the performance of pixel level access, however you may not be able to take advantage of some types of hardware blitting.
SDL_HWSURFACE
SDL will attempt to create the surface in video memory. This will allow SDL to take advantage of Video->Video blits (which are often accelerated).
SDL_SRCCOLORKEY
This flag turns on colourkeying for blits from this surface. If
+SDL_HWSURFACE is also specified and colourkeyed blits
+are hardware-accelerated, then SDL will attempt to place the surface in
+video memory.
+Use SDL_SetColorKey
+to set or clear this flag after surface creation.
SDL_SRCALPHA
This flag turns on alpha-blending for blits from this surface. If
+SDL_HWSURFACE is also specified and alpha-blending blits
+are hardware-accelerated, then the surface will be placed in video memory if
+possible.
+Use SDL_SetAlpha to
+set or clear this flag after surface creation.
Note: If an alpha-channel is specified (that is, if Amask is
+nonzero), then the SDL_SRCALPHA flag is automatically
+set. You may remove this flag by calling
+SDL_SetAlpha
+after surface creation.
Return Value
Returns the created surface, or NULL upon error.
Example
/* Create a 32-bit surface with the bytes of each pixel in R,G,B,A order,
+ as expected by OpenGL for textures */
+ SDL_Surface *surface;
+ Uint32 rmask, gmask, bmask, amask;
+
+ /* SDL interprets each pixel as a 32-bit number, so our masks must depend
+ on the endianness (byte order) of the machine */
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+ rmask = 0xff000000;
+ gmask = 0x00ff0000;
+ bmask = 0x0000ff00;
+ amask = 0x000000ff;
+#else
+ rmask = 0x000000ff;
+ gmask = 0x0000ff00;
+ bmask = 0x00ff0000;
+ amask = 0xff000000;
+#endif
+
+ surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32,
+ rmask, gmask, bmask, amask);
+ if(surface == NULL) {
+ fprintf(stderr, "CreateRGBSurface failed: %s\n", SDL_GetError());
+ exit(1);
+ }
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatergbsurfacefrom.html b/lib/sdl/msvc/docs/html/sdlcreatergbsurfacefrom.html
new file mode 100644
index 0000000000000000000000000000000000000000..6acfdccae8b4e16f5fa05aecd1dd6af70cb7bcb9
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatergbsurfacefrom.html
@@ -0,0 +1,256 @@
+SDL_CreateRGBSurfaceFrom
SDL_CreateRGBSurfaceFrom -- Create an SDL_Surface from pixel data
Synopsis
#include "SDL.h"
SDL_Surface *SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
Description
Creates an SDL_Surface from the provided pixel data.
The data stored in pixels is assumed to be of the depth specified in the parameter list. The pixel data is not copied into the SDL_Surface structure so it should not be freed until the surface has been freed with a called to SDL_FreeSurface. pitch is the length of each scanline in bytes.
See SDL_CreateRGBSurface for a more detailed description of the other parameters.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatesemaphore.html b/lib/sdl/msvc/docs/html/sdlcreatesemaphore.html
new file mode 100644
index 0000000000000000000000000000000000000000..43dcbf5bff23dc8000afdcabb19fb0fa6bb2674e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatesemaphore.html
@@ -0,0 +1,303 @@
+SDL_CreateSemaphore
SDL_CreateSemaphore() creates a new semaphore and
+initializes it with the value initial_value.
+Each locking operation on the semaphore by
+SDL_SemWait,
+SDL_SemTryWait or
+SDL_SemWaitTimeout
+will atomically decrement the semaphore value. The locking operation will be blocked
+if the semaphore value is not positive (greater than zero). Each unlock operation by
+SDL_SemPost
+will atomically increment the semaphore value.
Return Value
Returns a pointer to an initialized semaphore or
+NULL if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreatethread.html b/lib/sdl/msvc/docs/html/sdlcreatethread.html
new file mode 100644
index 0000000000000000000000000000000000000000..ca3c2d9201caafb525c6bb3c27e06312c57cf199
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreatethread.html
@@ -0,0 +1,223 @@
+SDL_CreateThread
SDL_CreateThread creates a new thread of execution
+that shares all of its parent's global memory, signal handlers,
+file descriptors, etc, and runs the function fn
+passed the void pointer data
+The thread quits when this function returns.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlcreateyuvoverlay.html b/lib/sdl/msvc/docs/html/sdlcreateyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..c24ef6ee2e0a0b4f57744454030602b6aac73bdb
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlcreateyuvoverlay.html
@@ -0,0 +1,256 @@
+SDL_CreateYUVOverlay
SDL_CreateYUVOverlay -- Create a YUV video overlay
Synopsis
#include "SDL.h"
SDL_Overlay *SDL_CreateYUVOverlay(int width, int height, Uint32 format, SDL_Surface *display);
Description
SDL_CreateYUVOverlay creates a YUV overlay of the specified width, height and format (see SDL_Overlay for a list of available formats), for the provided display. A SDL_Overlay structure is returned.
The term 'overlay' is a misnomer since, unless the overlay is created in hardware, the contents for the display surface underneath the area where the overlay is shown will be overwritten when the overlay is displayed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldelay.html b/lib/sdl/msvc/docs/html/sdldelay.html
new file mode 100644
index 0000000000000000000000000000000000000000..a5417fa66f369db4d37a59f9b6c0ac3533dd2d07
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldelay.html
@@ -0,0 +1,231 @@
+SDL_Delay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldestroycond.html b/lib/sdl/msvc/docs/html/sdldestroycond.html
new file mode 100644
index 0000000000000000000000000000000000000000..ac0804286a91955601c628facea50a0cda21784f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldestroycond.html
@@ -0,0 +1,206 @@
+SDL_DestroyCond
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldestroymutex.html b/lib/sdl/msvc/docs/html/sdldestroymutex.html
new file mode 100644
index 0000000000000000000000000000000000000000..949bfc5d5407e3e45e9ea296a8087ad05bee22e1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldestroymutex.html
@@ -0,0 +1,209 @@
+SDL_DestroyMutex
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldestroysemaphore.html b/lib/sdl/msvc/docs/html/sdldestroysemaphore.html
new file mode 100644
index 0000000000000000000000000000000000000000..d32bdfaf578007f6e6e91ab512a812a60a8a6df8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldestroysemaphore.html
@@ -0,0 +1,278 @@
+SDL_DestroySemaphore
SDL_DestroySemaphore -- Destroys a semaphore that was created by SDL_CreateSemaphore.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
void SDL_DestroySemaphore(SDL_sem *sem);
Description
SDL_DestroySemaphore destroys the semaphore pointed to
+by sem that was created by
+SDL_CreateSemaphore.
+It is not safe to destroy a semaphore if there are threads currently blocked
+waiting on it.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldisplayformat.html b/lib/sdl/msvc/docs/html/sdldisplayformat.html
new file mode 100644
index 0000000000000000000000000000000000000000..c91adfe50aa890608eeb3fc62781c4a72ede7d81
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldisplayformat.html
@@ -0,0 +1,262 @@
+SDL_DisplayFormat
This function takes a surface and copies it to a new surface of the
+pixel format and colors of the video framebuffer, suitable for fast
+blitting onto the display surface. It calls
+SDL_ConvertSurface
If you want to take advantage of hardware colorkey or alpha blit
+acceleration, you should set the colorkey and alpha value before
+calling this function.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldisplayformatalpha.html b/lib/sdl/msvc/docs/html/sdldisplayformatalpha.html
new file mode 100644
index 0000000000000000000000000000000000000000..6e88604d0210f87f5241ae1a1798883fb0267db4
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldisplayformatalpha.html
@@ -0,0 +1,250 @@
+SDL_DisplayFormatAlpha
This function takes a surface and copies it to a new surface of the
+pixel format and colors of the video framebuffer plus an alpha channel,
+suitable for fast blitting onto the display surface. It calls
+SDL_ConvertSurface
If you want to take advantage of hardware colorkey or alpha blit
+acceleration, you should set the colorkey and alpha value before
+calling this function.
This function can be used to convert a colourkey to an alpha channel,
+if the SDL_SRCCOLORKEY flag is set on the surface.
+The generated surface will then be transparent (alpha=0) where the
+pixels match the colourkey, and opaque (alpha=255) elsewhere.
Return Value
If the conversion fails or runs out of memory, it returns
+NULL
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdldisplayyuvoverlay.html b/lib/sdl/msvc/docs/html/sdldisplayyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..456c9985dfb471f888fe8ca8c4439f1a8946e144
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdldisplayyuvoverlay.html
@@ -0,0 +1,246 @@
+SDL_DisplayYUVOverlay
SDL_DisplayYUVOverlay -- Blit the overlay to the display
Synopsis
#include "SDL.h"
int SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
Description
Blit the overlay to the surface specified when it was created. The SDL_Rect structure, dstrect, specifies the position and size of the destination. If the dstrect is a larger or smaller than the overlay then the overlay will be scaled, this is optimized for 2x scaling.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlenablekeyrepeat.html b/lib/sdl/msvc/docs/html/sdlenablekeyrepeat.html
new file mode 100644
index 0000000000000000000000000000000000000000..878feb14f33155202131c6eb1cc13354be8b3f77
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlenablekeyrepeat.html
@@ -0,0 +1,238 @@
+SDL_EnableKeyRepeat
Enables or disables the keyboard repeat rate. delay specifies how long the key must be pressed before it begins repeating, it then repeats at the speed specified by interval. Both delay and interval are expressed in milliseconds.
Setting delay to 0 disables key repeating completely. Good default values are SDL_DEFAULT_REPEAT_DELAY and SDL_DEFAULT_REPEAT_INTERVAL.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlenableunicode.html b/lib/sdl/msvc/docs/html/sdlenableunicode.html
new file mode 100644
index 0000000000000000000000000000000000000000..855debbc996035b562e1583c7c68c6b155b086f1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlenableunicode.html
@@ -0,0 +1,252 @@
+SDL_EnableUNICODE
To obtain the character codes corresponding to received keyboard events,
+Unicode translation must first be turned on using this function. The
+translation incurs a slight overhead for each keyboard event and is therefore
+disabled by default. For each subsequently received key down event, the
+unicode member of the
+SDL_keysym structure
+will then contain the corresponding character code, or zero for keysyms that do
+not correspond to any character code.
A value of 1 for enable enables Unicode translation;
+0 disables it, and -1 leaves it unchanged (useful for querying the current
+translation mode).
Note that only key press events will be translated, not release events.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlenvvars.html b/lib/sdl/msvc/docs/html/sdlenvvars.html
new file mode 100644
index 0000000000000000000000000000000000000000..8999ed1f1f999569b57ae6cc52cdf08d54803e37
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlenvvars.html
@@ -0,0 +1,1227 @@
+SDL_envvars
Several environment variables are available to modify the
+behaviour of SDL. Using these variables isn't recommened and the names
+and presence of these variables aren't guaranteed from one release to
+the next. However, they can be very useful for debugging
+purposes.
Video
SDL_FBACCEL
If set to 0, disable hardware acceleration in the linux fbcon driver.
SDL_FBDEV
Frame buffer device to use in the linux fbcon driver, instead of /dev/fb0
SDL_FULLSCREEN_UPDATE
In the ps2gs driver, sets the SDL_ASYNCBLIT flag on the
+display surface.
SDL_VIDEODRIVER
Selectes the video driver for SDL to use. Possible values, in the
+order they are tried if this variable is not set:
x11
dga
(the XFree86 DGA2)
nanox
(Linux)
fbcon
(Linux)
directfb
(Linux)
ps2gs
(Playstation 2)
ggi
vgl
(BSD)
svgalib
(Linux)
aalib
directx
(Win32)
windib
(Win32)
bwindow
(BeOS)
toolbox
(MacOS Classic)
DSp
(MacOS Classic)
Quartz
(Mac OS X)
CGX
(Amiga)
photon
(QNX)
dummy
SDL_VIDEO_CENTERED
If set, tries to center the SDL window when running in X11 windowed
+mode, or using the CyberGrafix driver.
SDL_VIDEO_GL_DRIVER
The openGL driver (shared library) to use for X11. Default is libGL.so.1
SDL_VIDEO_X11_DGAMOUSE
With XFree86, enables use of DGA mouse if set.
SDL_VIDEO_X11_MOUSEACCEL
For X11, sets the mouse acceleration. The value should be a string
+on the form:
"n/d/t"
where n and d are the
+acceleration numerator/denumerators (so mouse movement is accelerated by
+n/d), and
+t is the threshold above which acceleration applies
+(counted as number of pixels the mouse moves at once).
SDL_VIDEO_X11_NODIRECTCOLOR
If set, don't attempt to use DirectColor visuals even if they are
+present. (SDL will use them otherwise for gamma correction).
+This is needed with older X servers when using the XVideo extension.
SDL_VIDEO_X11_VISUALID
ID of an X11 visual to use, overriding SDL's default visual selection
+algorithm. It can be in decimal or in hex (prefixed by 0x).
SDL_VIDEO_YUV_DIRECT
If set, display YUV overlay directly on the video surface if possible,
+instead of on the surface passed to
+SDL_CreateYUVOverlay.
SDL_VIDEO_YUV_HWACCEL
If not set or set to a nonzero value, SDL will attempt to use
+hardware YUV acceleration for video playback.
SDL_WINDOWID
For X11 or Win32, contains the ID number of the window to be used by
+SDL instead of creating its own window. Either in decimal or
+in hex (prefixed by 0x).
Events/Input
SDL_MOUSE_RELATIVE
If set to 0, do not use mouse relative mode in X11. The default is
+to use it if the mouse is hidden and input is grabbed.
SDL_MOUSEDEV
The mouse device to use for the linux fbcon driver. If not set,
+SDL first tries to use GPM in repeater mode, then various other
+devices (/dev/pcaux, /dev/adbmouse, /dev/mouse etc).
SDL_MOUSEDEV_IMPS2
If set, SDL will not try to auto-detect the IMPS/2 protocol of
+a PS/2 mouse but use it right away. For the fbcon and ps2gs drivers.
SDL_MOUSEDRV
For the linux fbcon driver: if set to ELO, use the ELO touchscreen
+controller as a pointer device
SDL_NO_RAWKBD
For the libvga driver: If set, do not attempt to put the keyboard in raw mode.
SDL_NOMOUSE
If set, the linux fbcon driver will not use a mouse at all.
SDL_NO_LOCK_KEYS
Disable CAPS-LOCK and NUM-LOCK suppression of down+up key events,
+suitable for games where the player needs these keys to do more than just toggle.
+A value of 1 will effect both CAPS-LOCK and NUM-LOCK.
+A value of 2 will effect only CAPS-LOCK.
+A value of 3 will effect only NUM-LOCK.
+All other values have no effect.
+
Audio
AUDIODEV
The audio device to use, if SDL_PATH_DSP isn't set.
SDL_AUDIODRIVER
Selects the audio driver for SDL to use. Possible values, in the
+order they are tried if this variable is not set:
openbsd
(OpenBSD)
dsp
(OSS /dev/dsp: Linux, Solaris, BSD etc)
alsa
(Linux)
pulse
(PulseAudio daemon)
audio
(Unix style /dev/audio: SunOS, Solaris etc)
AL
(Irix)
artsc
(ARTS audio daemon)
esd
(esound audio daemon)
nas
(NAS audio daemon)
dma
(OSS /dev/dsp, using DMA)
dsound
(Win32 DirectX)
waveout
(Win32 WaveOut)
baudio
(BeOS)
sndmgr
(MacOS SoundManager)
paud
(AIX)
AHI
(Amiga)
disk
(all; output to file)
SDL_DISKAUDIOFILE
The name of the output file for the "disk" audio driver. If not
+set, the name sdlaudio.raw is used.
SDL_DISKAUDIODELAY
For the "disk" audio driver, how long to wait (in ms) before writing
+a full sound buffer. The default is 150 ms.
SDL_DSP_NOSELECT
For some audio drivers (alsa, paud, dma and dsp), don't use select()
+but a timed method instead. May cure some audio problems, or cause
+others.
SDL_PATH_DSP
The audio device to use. If not set, SDL tries AUDIODEV and then
+a platform-dependent default value (/dev/audio on Solaris,
+/dev/dsp on Linux etc).
CD-ROM
SDL_CDROM
A colon-separated list of CD-ROM devices to use, in addition to
+the standard devices (typically /dev/cdrom, platform-dependent).
Debugging
SDL_DEBUG
If set, causes every call to SDL_SetError (that
+is, every time SDL signals an error) to also print an error message on
+stderr.
Joystick
SDL_JOYSTICK_DEVICE
Joystick device to use in the linux joystick driver, in addition
+to the usual: /dev/js*, /dev/input/event*, /dev/input/js*
SDL_LINUX_JOYSTICK
Special joystick configuration string for linux. The format is
"namenumaxesnumhatsnumballs"
where name is the name string of the joystick
+(possibly in single quotes), and the rest are the number of axes, hats
+and balls respectively.
The SDL_Event union is the core to all event handling is SDL, its probably the most important structure after SDL_Surface. SDL_Event is a union of all event structures used in SDL, using it is a simple matter of knowing which union member relates to which event type.
Reading events from the event queue is done with either SDL_PollEvent or SDL_PeepEvents. We'll use SDL_PollEvent and step through an example.
First off, we create an empty SDL_Event structure.
+
SDL_Event test_event;
+SDL_PollEvent removes the next event from the event queue, if there are no events on the queue it returns 0 otherwise it returns 1. We use a while loop to process each event in turn.
+
while(SDL_PollEvent(&test_event)) {
+The SDL_PollEvent function take a pointer to an SDL_Event structure that is to be filled with event information. We know that if SDL_PollEvent removes an event from the queue then the event information will be placed in our test_event structure, but we also know that the type of event will be placed in the type member of test_event. So to handle each event type seperately we use a switch statement.
+
switch(test_event.type) {
+We need to know what kind of events we're looking for and the event type's of those events. So lets assume we want to detect where the user is moving the mouse pointer within our application. We look through our event types and notice that SDL_MOUSEMOTION is, more than likely, the event we're looking for. A little more research tells use that SDL_MOUSEMOTION events are handled within the SDL_MouseMotionEvent structure which is the motion member of SDL_Event. We can check for the SDL_MOUSEMOTION event type within our switch statement like so:
+
case SDL_MOUSEMOTION:
+All we need do now is read the information out of the motion member of test_event.
+
printf("We got a motion event.\n");
+ printf("Current mouse position is: (%d, %d)\n", test_event.motion.x, test_event.motion.y);
+ break;
+ default:
+ printf("Unhandled Event!\n");
+ break;
+ }
+}
+printf("Event queue empty.\n");
It is also possible to push events onto the event queue and so use it as a two-way communication path. Both SDL_PushEvent and SDL_PeepEvents allow you to place events onto the event queue. This is usually used to place a SDL_USEREVENT on the event queue, however you could use it to post fake input events if you wished. Creating your own events is a simple matter of choosing the event type you want, setting the type member and filling the appropriate member structure with information.
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlexposeevent.html b/lib/sdl/msvc/docs/html/sdlexposeevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..82c2a3e7e29ad8ca87a910550bcced5936e9f3c1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlexposeevent.html
@@ -0,0 +1,252 @@
+SDL_ExposeEvent
SDL_ExposeEvent is a member of the SDL_Event union and is used whan an event of type SDL_VIDEOEXPOSE is reported.
A VIDEOEXPOSE event is triggered when the screen has been modified
+outside of the application, usually by the window manager and needs to
+be redrawn.
SDL_FillRect -- This function performs a fast fill of the given rectangle with some color
Synopsis
#include "SDL.h"
int SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
Description
This function performs a fast fill of the given rectangle with
+color. If dstrect
+is NULL, the whole surface will be filled with
+color.
The color should be a pixel of the format used by the surface, and
+can be generated by the
+SDL_MapRGB or SDL_MapRGBA
+functions. If the color value contains an alpha value then the
+destination is simply "filled" with that alpha information, no blending
+takes place.
If there is a clip rectangle set on the destination (set via
+SDL_SetClipRect) then this
+function will clip based on the intersection of the clip rectangle and
+the dstrect rectangle and the dstrect rectangle
+will be modified to represent the area actually filled.
Return Value
This function returns 0 on success, or
+-1 on error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlflip.html b/lib/sdl/msvc/docs/html/sdlflip.html
new file mode 100644
index 0000000000000000000000000000000000000000..b480f99aa8c9b7f87018d0bfc8cbd81ef2e5c9c3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlflip.html
@@ -0,0 +1,259 @@
+SDL_Flip
On hardware that supports double-buffering, this function sets up a flip
+and returns. The hardware will wait for vertical retrace, and then swap
+video buffers before the next video surface blit or lock will return.
+On hardware that doesn't support double-buffering, this is equivalent
+to calling SDL_UpdateRect(screen, 0, 0, 0, 0)
The SDL_DOUBLEBUF flag must have been passed to
+SDL_SetVideoMode,
+ when
+setting the video mode for this function to perform hardware flipping.
Return Value
This function returns 0 if successful, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreecursor.html b/lib/sdl/msvc/docs/html/sdlfreecursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..01a4f7c257219c8beef56bbbed0a427e358da033
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreecursor.html
@@ -0,0 +1,209 @@
+SDL_FreeCursor
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreesurface.html b/lib/sdl/msvc/docs/html/sdlfreesurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..84b60481095ec700edb8eca64ed7da44768fea46
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreesurface.html
@@ -0,0 +1,219 @@
+SDL_FreeSurface
Frees the resources used by a previously created SDL_Surface. If the surface was created using
+SDL_CreateRGBSurfaceFrom then the pixel data is not freed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreewav.html b/lib/sdl/msvc/docs/html/sdlfreewav.html
new file mode 100644
index 0000000000000000000000000000000000000000..24242c4b0fe486d837c63b0e5615d724f6f9085e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreewav.html
@@ -0,0 +1,222 @@
+SDL_FreeWAV
After a WAVE file has been opened with SDL_LoadWAV its data can eventually be freed with SDL_FreeWAV. audio_buf is a pointer to the buffer created by SDL_LoadWAV.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlfreeyuvoverlay.html b/lib/sdl/msvc/docs/html/sdlfreeyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..e82340d9e2e0f5fb34a60f26a35f2df063bb6cb7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlfreeyuvoverlay.html
@@ -0,0 +1,233 @@
+SDL_FreeYUVOverlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetappstate.html b/lib/sdl/msvc/docs/html/sdlgetappstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..d09e2e0f08b406eefea2f56c41eab616d147ce87
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetappstate.html
@@ -0,0 +1,263 @@
+SDL_GetAppState
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetaudiostatus.html b/lib/sdl/msvc/docs/html/sdlgetaudiostatus.html
new file mode 100644
index 0000000000000000000000000000000000000000..3fc3a09119cd3e6813975f82b76356f8f023b0cf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetaudiostatus.html
@@ -0,0 +1,221 @@
+SDL_GetAudioStatus
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetcliprect.html b/lib/sdl/msvc/docs/html/sdlgetcliprect.html
new file mode 100644
index 0000000000000000000000000000000000000000..f00ac77f8f6a2d4fe15f5957d933f37a9eab6901
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetcliprect.html
@@ -0,0 +1,229 @@
+SDL_GetClipRect
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetcursor.html b/lib/sdl/msvc/docs/html/sdlgetcursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..72ecbc7c0975aa4fa7eb9c2bee43fe3d91db5855
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetcursor.html
@@ -0,0 +1,219 @@
+SDL_GetCursor
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgeterror.html b/lib/sdl/msvc/docs/html/sdlgeterror.html
new file mode 100644
index 0000000000000000000000000000000000000000..cdf57924a9f2f08e98b368f2a178d82e13639f39
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgeterror.html
@@ -0,0 +1,205 @@
+SDL_GetError
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgeteventfilter.html b/lib/sdl/msvc/docs/html/sdlgeteventfilter.html
new file mode 100644
index 0000000000000000000000000000000000000000..d254d34a52d8405504c182b340abbc21098eded4
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgeteventfilter.html
@@ -0,0 +1,235 @@
+SDL_GetEventFilter
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetgammaramp.html b/lib/sdl/msvc/docs/html/sdlgetgammaramp.html
new file mode 100644
index 0000000000000000000000000000000000000000..bfcc03c4d3334cc3ca370205fa36946f54c3f395
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetgammaramp.html
@@ -0,0 +1,219 @@
+SDL_GetGammaRamp
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetkeyname.html b/lib/sdl/msvc/docs/html/sdlgetkeyname.html
new file mode 100644
index 0000000000000000000000000000000000000000..6c51c9497a0ad272a5ff634e8e4911729cc7c17f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetkeyname.html
@@ -0,0 +1,216 @@
+SDL_GetKeyName
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetkeystate.html b/lib/sdl/msvc/docs/html/sdlgetkeystate.html
new file mode 100644
index 0000000000000000000000000000000000000000..1c16f2e50c295fa498b70669e44d92148b4ec067
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetkeystate.html
@@ -0,0 +1,253 @@
+SDL_GetKeyState
SDL_GetKeyState -- Get a snapshot of the current keyboard state
Synopsis
#include "SDL.h"
Uint8 *SDL_GetKeyState(int *numkeys);
Description
Gets a snapshot of the current keyboard state. The current state is return as a pointer to an array, the size of this array is stored in numkeys. The array is indexed by the SDLK_* symbols. A value of 1 means the key is pressed and a value of 0 means its not. The pointer returned is a pointer to an internal SDL array and should not be freed by the caller.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetmodstate.html b/lib/sdl/msvc/docs/html/sdlgetmodstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..64d2f35621f9870a93b2d7edc12b3a1d63e65c33
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetmodstate.html
@@ -0,0 +1,257 @@
+SDL_GetModState
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetmousestate.html b/lib/sdl/msvc/docs/html/sdlgetmousestate.html
new file mode 100644
index 0000000000000000000000000000000000000000..d96a55b8d1b74fd56a03484f8ec9223bb532352a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetmousestate.html
@@ -0,0 +1,253 @@
+SDL_GetMouseState
SDL_GetMouseState -- Retrieve the current state of the mouse
Synopsis
#include "SDL.h"
Uint8 SDL_GetMouseState(int *x, int *y);
Description
The current button state is returned as a button bitmask, which can
+be tested using the SDL_BUTTON(X) macros, and x and y are set to the
+current mouse cursor position. You can pass NULL for either x or y.
Example
SDL_PumpEvents();
+if(SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(1))
+ printf("Mouse Button 1(left) is pressed.\n");
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetrelativemousestate.html b/lib/sdl/msvc/docs/html/sdlgetrelativemousestate.html
new file mode 100644
index 0000000000000000000000000000000000000000..52a51066b588a10846fdadc0b2f15e83140a336d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetrelativemousestate.html
@@ -0,0 +1,235 @@
+SDL_GetRelativeMouseState
SDL_GetRelativeMouseState -- Retrieve the current state of the mouse
Synopsis
#include "SDL.h"
Uint8 SDL_GetRelativeMouseState(int *x, int *y);
Description
The current button state is returned as a button bitmask, which can
+be tested using the SDL_BUTTON(X) macros, and x and y are set to the change in the mouse position since the last call to SDL_GetRelativeMouseState or since event initialization. You can pass NULL for either x or y.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetrgb.html b/lib/sdl/msvc/docs/html/sdlgetrgb.html
new file mode 100644
index 0000000000000000000000000000000000000000..47774dc2ed88c805402940bb11ae5ccdf7753b74
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetrgb.html
@@ -0,0 +1,231 @@
+SDL_GetRGB
Get RGB component values from a pixel stored in the specified pixel format.
This function uses the entire 8-bit [0..255] range when converting color
+components from pixel formats with less than 8-bits per RGB component
+(e.g., a completely white pixel in 16-bit RGB565 format would return
+[0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetrgba.html b/lib/sdl/msvc/docs/html/sdlgetrgba.html
new file mode 100644
index 0000000000000000000000000000000000000000..a9e1093ad5a37d7e64d756b085b0270f518d0e56
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetrgba.html
@@ -0,0 +1,222 @@
+SDL_GetRGBA
Get RGBA component values from a pixel stored in the specified pixel format.
This function uses the entire 8-bit [0..255] range when converting color
+components from pixel formats with less than 8-bits per RGB component
+(e.g., a completely white pixel in 16-bit RGB565 format would return
+[0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).
If the surface has no alpha component, the alpha will be returned as 0xff
+(100% opaque).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetthreadid.html b/lib/sdl/msvc/docs/html/sdlgetthreadid.html
new file mode 100644
index 0000000000000000000000000000000000000000..4bc59cb69c16baf753c480af054f69449c1c5a37
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetthreadid.html
@@ -0,0 +1,209 @@
+SDL_GetThreadID
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetticks.html b/lib/sdl/msvc/docs/html/sdlgetticks.html
new file mode 100644
index 0000000000000000000000000000000000000000..0911aae1a5557d35b1d019c6652c5683dc928e03
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetticks.html
@@ -0,0 +1,206 @@
+SDL_GetTicks
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetvideoinfo.html b/lib/sdl/msvc/docs/html/sdlgetvideoinfo.html
new file mode 100644
index 0000000000000000000000000000000000000000..25c4b458aa0101158bc950edcfbb60ea0bd81131
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetvideoinfo.html
@@ -0,0 +1,226 @@
+SDL_GetVideoInfo
SDL_GetVideoInfo -- returns a pointer to information about the video hardware
Synopsis
#include "SDL.h"
SDL_VideoInfo *SDL_GetVideoInfo(void);
Description
This function returns a read-only pointer to information about the video
+hardware. If this is called before SDL_SetVideoMode, the
+vfmt member of the returned structure will contain the
+pixel format of the "best" video mode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlgetvideosurface.html b/lib/sdl/msvc/docs/html/sdlgetvideosurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..905b1f6ac4b9eff8bb0e9a77a7aa3aceaeec7213
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlgetvideosurface.html
@@ -0,0 +1,208 @@
+SDL_GetVideoSurface
SDL_GetVideoSurface -- returns a pointer to the current display surface
Synopsis
#include "SDL.h"
SDL_Surface *SDL_GetVideoSurface(void);
Description
This function returns a pointer to the current display surface.
+If SDL is doing format conversion on the display surface, this
+function returns the publicly visible surface, not the real video
+surface.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglattr.html b/lib/sdl/msvc/docs/html/sdlglattr.html
new file mode 100644
index 0000000000000000000000000000000000000000..0ae01272a4570c2170782e64ca74c2f68f4ce6ea
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglattr.html
@@ -0,0 +1,379 @@
+SDL_GLattr
Size of the accumulation buffer red component, in bits
SDL_GL_ACCUM_GREEN_SIZE
Size of the accumulation buffer green component, in bits
SDL_GL_ACCUM_BLUE_SIZE
Size of the accumulation buffer blue component, in bits
SDL_GL_ACCUM_ALPHA_SIZE
Size of the accumulation buffer alpha component, in bits
Description
While you can set most OpenGL attributes normally, the attributes list above must be known before SDL sets the video mode. These attributes a set and read with SDL_GL_SetAttribute and SDL_GL_GetAttribute.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglgetattribute.html b/lib/sdl/msvc/docs/html/sdlglgetattribute.html
new file mode 100644
index 0000000000000000000000000000000000000000..26c8913bd24e69678470a11891fb35728e417b10
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglgetattribute.html
@@ -0,0 +1,247 @@
+SDL_GL_GetAttribute
SDL_GL_GetAttribute -- Get the value of a special SDL/OpenGL attribute
Synopsis
#include "SDL.h"
int SDL_GL_GetAttribute(SDLGLattr attr, int *value);
Description
Places the value of the SDL/OpenGL attributeattr into value. This is useful after a call to SDL_SetVideoMode to check whether your attributes have been set as you expected.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglgetprocaddress.html b/lib/sdl/msvc/docs/html/sdlglgetprocaddress.html
new file mode 100644
index 0000000000000000000000000000000000000000..a6cf6e4c1198c3e54391b337c6eb092d5d879780
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglgetprocaddress.html
@@ -0,0 +1,262 @@
+SDL_GL_GetProcAddress
SDL_GL_GetProcAddress -- Get the address of a GL function
Synopsis
#include "SDL.h"
void *SDL_GL_GetProcAddress(const char* proc);
Description
Returns the address of the GL function proc, or NULL if the function is not found. If the GL library is loaded at runtime, with SDL_GL_LoadLibrary, then all GL functions must be retrieved this way. Usually this is used to retrieve function pointers to OpenGL extensions.
Example
typedef void (*GL_ActiveTextureARB_Func)(unsigned int);
+GL_ActiveTextureARB_Func glActiveTextureARB_ptr = 0;
+int has_multitexture=1;
+.
+.
+.
+/* Get function pointer */
+glActiveTextureARB_ptr=(GL_ActiveTextureARB_Func) SDL_GL_GetProcAddress("glActiveTextureARB");
+
+/* Check for a valid function ptr */
+if(!glActiveTextureARB_ptr){
+ fprintf(stderr, "Multitexture Extensions not present.\n");
+ has_multitexture=0;
+}
+.
+.
+.
+.
+if(has_multitexture){
+ glActiveTextureARB_ptr(GL_TEXTURE0_ARB);
+ .
+ .
+}
+else{
+ .
+ .
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglloadlibrary.html b/lib/sdl/msvc/docs/html/sdlglloadlibrary.html
new file mode 100644
index 0000000000000000000000000000000000000000..d3c4c6d79dd3099b70d8c4ec2a8c63fa1b705fb2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglloadlibrary.html
@@ -0,0 +1,231 @@
+SDL_GL_LoadLibrary
If you wish, you may load the OpenGL library at runtime, this must be done before SDL_SetVideoMode is called. The path of the GL library is passed to SDL_GL_LoadLibrary and it returns 0 on success, or -1 on an error. You must then use SDL_GL_GetProcAddress to retrieve function pointers to GL functions.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglsetattribute.html b/lib/sdl/msvc/docs/html/sdlglsetattribute.html
new file mode 100644
index 0000000000000000000000000000000000000000..ffb1204b0e005fe6cd59cd872449c62fda5c379d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglsetattribute.html
@@ -0,0 +1,286 @@
+SDL_GL_SetAttribute
SDL_GL_SetAttribute -- Set a special SDL/OpenGL attribute
Synopsis
#include "SDL.h"
int SDL_GL_SetAttribute(SDL_GLattr attr, int value);
Description
Sets the OpenGL attributeattr to value. The attributes you set don't take effect until after a call to SDL_SetVideoMode. You should use SDL_GL_GetAttribute to check the values after a SDL_SetVideoMode call.
Note: The SDL_DOUBLEBUF flag is not required to enable double buffering when setting an OpenGL video mode. Double buffering is enabled or disabled using the SDL_GL_DOUBLEBUFFER attribute.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlglswapbuffers.html b/lib/sdl/msvc/docs/html/sdlglswapbuffers.html
new file mode 100644
index 0000000000000000000000000000000000000000..fa383414d4d07705fc7d2f1726d2e51a58d93c9b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlglswapbuffers.html
@@ -0,0 +1,212 @@
+SDL_GL_SwapBuffers
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlinit.html b/lib/sdl/msvc/docs/html/sdlinit.html
new file mode 100644
index 0000000000000000000000000000000000000000..11f27b81d1652fd907d3e07d3a44c9c94fb4c887
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlinit.html
@@ -0,0 +1,368 @@
+SDL_Init
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlinitsubsystem.html b/lib/sdl/msvc/docs/html/sdlinitsubsystem.html
new file mode 100644
index 0000000000000000000000000000000000000000..917fd1068e0f59bab51264b9113c45f3b106c7ab
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlinitsubsystem.html
@@ -0,0 +1,283 @@
+SDL_InitSubSystem
After SDL has been initialized with SDL_Init you may initialize uninitialized subsystems with SDL_InitSubSystem. The flags parameter is the same as that used in SDL_Init.
Examples
/* Seperating Joystick and Video initialization. */
+SDL_Init(SDL_INIT_VIDEO);
+.
+.
+SDL_SetVideoMode(640, 480, 16, SDL_DOUBLEBUF|SDL_FULLSCREEN);
+.
+/* Do Some Video stuff */
+.
+.
+/* Initialize the joystick subsystem */
+SDL_InitSubSystem(SDL_INIT_JOYSTICK);
+
+/* Do some stuff with video and joystick */
+.
+.
+.
+/* Shut them both down */
+SDL_Quit();
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoyaxisevent.html b/lib/sdl/msvc/docs/html/sdljoyaxisevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..9f0166959f0ed40852089614e1dd58e3a0abf9d3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoyaxisevent.html
@@ -0,0 +1,330 @@
+SDL_JoyAxisEvent
SDL_JoyAxisEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYAXISMOTION is reported.
A SDL_JOYAXISMOTION event occurs when ever a user moves an axis on the joystick. The field which is the index of the joystick that reported the event and axis is the index of the axis (for a more detailed explaination see the Joystick section). value is the current position of the axis.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoyballevent.html b/lib/sdl/msvc/docs/html/sdljoyballevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..4ab96fe0e83393f66c5469959366c13ef4140d8d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoyballevent.html
@@ -0,0 +1,340 @@
+SDL_JoyBallEvent
SDL_JoyBallEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYBALLMOTION is reported.
A SDL_JOYBALLMOTION event occurs when a user moves a trackball on the joystick. The field which is the index of the joystick that reported the event and ball is the index of the trackball (for a more detailed explaination see the Joystick section). Trackballs only return relative motion, this is the change in position on the ball since it was last polled (last cycle of the event loop) and it is stored in xrel and yrel.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoybuttonevent.html b/lib/sdl/msvc/docs/html/sdljoybuttonevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..d1d9c1ef638d0dc9fbcd2a3c16cbecccba7ddbc2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoybuttonevent.html
@@ -0,0 +1,351 @@
+SDL_JoyButtonEvent
SDL_JoyButtonEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP is reported.
A SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP event occurs when ever a user presses or releases a button on a joystick. The field which is the index of the joystick that reported the event and button is the index of the button (for a more detailed explaination see the Joystick section). state is the current state or the button which is either SDL_PRESSED or SDL_RELEASED.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoyhatevent.html b/lib/sdl/msvc/docs/html/sdljoyhatevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..5e115be2316b524d7bae33ccbff8336a8065ac93
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoyhatevent.html
@@ -0,0 +1,413 @@
+SDL_JoyHatEvent
SDL_JoyHatEvent is a member of the SDL_Event union and is used when an event of type SDL_JOYHATMOTION is reported.
A SDL_JOYHATMOTION event occurs when ever a user moves a hat on the joystick. The field which is the index of the joystick that reported the event and hat is the index of the hat (for a more detailed exlaination see the Joystick section). value is the current position of the hat. It is a logically OR'd combination of the following values (whose meanings should be pretty obvious:) :
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickclose.html b/lib/sdl/msvc/docs/html/sdljoystickclose.html
new file mode 100644
index 0000000000000000000000000000000000000000..efb44e0fe6ca9a09df7ef324f3e851317438d46d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickclose.html
@@ -0,0 +1,223 @@
+SDL_JoystickClose
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickeventstate.html b/lib/sdl/msvc/docs/html/sdljoystickeventstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..11b148a126047f2a2a263b4d5c0690d8bbd80e6f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickeventstate.html
@@ -0,0 +1,290 @@
+SDL_JoystickEventState
This function is used to enable or disable joystick event processing. With joystick event processing disabled you will have to update joystick states with SDL_JoystickUpdate and read the joystick information manually. state is either SDL_QUERY, SDL_ENABLE or SDL_IGNORE.
Note: Joystick event handling is prefered
Return Value
If state is SDL_QUERY then the current state is returned, otherwise the new processing state is returned.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgetaxis.html b/lib/sdl/msvc/docs/html/sdljoystickgetaxis.html
new file mode 100644
index 0000000000000000000000000000000000000000..40a17b4cc2d4e46bd66cd549440a8df0b678cd7f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgetaxis.html
@@ -0,0 +1,271 @@
+SDL_JoystickGetAxis
SDL_JoystickGetAxis -- Get the current state of an axis
Synopsis
#include "SDL.h"
Sint16 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis);
Description
SDL_JoystickGetAxis returns the current state of the given axis on the given joystick.
On most modern joysticks the X axis is usually represented by axis 0 and the Y axis by axis 1. The value returned by SDL_JoystickGetAxis is a signed integer (-32768 to 32768) representing the current position of the axis, it maybe necessary to impose certain tolerances on these values to account for jitter. It is worth noting that some joysticks use axes 2 and 3 for extra buttons.
Return Value
Returns a 16-bit signed integer representing the current position of the axis.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgetball.html b/lib/sdl/msvc/docs/html/sdljoystickgetball.html
new file mode 100644
index 0000000000000000000000000000000000000000..0da252ab1a5cd52e7e89236e46f6869980a986e8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgetball.html
@@ -0,0 +1,262 @@
+SDL_JoystickGetBall
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgetbutton.html b/lib/sdl/msvc/docs/html/sdljoystickgetbutton.html
new file mode 100644
index 0000000000000000000000000000000000000000..680e3569d05a3081c89d68c7aa6da7e6b29f81a0
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgetbutton.html
@@ -0,0 +1,231 @@
+SDL_JoystickGetButton
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickgethat.html b/lib/sdl/msvc/docs/html/sdljoystickgethat.html
new file mode 100644
index 0000000000000000000000000000000000000000..c638abb7c235c7436561d40633ddb9171af36992
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickgethat.html
@@ -0,0 +1,297 @@
+SDL_JoystickGetHat
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickindex.html b/lib/sdl/msvc/docs/html/sdljoystickindex.html
new file mode 100644
index 0000000000000000000000000000000000000000..868a75addb6b033ead51735caca43cba7097b8cf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickindex.html
@@ -0,0 +1,218 @@
+SDL_JoystickIndex
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickname.html b/lib/sdl/msvc/docs/html/sdljoystickname.html
new file mode 100644
index 0000000000000000000000000000000000000000..0add817dc5e9d8a791f5e2bb53b4146a3d57af9d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickname.html
@@ -0,0 +1,238 @@
+SDL_JoystickName
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumaxes.html b/lib/sdl/msvc/docs/html/sdljoysticknumaxes.html
new file mode 100644
index 0000000000000000000000000000000000000000..53b67f52394d0496fdefd561e332580d029d796c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumaxes.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumAxes
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumballs.html b/lib/sdl/msvc/docs/html/sdljoysticknumballs.html
new file mode 100644
index 0000000000000000000000000000000000000000..0a8405dc930423c23013371b6a5c51cb07a776b5
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumballs.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumBalls
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumbuttons.html b/lib/sdl/msvc/docs/html/sdljoysticknumbuttons.html
new file mode 100644
index 0000000000000000000000000000000000000000..625b893a6a2301d184ae888bde281544c5f96396
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumbuttons.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumButtons
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoysticknumhats.html b/lib/sdl/msvc/docs/html/sdljoysticknumhats.html
new file mode 100644
index 0000000000000000000000000000000000000000..ed53235854766bdbddfb0264ece1ae0756bcaa85
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoysticknumhats.html
@@ -0,0 +1,225 @@
+SDL_JoystickNumHats
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickopen.html b/lib/sdl/msvc/docs/html/sdljoystickopen.html
new file mode 100644
index 0000000000000000000000000000000000000000..e608c4370f7a2db71891cd34bd3edf159a696c03
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickopen.html
@@ -0,0 +1,259 @@
+SDL_JoystickOpen
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickopened.html b/lib/sdl/msvc/docs/html/sdljoystickopened.html
new file mode 100644
index 0000000000000000000000000000000000000000..5275a099de81d5fcc06be314f717d38b87f935b3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickopened.html
@@ -0,0 +1,233 @@
+SDL_JoystickOpened
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdljoystickupdate.html b/lib/sdl/msvc/docs/html/sdljoystickupdate.html
new file mode 100644
index 0000000000000000000000000000000000000000..0cb37dc2261dc99e93489491c7f951a021334e6e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdljoystickupdate.html
@@ -0,0 +1,211 @@
+SDL_JoystickUpdate
SDL_JoystickUpdate -- Updates the state of all joysticks
Synopsis
#include "SDL.h"
void SDL_JoystickUpdate(void);
Description
Updates the state(position, buttons, etc.) of all open joysticks. If joystick events have been enabled with SDL_JoystickEventState then this is called automatically in the event loop.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkey.html b/lib/sdl/msvc/docs/html/sdlkey.html
new file mode 100644
index 0000000000000000000000000000000000000000..6591884d1e34b038474222b4e06087e8f72d9d0b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkey.html
@@ -0,0 +1,2630 @@
+SDLKey
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkeyboardevent.html b/lib/sdl/msvc/docs/html/sdlkeyboardevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..1a6962c74a5a95152f8dc4761f2dcafca620641c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkeyboardevent.html
@@ -0,0 +1,375 @@
+SDL_KeyboardEvent
SDL_KeyboardEvent is a member of the SDL_Event union and is used when an event of type SDL_KEYDOWN or SDL_KEYUP is reported.
The type and state actually report the same information, they just use different values to do it! A keyboard event occurs when a key is released (type=SDK_KEYUP or state=SDL_RELEASED) and when a key is pressed (type=SDL_KEYDOWN or state=SDL_PRESSED). The information on what key was pressed or released is in the keysym structure.
Note: Repeating SDL_KEYDOWN events will occur if key repeat is enabled (see SDL_EnableKeyRepeat).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkeysym.html b/lib/sdl/msvc/docs/html/sdlkeysym.html
new file mode 100644
index 0000000000000000000000000000000000000000..7a22f795136dc8a3f1dbbe309d5a57d86544fa2e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkeysym.html
@@ -0,0 +1,355 @@
+SDL_keysym
The SDL_keysym structure is used by reporting key presses and releases since it is a part of the SDL_KeyboardEvent.
The scancode field should generally be left alone, it is the hardware dependent scancode returned by the keyboard. The sym field is extremely useful. It is the SDL-defined value of the key (see SDL Key Syms. This field is very useful when you are checking for certain key presses, like so:
+
+mod stores the current state of the keyboard modifiers as explained in SDL_GetModState. The unicode is only used when UNICODE translation is enabled with SDL_EnableUNICODE. If unicode is non-zero then this a the UNICODE character corresponding to the keypress. If the high 9 bits of the character are 0, then this maps to the equivalent ASCII character:
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlkillthread.html b/lib/sdl/msvc/docs/html/sdlkillthread.html
new file mode 100644
index 0000000000000000000000000000000000000000..2ce7b9b58f84ae3b0fe9d64f1c1825ead1290d7b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlkillthread.html
@@ -0,0 +1,223 @@
+SDL_KillThread
SDL_KillThread -- Gracelessly terminates the thread.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
void SDL_KillThread(SDL_Thread *thread);
Description
SDL_KillThread gracelessly terminates the thread
+associated with thread. If possible, you should
+use some other form of IPC to signal the thread to quit.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllistmodes.html b/lib/sdl/msvc/docs/html/sdllistmodes.html
new file mode 100644
index 0000000000000000000000000000000000000000..ee7bc0eeecf0ad9d37f5f35b3328fa9cb61898a2
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllistmodes.html
@@ -0,0 +1,310 @@
+SDL_ListModes
Return a pointer to an array of available screen dimensions for the given
+format and video flags, sorted largest to smallest. Returns
+NULL if there are no dimensions available for a particular
+format, or -1 if any dimension is okay for
+the given format.
If format is NULL, the mode list
+will be for the format returned by SDL_GetVideoInfo()->vfmt. The flag parameter is an OR'd combination of surface flags. The flags are the same as those used SDL_SetVideoMode and they play a strong role in deciding what modes are valid. For instance, if you pass SDL_HWSURFACE as a flag only modes that support hardware video surfaces will be returned.
Example
SDL_Rect **modes;
+int i;
+.
+.
+.
+
+/* Get available fullscreen/hardware modes */
+modes=SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
+
+/* Check is there are any modes available */
+if(modes == (SDL_Rect **)0){
+ printf("No modes available!\n");
+ exit(-1);
+}
+
+/* Check if our resolution is restricted */
+if(modes == (SDL_Rect **)-1){
+ printf("All resolutions available.\n");
+}
+else{
+ /* Print valid modes */
+ printf("Available Modes\n");
+ for(i=0;modes[i];++i)
+ printf(" %d x %d\n", modes[i]->w, modes[i]->h);
+}
+.
+.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlloadbmp.html b/lib/sdl/msvc/docs/html/sdlloadbmp.html
new file mode 100644
index 0000000000000000000000000000000000000000..41556e34ae87fabf050fe72860d592b381deb275
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlloadbmp.html
@@ -0,0 +1,219 @@
+SDL_LoadBMP
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlloadwav.html b/lib/sdl/msvc/docs/html/sdlloadwav.html
new file mode 100644
index 0000000000000000000000000000000000000000..8abb73ec366f3038b4d61264a971bff327d74104
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlloadwav.html
@@ -0,0 +1,296 @@
+SDL_LoadWAV
SDL_LoadWAV
+This function loads a WAVE file into memory.
If this function succeeds, it returns the given
+SDL_AudioSpec,
+filled with the audio data format of the wave data, and sets
+audio_buf to a malloc'd
+buffer containing the audio data, and sets audio_len
+to the length of that audio buffer, in bytes. You need to free the audio
+buffer with SDL_FreeWAV when you are
+done with it.
This function returns NULL and sets the SDL
+error message if the wave file cannot be opened, uses an unknown data format,
+or is corrupt. Currently raw, MS-ADPCM and IMA-ADPCM WAVE files are supported.
Example
SDL_AudioSpec wav_spec;
+Uint32 wav_length;
+Uint8 *wav_buffer;
+
+/* Load the WAV */
+if( SDL_LoadWAV("test.wav", &wav_spec, &wav_buffer, &wav_length) == NULL ){
+ fprintf(stderr, "Could not open test.wav: %s\n", SDL_GetError());
+ exit(-1);
+}
+.
+.
+.
+/* Do stuff with the WAV */
+.
+.
+/* Free It */
+SDL_FreeWAV(wav_buffer);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllockaudio.html b/lib/sdl/msvc/docs/html/sdllockaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..0e6fc292b4db8c10c143a834c1e722f48eca4f89
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllockaudio.html
@@ -0,0 +1,208 @@
+SDL_LockAudio
The lock manipulated by these functions protects the callback function.
+During a LockAudio period, you can be guaranteed that the
+callback function is not running. Do not call these from the callback
+function or you will cause deadlock.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllocksurface.html b/lib/sdl/msvc/docs/html/sdllocksurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..40c8959ea025ce28b2898e3a10e818d4bd548e9f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllocksurface.html
@@ -0,0 +1,306 @@
+SDL_LockSurface
SDL_LockSurface -- Lock a surface for directly access.
Synopsis
#include "SDL.h"
int SDL_LockSurface(SDL_Surface *surface);
Description
SDL_LockSurface sets up a surface for directly
+accessing the pixels. Between calls to SDL_LockSurface
+and SDL_UnlockSurface, you can write to and read from
+surface->pixels, using the pixel format stored in
+surface->format. Once you are done accessing the
+surface, you should use SDL_UnlockSurface to release it.
Not all surfaces require locking.
+If SDL_MUSTLOCK(surface)
+evaluates to 0, then you can read and write to the
+surface at any time, and the pixel format of the surface will not change.
No operating system or library calls should be made between lock/unlock
+pairs, as critical system locks may be held during this time.
It should be noted, that since SDL 1.1.8 surface locks are recursive. This means that you can lock a surface multiple times, but each lock must have a match unlock.
+
.
+ .
+ SDL_LockSurface( surface );
+ .
+ /* Surface is locked */
+ /* Direct pixel access on surface here */
+ .
+ SDL_LockSurface( surface );
+ .
+ /* More direct pixel access on surface */
+ .
+ SDL_UnlockSurface( surface );
+ /* Surface is still locked */
+ /* Note: Is versions < 1.1.8, the surface would have been */
+ /* no longer locked at this stage */
+ .
+ SDL_UnlockSurface( surface );
+ /* Surface is now unlocked */
+ .
+ .
Return Value
SDL_LockSurface returns 0,
+or -1 if the surface couldn't be locked.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdllockyuvoverlay.html b/lib/sdl/msvc/docs/html/sdllockyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..74e6ce673dba1e186746e1613f77878e98a1caa0
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdllockyuvoverlay.html
@@ -0,0 +1,252 @@
+SDL_LockYUVOverlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmaprgb.html b/lib/sdl/msvc/docs/html/sdlmaprgb.html
new file mode 100644
index 0000000000000000000000000000000000000000..5086d0c7dca8b7b700cde9c60ef06c11870e2af1
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmaprgb.html
@@ -0,0 +1,254 @@
+SDL_MapRGB
Maps the RGB color value to the specified pixel format and returns the
+pixel value as a 32-bit int.
If the format has a palette (8-bit) the index of the closest matching
+color in the palette will be returned.
If the specified pixel format has an alpha component it will be returned
+as all 1 bits (fully opaque).
Return Value
A pixel value best approximating the given RGB color value for a given
+pixel format. If the pixel format bpp (color depth) is less than 32-bpp
+then the unused upper bits of the return value can safely be ignored
+(e.g., with a 16-bpp format the return value can be assigned to a
+Uint16, and similarly a Uint8 for an 8-bpp
+format).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmaprgba.html b/lib/sdl/msvc/docs/html/sdlmaprgba.html
new file mode 100644
index 0000000000000000000000000000000000000000..e6bff276f770f121e1009482c4339f039aa96036
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmaprgba.html
@@ -0,0 +1,242 @@
+SDL_MapRGBA
Maps the RGBA color value to the specified pixel format and returns the
+pixel value as a 32-bit int.
If the format has a palette (8-bit) the index of the closest matching
+color in the palette will be returned.
If the specified pixel format has no alpha component the alpha value
+will be ignored (as it will be in formats with a palette).
Return Value
A pixel value best approximating the given RGBA color value for a given
+pixel format. If the pixel format bpp (color depth) is less than 32-bpp
+then the unused upper bits of the return value can safely be ignored
+(e.g., with a 16-bpp format the return value can be assigned to a
+Uint16, and similarly a Uint8 for an 8-bpp
+format).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmixaudio.html b/lib/sdl/msvc/docs/html/sdlmixaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..6cbf0f0dbd4baa642bf9aadfd6dd21938965402d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmixaudio.html
@@ -0,0 +1,237 @@
+SDL_MixAudio
void SDL_MixAudio(Uint8 *dst, Uint8 *src, Uint32 len, int volume);
Description
This function takes two audio buffers of len bytes each
+of the playing audio format and mixes them, performing addition, volume
+adjustment, and overflow clipping. The volume ranges
+from 0 to SDL_MIX_MAXVOLUME and should be set to the maximum
+value for full audio volume. Note this does not change hardware volume. This is
+provided for convenience -- you can mix your own audio data.
Note: Do not use this function for mixing together more than two streams of sample
+data. The output from repeated application of this function may be distorted
+by clipping, because there is no accumulator with greater range than the
+input (not to mention this being an inefficient way of doing it).
+Use mixing functions from SDL_mixer, OpenAL, or write your own mixer instead.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmousebuttonevent.html b/lib/sdl/msvc/docs/html/sdlmousebuttonevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..b0b40df97a7ef890a0400bb466809be717757c0c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmousebuttonevent.html
@@ -0,0 +1,346 @@
+SDL_MouseButtonEvent
The mouse button index (SDL_BUTTON_LEFT, SDL_BUTTON_MIDDLE, SDL_BUTTON_RIGHT)
state
SDL_PRESSED or SDL_RELEASED
x, y
The X/Y coordinates of the mouse at press/release time
Description
SDL_MouseButtonEvent is a member of the SDL_Event union and is used when an event of type SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP is reported.
When a mouse button press or release is detected then number of the button pressed (from 1 to 255, with 1 usually being the left button and 2 the right) is placed into button, the position of the mouse when this event occured is stored in the x and the y fields. Like SDL_KeyboardEvent, information on whether the event was a press or a release event is stored in both the type and state fields, but this should be obvious.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmousemotionevent.html b/lib/sdl/msvc/docs/html/sdlmousemotionevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..3cc7cb5c6adf74472fbd7ec31af6c1462b3a0b58
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmousemotionevent.html
@@ -0,0 +1,365 @@
+SDL_MouseMotionEvent
SDL_MouseMotionEvent is a member of the SDL_Event union and is used when an event of type SDL_MOUSEMOTION is reported.
Simply put, a SDL_MOUSEMOTION type event occurs when a user moves the mouse within the application window or when SDL_WarpMouse is called. Both the absolute (x and y) and relative (xrel and yrel) coordinates are reported along with the current button states (state). The button state can be interpreted using the SDL_BUTTON macro (see SDL_GetMouseState).
If the cursor is hidden (SDL_ShowCursor(0)) and the input is grabbed (SDL_WM_GrabInput(SDL_GRAB_ON)), then the mouse will give relative motion events even when the cursor reaches the edge fo the screen. This is currently only implemented on Windows and Linux/Unix-a-likes.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmutexp.html b/lib/sdl/msvc/docs/html/sdlmutexp.html
new file mode 100644
index 0000000000000000000000000000000000000000..fc32ca59961d2492620ea615420296c67665b8fe
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmutexp.html
@@ -0,0 +1,241 @@
+SDL_mutexP
Locks the mutex, which was previously created with SDL_CreateMutex. If the mutex is already locked then SDL_mutexP will not return until it is unlocked. Returns 0 on success, or -1 on an error.
SDL also defines a macro #define SDL_LockMutex(m) SDL_mutexP(m).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlmutexv.html b/lib/sdl/msvc/docs/html/sdlmutexv.html
new file mode 100644
index 0000000000000000000000000000000000000000..06a68bdc5ebe5135213fd933dc999c9789abce7c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlmutexv.html
@@ -0,0 +1,235 @@
+SDL_mutexV
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlnumjoysticks.html b/lib/sdl/msvc/docs/html/sdlnumjoysticks.html
new file mode 100644
index 0000000000000000000000000000000000000000..68e3e3a72ee587bed9f098f50f192f02d63c255f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlnumjoysticks.html
@@ -0,0 +1,222 @@
+SDL_NumJoysticks
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlopenaudio.html b/lib/sdl/msvc/docs/html/sdlopenaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..bcfed54a7f4ba0906aa9d9953d3c22a2e8dea9e7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlopenaudio.html
@@ -0,0 +1,578 @@
+SDL_OpenAudio
SDL_OpenAudio -- Opens the audio device with the desired parameters.
Synopsis
#include "SDL.h"
int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained);
Description
This function opens the audio device with the desired parameters, and
+returns 0 if successful, placing the actual hardware parameters in the
+structure pointed to by obtained. If obtained is NULL, the audio
+data passed to the callback function will be guaranteed to be in the
+requested format, and will be automatically converted to the hardware
+audio format if necessary. This function returns -1 if it failed
+to open the audio device, or couldn't set up the audio thread.
To open the audio device a desiredSDL_AudioSpec must be created.
+
The desired size of the audio buffer in samples. This number should be a power of two, and may be adjusted by the audio driver to a value more suitable for the hardware. Good values seem to range between 512 and 8192 inclusive, depending on the application and CPU speed. Smaller values yield faster response time, but can lead to underflow if the application is doing heavy processing and cannot fill the audio buffer in time. A stereo sample consists of both right and left channels in LR ordering. Note that the number of samples is directly related to time by the following formula: ms = (samples*1000)/freq
desired->callback
This should be set to a function that will be called when the audio device is ready for more data. It is passed a pointer to the audio buffer, and the length in bytes of the audio buffer. This function usually runs in a separate thread, and so you should protect data structures that it accesses by calling SDL_LockAudio and SDL_UnlockAudio in your code. The callback prototype is:
+
void callback(void *userdata, Uint8 *stream, int len);
+userdata is the pointer stored in userdata field of the SDL_AudioSpec. stream is a pointer to the audio buffer you want to fill with information and len is the length of the audio buffer in bytes.
desired->userdata
This pointer is passed as the first parameter to the callback function.
SDL_OpenAudio reads these fields from the desiredSDL_AudioSpec structure pass to the function and attempts to find an audio configuration matching your desired. As mentioned above, if the obtained parameter is NULL then SDL with convert from your desired audio settings to the hardware settings as it plays.
If obtained is NULL then the desiredSDL_AudioSpec is your working specification, otherwise the obtainedSDL_AudioSpec becomes the working specification and the desirec specification can be deleted. The data in the working specification is used when building SDL_AudioCVT's for converting loaded data to the hardware format.
SDL_OpenAudio calculates the size and silence fields for both the desired and obtained specifications. The size field stores the total size of the audio buffer in bytes, while the silence stores the value used to represent silence in the audio buffer
The audio device starts out playing silence when it's opened, and should be enabled for playing by calling SDL_PauseAudio(0) when you are ready for your audio callback function to be called. Since the audio driver may modify the requested size of the audio buffer, you should allocate any local mixing buffers after you open the audio device.
Examples
/* Prototype of our callback function */
+void my_audio_callback(void *userdata, Uint8 *stream, int len);
+
+/* Open the audio device */
+SDL_AudioSpec *desired, *obtained;
+SDL_AudioSpec *hardware_spec;
+
+/* Allocate a desired SDL_AudioSpec */
+desired = malloc(sizeof(SDL_AudioSpec));
+
+/* Allocate space for the obtained SDL_AudioSpec */
+obtained = malloc(sizeof(SDL_AudioSpec));
+
+/* 22050Hz - FM Radio quality */
+desired->freq=22050;
+
+/* 16-bit signed audio */
+desired->format=AUDIO_S16LSB;
+
+/* Mono */
+desired->channels=0;
+
+/* Large audio buffer reduces risk of dropouts but increases response time */
+desired->samples=8192;
+
+/* Our callback function */
+desired->callback=my_audio_callback;
+
+desired->userdata=NULL;
+
+/* Open the audio device */
+if ( SDL_OpenAudio(desired, obtained) < 0 ){
+ fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+ exit(-1);
+}
+/* desired spec is no longer needed */
+free(desired);
+hardware_spec=obtained;
+.
+.
+/* Prepare callback for playing */
+.
+.
+.
+/* Start playing */
+SDL_PauseAudio(0);
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdloverlay.html b/lib/sdl/msvc/docs/html/sdloverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..422919edc90d03be4408c9bc63861093ad06b047
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdloverlay.html
@@ -0,0 +1,362 @@
+SDL_Overlay
Number of planes in the overlay. Usually either 1 or 3
pitches
An array of pitches, one for each plane. Pitch is the length of a row in bytes.
pixels
An array of pointers to teh data of each plane. The overlay should be locked before these pointers are used.
hw_overlay
This will be set to 1 if the overlay is hardware accelerated.
Description
A SDL_Overlay is similar to a SDL_Surface except it stores a YUV overlay. All the fields are read only, except for pixels which should be locked before use. The format field stores the format of the overlay which is one of the following:
+
#define SDL_YV12_OVERLAY 0x32315659 /* Planar mode: Y + V + U */
+#define SDL_IYUV_OVERLAY 0x56555949 /* Planar mode: Y + U + V */
+#define SDL_YUY2_OVERLAY 0x32595559 /* Packed mode: Y0+U0+Y1+V0 */
+#define SDL_UYVY_OVERLAY 0x59565955 /* Packed mode: U0+Y0+V0+Y1 */
+#define SDL_YVYU_OVERLAY 0x55595659 /* Packed mode: Y0+V0+Y1+U0 */
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpalette.html b/lib/sdl/msvc/docs/html/sdlpalette.html
new file mode 100644
index 0000000000000000000000000000000000000000..6498ac40ba206e4baf37547b12787d94cba1536c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpalette.html
@@ -0,0 +1,301 @@
+SDL_Palette
SDL_Palette -- Color palette for 8-bit pixel formats
Structure Definition
typedef struct{
+ int ncolors;
+ SDL_Color *colors;
+} SDL_Palette;
Structure Data
ncolors
Number of colors used in this palette
colors
Pointer to SDL_Color structures that make up the palette.
Description
Each pixel in an 8-bit surface is an index into the colors field of the SDL_Palette structure store in SDL_PixelFormat. A SDL_Palette should never need to be created manually. It is automatically created when SDL allocates a SDL_PixelFormat for a surface. The colors values of a SDL_Surfaces palette can be set with the SDL_SetColors.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpauseaudio.html b/lib/sdl/msvc/docs/html/sdlpauseaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..39d5a0f0f91e01f5343f3c8887c3355987ae8a03
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpauseaudio.html
@@ -0,0 +1,221 @@
+SDL_PauseAudio
SDL_PauseAudio -- Pauses and unpauses the audio callback processing
Synopsis
#include "SDL.h"
void SDL_PauseAudio(int pause_on);
Description
This function pauses and unpauses the audio callback processing.
+It should be called with pause_on=0 after opening the audio
+device to start playing sound. This is so you can safely initialize
+data for your callback function after opening the audio device.
+Silence will be written to the audio device during the pause.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpeepevents.html b/lib/sdl/msvc/docs/html/sdlpeepevents.html
new file mode 100644
index 0000000000000000000000000000000000000000..d5a0ff6f9fe11184af66f51b485cab9b312227c7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpeepevents.html
@@ -0,0 +1,321 @@
+SDL_PeepEvents
SDL_PeepEvents -- Checks the event queue for messages and optionally returns them.
Synopsis
#include "SDL.h"
int SDL_PeepEvents(SDL_Event *events, int numevents, SDL_eventaction action, Uint32 mask);
Description
Checks the event queue for messages and optionally returns them.
If action is SDL_ADDEVENT, up to
+numevents events will be added to the back of the event
+ queue.
If action is SDL_PEEKEVENT, up to
+numevents events at the front of the event queue,
+matching mask,
+will be returned and will not be removed from the queue.
If action is SDL_GETEVENT, up to
+numevents events at the front of the event queue,
+matching mask,
+will be returned and will be removed from the queue.
The mask parameter is an bitwise OR of
+SDL_EVENTMASK(event_type), for all
+event types you are interested in.
This function is thread-safe.
Return Value
This function returns the number of events actually stored, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpixelformat.html b/lib/sdl/msvc/docs/html/sdlpixelformat.html
new file mode 100644
index 0000000000000000000000000000000000000000..000ddc08b163564736cb4c9c6462f6ffc8414c8a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpixelformat.html
@@ -0,0 +1,528 @@
+SDL_PixelFormat
Pointer to the palette, or NULL if the BitsPerPixel>8
BitsPerPixel
The number of bits used to represent each pixel in a surface. Usually 8, 16, 24 or 32.
BytesPerPixel
The number of bytes used to represent each pixel in a surface. Usually one to four.
[RGBA]mask
Binary mask used to retrieve individual color values
[RGBA]loss
Precision loss of each color component (2[RGBA]loss)
[RGBA]shift
Binary left shift of each color component in the pixel value
colorkey
Pixel value of transparent pixels
alpha
Overall surface alpha value
Description
A SDL_PixelFormat describes the format of the pixel data stored at the pixels field of a SDL_Surface. Every surface stores a SDL_PixelFormat in the format field.
If you wish to do pixel level modifications on a surface, then understanding how SDL stores its color information is essential.
8-bit pixel formats are the easiest to understand. Since its an 8-bit format, we have 8 BitsPerPixel and 1 BytesPerPixel. Since BytesPerPixel is 1, all pixels are represented by a Uint8 which contains an index into palette->colors. So, to determine the color of a pixel in a 8-bit surface: we read the color index from surface->pixels and we use that index to read the SDL_Color structure from surface->format->palette->colors. Like so:
+
SDL_Surface *surface;
+SDL_PixelFormat *fmt;
+SDL_Color *color;
+Uint8 index;
+
+.
+.
+
+/* Create surface */
+.
+.
+fmt=surface->format;
+
+/* Check the bitdepth of the surface */
+if(fmt->BitsPerPixel!=8){
+ fprintf(stderr, "Not an 8-bit surface.\n");
+ return(-1);
+}
+
+/* Lock the surface */
+SDL_LockSurface(surface);
+
+/* Get the topleft pixel */
+index=*(Uint8 *)surface->pixels;
+color=fmt->palette->colors[index];
+
+/* Unlock the surface */
+SDL_UnlockSurface(surface);
+printf("Pixel Color-> Red: %d, Green: %d, Blue: %d. Index: %d\n",
+ color->r, color->g, color->b, index);
+.
+.
Pixel formats above 8-bit are an entirely different experience. They are
+considered to be "TrueColor" formats and the color information is stored in the
+pixels themselves, not in a palette. The mask, shift and loss fields tell us
+how the color information is encoded. The mask fields allow us to isolate each
+color component, the shift fields tell us the number of bits to the right of
+each component in the pixel value and the loss fields tell us the number of
+bits lost from each component when packing 8-bit color component in a pixel.
+
/* Extracting color components from a 32-bit color value */
+SDL_PixelFormat *fmt;
+SDL_Surface *surface;
+Uint32 temp, pixel;
+Uint8 red, green, blue, alpha;
+.
+.
+.
+fmt=surface->format;
+SDL_LockSurface(surface);
+pixel=*((Uint32*)surface->pixels);
+SDL_UnlockSurface(surface);
+
+/* Get Red component */
+temp=pixel&fmt->Rmask; /* Isolate red component */
+temp=temp>>fmt->Rshift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Rloss; /* Expand to a full 8-bit number */
+red=(Uint8)temp;
+
+/* Get Green component */
+temp=pixel&fmt->Gmask; /* Isolate green component */
+temp=temp>>fmt->Gshift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Gloss; /* Expand to a full 8-bit number */
+green=(Uint8)temp;
+
+/* Get Blue component */
+temp=pixel&fmt->Bmask; /* Isolate blue component */
+temp=temp>>fmt->Bshift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Bloss; /* Expand to a full 8-bit number */
+blue=(Uint8)temp;
+
+/* Get Alpha component */
+temp=pixel&fmt->Amask; /* Isolate alpha component */
+temp=temp>>fmt->Ashift;/* Shift it down to 8-bit */
+temp=temp<<fmt->Aloss; /* Expand to a full 8-bit number */
+alpha=(Uint8)temp;
+
+printf("Pixel Color -> R: %d, G: %d, B: %d, A: %d\n", red, green, blue, alpha);
+.
+.
+.
SDL_PollEvent -- Polls for currently pending events.
Synopsis
#include "SDL.h"
int SDL_PollEvent(SDL_Event *event);
Description
Polls for currently pending events, and returns 1
+if there are any pending events, or 0 if there
+are none available.
If event is not NULL, the next
+event is removed from the queue and stored in that area.
Examples
SDL_Event event; /* Event structure */
+
+.
+.
+.
+/* Check for events */
+while(SDL_PollEvent(&event)){ /* Loop until there are no events left on the queue */
+ switch(event.type){ /* Process the appropiate event type */
+ case SDL_KEYDOWN: /* Handle a KEYDOWN event */
+ printf("Oh! Key press\n");
+ break;
+ case SDL_MOUSEMOTION:
+ .
+ .
+ .
+ default: /* Report an unhandled event */
+ printf("I don't know what this event is!\n");
+ }
+}
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpumpevents.html b/lib/sdl/msvc/docs/html/sdlpumpevents.html
new file mode 100644
index 0000000000000000000000000000000000000000..a7e528f19ac4b428212d41996ff631044f6e2762
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpumpevents.html
@@ -0,0 +1,244 @@
+SDL_PumpEvents
SDL_PumpEvents -- Pumps the event loop, gathering events from the input devices.
Synopsis
#include "SDL.h"
void SDL_PumpEvents(void);
Description
Pumps the event loop, gathering events from the input devices.
SDL_PumpEvents gathers all the pending input information from devices and places it on the event queue. Without calls to SDL_PumpEvents no events would ever be placed on the queue. Often calls the need for SDL_PumpEvents is hidden from the user since SDL_PollEvent and SDL_WaitEvent implicitly call SDL_PumpEvents. However, if you are not polling or waiting for events (e.g. you are filtering them), then you must call SDL_PumpEvents to force an event queue update.
Note: You can only call this function in the thread that set the video mode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlpushevent.html b/lib/sdl/msvc/docs/html/sdlpushevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..6905385c32d40bb7a32aa22ebe13abe1ce1cb47c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlpushevent.html
@@ -0,0 +1,266 @@
+SDL_PushEvent
SDL_PushEvent -- Pushes an event onto the event queue
Synopsis
#include "SDL.h"
int SDL_PushEvent(SDL_Event *event);
Description
The event queue can actually be used as a two way communication channel. Not only can events be read from the queue, but the user can also push their own events onto it. event is a pointer to the event structure you wish to push onto the queue.
Note: Pushing device input events onto the queue doesn't modify the state of the device within SDL.
Return Value
Returns 0 on success or -1 if the event couldn't be pushed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlquit.html b/lib/sdl/msvc/docs/html/sdlquit.html
new file mode 100644
index 0000000000000000000000000000000000000000..1f31c82558ae9fb430d16b8d65148471e7cc90da
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlquit.html
@@ -0,0 +1,244 @@
+SDL_Quit
SDL_Quit shuts down all SDL subsystems and frees the resources allocated to them. This should always be called before you exit. For the sake of simplicity you can set SDL_Quit as your atexit call, like:
+
Note: While using atexit maybe be fine for small programs, more advanced users should shut down SDL in their own cleanup code. Plus, using atexit in a library is a sure way to crash dynamically loaded code
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlquitevent.html b/lib/sdl/msvc/docs/html/sdlquitevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..d575f38b7b703a6c9a588a443d39184ec8347be4
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlquitevent.html
@@ -0,0 +1,263 @@
+SDL_QuitEvent
SDL_QuitEvent is a member of the SDL_Event union and is used whan an event of type SDL_QUIT is reported.
As can be seen, the SDL_QuitEvent structure serves no useful purpose. The event itself, on the other hand, is very important. If you filter out or ignore a quit event then it is impossible for the user to close the window. On the other hand, if you do accept a quit event then the application window will be closed, and screen updates will still report success event though the application will no longer be visible.
Note: The macro SDL_QuitRequested will return non-zero if a quit event is pending
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlquitsubsystem.html b/lib/sdl/msvc/docs/html/sdlquitsubsystem.html
new file mode 100644
index 0000000000000000000000000000000000000000..877e3ce1181fe10145a0c7fa537813217aab19de
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlquitsubsystem.html
@@ -0,0 +1,248 @@
+SDL_QuitSubSystem
SDL_QuitSubSystem allows you to shut down a subsystem that has been previously initialized by SDL_Init or SDL_InitSubSystem. The flags tells SDL_QuitSubSystem which subsystems to shut down, it uses the same values that are passed to SDL_Init.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlrect.html b/lib/sdl/msvc/docs/html/sdlrect.html
new file mode 100644
index 0000000000000000000000000000000000000000..ba4a80be69ceb897c407a1411e9fac7ea1d7514a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlrect.html
@@ -0,0 +1,258 @@
+SDL_Rect
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlremovetimer.html b/lib/sdl/msvc/docs/html/sdlremovetimer.html
new file mode 100644
index 0000000000000000000000000000000000000000..26a3d11f7b8cf7b1965f58345a4e1a9c62070863
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlremovetimer.html
@@ -0,0 +1,236 @@
+SDL_RemoveTimer
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlresizeevent.html b/lib/sdl/msvc/docs/html/sdlresizeevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..1d446a54cd140f502bad788e7457aec15638c93e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlresizeevent.html
@@ -0,0 +1,307 @@
+SDL_ResizeEvent
SDL_ResizeEvent is a member of the SDL_Event union and is used when an event of type SDL_VIDEORESIZE is reported.
When SDL_RESIZABLE is passed as a flag to SDL_SetVideoMode the user is allowed to resize the applications window. When the window is resized an SDL_VIDEORESIZE is report, with the new window width and height values stored in w and h, respectively. When an SDL_VIDEORESIZE is recieved the window should be resized to the new dimensions using SDL_SetVideoMode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsavebmp.html b/lib/sdl/msvc/docs/html/sdlsavebmp.html
new file mode 100644
index 0000000000000000000000000000000000000000..4c318ed756e4fa74a135b1302568db8b8c8bf713
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsavebmp.html
@@ -0,0 +1,236 @@
+SDL_SaveBMP
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsempost.html b/lib/sdl/msvc/docs/html/sdlsempost.html
new file mode 100644
index 0000000000000000000000000000000000000000..18fb01ab2f7717868d7736f1a838fbebd0dc1953
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsempost.html
@@ -0,0 +1,299 @@
+SDL_SemPost
SDL_SemPost unlocks the semaphore pointed to by
+sem and atomically increments the semaphores value.
+Threads that were blocking on the semaphore may be scheduled after this call
+succeeds.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemtrywait.html b/lib/sdl/msvc/docs/html/sdlsemtrywait.html
new file mode 100644
index 0000000000000000000000000000000000000000..86f47a1c83afce734bc83cdd1c966268c467ed99
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemtrywait.html
@@ -0,0 +1,319 @@
+SDL_SemTryWait
SDL_SemTryWait -- Attempt to lock a semaphore but don't suspend the thread.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_SemTryWait(SDL_sem *sem);
Description
SDL_SemTryWait is a non-blocking varient of
+SDL_SemWait. If the value of the semaphore
+pointed to by sem is positive it will atomically
+decrement the semaphore value and return 0, otherwise it will return
+SDL_MUTEX_TIMEDOUT instead of suspending the thread.
After SDL_SemTryWait is successful, the semaphore
+can be released and its count atomically incremented by a successful call to
+SDL_SemPost.
Return Value
Returns 0 if the semaphore was successfully locked or
+either SDL_MUTEX_TIMEDOUT or -1
+if the thread would have suspended or there was an error, respectivly.
If the semaphore was not successfully locked, the semaphore will be unchanged.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemvalue.html b/lib/sdl/msvc/docs/html/sdlsemvalue.html
new file mode 100644
index 0000000000000000000000000000000000000000..7867369b1b496e0de3c26969fa7e29b413a57ac8
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemvalue.html
@@ -0,0 +1,273 @@
+SDL_SemValue
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemwait.html b/lib/sdl/msvc/docs/html/sdlsemwait.html
new file mode 100644
index 0000000000000000000000000000000000000000..5e98d552ee60e0155213a7b064b1519f671b7329
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemwait.html
@@ -0,0 +1,298 @@
+SDL_SemWait
SDL_SemWait -- Lock a semaphore and suspend the thread if the semaphore value is zero.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_SemWait(SDL_sem *sem);
Description
SDL_SemWait() suspends the calling thread until either
+the semaphore pointed to by sem has a positive value,
+the call is interrupted by a signal or error. If the call is successful it
+will atomically decrement the semaphore value.
After SDL_SemWait() is successful, the semaphore
+can be released and its count atomically incremented by a successful call to
+SDL_SemPost.
Return Value
Returns 0 if successful or
+-1 if there was an error (leaving the semaphore unchanged).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsemwaittimeout.html b/lib/sdl/msvc/docs/html/sdlsemwaittimeout.html
new file mode 100644
index 0000000000000000000000000000000000000000..788f5b7250645a14e763af26d61a228b4cc29520
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsemwaittimeout.html
@@ -0,0 +1,322 @@
+SDL_SemWaitTimeout
SDL_SemWaitTimeout -- Lock a semaphore, but only wait up to a specified maximum time.
Synopsis
#include "SDL.h"
+#include "SDL_thread.h"
int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout);
Description
SDL_SemWaitTimeout() is a varient of
+SDL_SemWait
+with a maximum timeout value.
+If the value of the semaphore pointed to by sem is
+positive (greater than zero) it will atomically decrement the semaphore value
+and return 0, otherwise it will wait up to timeout
+milliseconds trying to lock the semaphore. This function is to be avoided if
+possible since on some platforms it is implemented by polling the semaphore
+every millisecond in a busy loop.
After SDL_SemWaitTimeout() is successful, the semaphore
+can be released and its count atomically incremented by a successful call to
+SDL_SemPost.
Return Value
Returns 0 if the semaphore was successfully locked or
+either SDL_MUTEX_TIMEDOUT or -1
+if the timeout period was exceeded or there was an error, respectivly.
If the semaphore was not successfully locked, the semaphore will be unchanged.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetalpha.html b/lib/sdl/msvc/docs/html/sdlsetalpha.html
new file mode 100644
index 0000000000000000000000000000000000000000..fc844981f14fd8bb3cd4ed62dc648847faf494a3
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetalpha.html
@@ -0,0 +1,500 @@
+SDL_SetAlpha
SDL_SetAlpha -- Adjust the alpha properties of a surface
Synopsis
#include "SDL.h"
int SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
Description
Note: This function and the semantics of SDL alpha blending have changed since version 1.1.4. Up until version 1.1.5, an alpha value of 0 was considered opaque and a value of 255 was considered transparent. This has now been inverted: 0 (SDL_ALPHA_TRANSPARENT) is now considered transparent and 255 (SDL_ALPHA_OPAQUE) is now considered opaque.
SDL_SetAlpha is used for setting the per-surface alpha
+value and/or enabling and disabling alpha blending.
Thesurface parameter specifies which surface whose alpha
+attributes you wish to adjust. flags is used to specify
+whether alpha blending should be used (SDL_SRCALPHA) and
+whether the surface should use RLE acceleration for blitting
+(SDL_RLEACCEL). flags can be an OR'd
+combination of these two options, one of these options or 0. If
+SDL_SRCALPHA is not passed as a flag then all alpha
+information is ignored when blitting the surface. The
+alpha parameter is the per-surface alpha value; a
+surface need not have an alpha channel to use per-surface alpha and blitting
+can still be accelerated with SDL_RLEACCEL.
Note: The per-surface alpha value of 128 is considered a special case and
+is optimised, so it's much faster than other per-surface values.
Alpha effects surface blitting in the following ways:
RGBA->RGB with SDL_SRCALPHA
The source is alpha-blended with the destination, using the alpha channel. SDL_SRCCOLORKEY and the per-surface alpha are ignored.
RGBA->RGB without SDL_SRCALPHA
The RGB data is copied from the source. The source alpha channel and the per-surface alpha value are ignored.
RGB->RGBA with SDL_SRCALPHA
The source is alpha-blended with the destination using the per-surface alpha
+value. If SDL_SRCCOLORKEY is set, only the pixels not
+matching the colorkey value are copied. The alpha channel of the copied pixels
+is set to opaque.
RGB->RGBA without SDL_SRCALPHA
The RGB data is copied from the source and the alpha value of the copied pixels
+is set to opaque. If SDL_SRCCOLORKEY is set, only the pixels
+not matching the colorkey value are copied.
RGBA->RGBA with SDL_SRCALPHA
The source is alpha-blended with the destination using the source alpha
+channel. The alpha channel in the destination surface is left untouched.
+SDL_SRCCOLORKEY is ignored.
RGBA->RGBA without SDL_SRCALPHA
The RGBA data is copied to the destination surface. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.
RGB->RGB with SDL_SRCALPHA
The source is alpha-blended with the destination using the per-surface alpha value. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.
RGB->RGB without SDL_SRCALPHA
The RGB data is copied from the source. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.
Note: Note that RGBA->RGBA blits (with SDL_SRCALPHA set) keep the alpha
+of the destination surface. This means that you cannot compose two arbitrary
+RGBA surfaces this way and get the result you would expect from "overlaying"
+them; the destination alpha will work as a mask.
Also note that per-pixel and per-surface alpha cannot be combined;
+the per-pixel alpha is always used if available
Return Value
This function returns 0, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcliprect.html b/lib/sdl/msvc/docs/html/sdlsetcliprect.html
new file mode 100644
index 0000000000000000000000000000000000000000..03898d55ace6cde337e4481443001b1c5ee67513
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcliprect.html
@@ -0,0 +1,241 @@
+SDL_SetClipRect
Sets the clipping rectangle for a surface. When this surface is the
+destination of a blit, only the area within the clip rectangle will be
+drawn into.
The rectangle pointed to by rect will be
+clipped to the edges of the surface so that the clip rectangle for a
+surface can never fall outside the edges of the surface.
If rect is NULL the clipping
+rectangle will be set to the full size of the surface.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcolorkey.html b/lib/sdl/msvc/docs/html/sdlsetcolorkey.html
new file mode 100644
index 0000000000000000000000000000000000000000..0cb6695791539b6004b87c972323cb65175ea3dd
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcolorkey.html
@@ -0,0 +1,321 @@
+SDL_SetColorKey
SDL_SetColorKey -- Sets the color key (transparent pixel) in a blittable surface and
+RLE acceleration.
Synopsis
#include "SDL.h"
int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key);
Description
Sets the color key (transparent pixel) in a blittable surface and enables or
+ disables RLE blit acceleration.
RLE acceleration can substantially speed up blitting of images with large
+horizontal runs of transparent pixels (i.e., pixels that match the
+key value). The key must be of the same pixel format as the surface, SDL_MapRGB is often useful for obtaining an acceptable value.
If flag is SDL_SRCCOLORKEY then
+key is the transparent pixel value in the source image of a
+blit.
If flag is OR'd with
+SDL_RLEACCEL then the surface will be draw using RLE
+acceleration when drawn with
+SDL_BlitSurface. The surface will
+actually be encoded for RLE acceleration the first time
+SDL_BlitSurface or
+SDL_DisplayFormat is called on the
+surface.
If flag is 0, this function clears
+any current color key.
Return Value
This function returns 0, or
+-1 if there was an error.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcolors.html b/lib/sdl/msvc/docs/html/sdlsetcolors.html
new file mode 100644
index 0000000000000000000000000000000000000000..569564598ba819d7de1415d9e2278ef4c5deec6f
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcolors.html
@@ -0,0 +1,358 @@
+SDL_SetColors
SDL_SetColors -- Sets a portion of the colormap for the given 8-bit surface.
Synopsis
#include "SDL.h"
int SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors);
Description
Sets a portion of the colormap for the given 8-bit surface.
When surface is the surface associated with the current
+display, the display colormap will be updated with the requested colors. If
+SDL_HWPALETTE was set in SDL_SetVideoMode flags,
+SDL_SetColors will always return 1,
+and the palette is guaranteed to be set the way you desire, even if the window
+colormap has to be warped or run under emulation.
The color components of a
+SDL_Color
+structure are 8-bits in size, giving you a total of 2563
+=16777216 colors.
Palettized (8-bit) screen surfaces with the SDL_HWPALETTE
+flag have two palettes, a logical palette that is used for mapping blits
+to/from the surface and a physical palette (that determines how the
+hardware will map the colors to the display). SDL_SetColors
+modifies both palettes (if present), and is equivalent to calling
+SDL_SetPalette with the
+flags set to
+(SDL_LOGPAL | SDL_PHYSPAL).
Return Value
If surface is not a palettized surface, this function
+does nothing, returning 0. If all of the colors were set
+as passed to SDL_SetColors, it will return
+1. If not all the color entries were set exactly as
+given, it will return 0, and you should look at the
+surface palette to determine the actual color palette.
Example
/* Create a display surface with a grayscale palette */
+SDL_Surface *screen;
+SDL_Color colors[256];
+int i;
+.
+.
+.
+/* Fill colors with color information */
+for(i=0;i<256;i++){
+ colors[i].r=i;
+ colors[i].g=i;
+ colors[i].b=i;
+}
+
+/* Create display */
+screen=SDL_SetVideoMode(640, 480, 8, SDL_HWPALETTE);
+if(!screen){
+ printf("Couldn't set video mode: %s\n", SDL_GetError());
+ exit(-1);
+}
+
+/* Set palette */
+SDL_SetColors(screen, colors, 0, 256);
+.
+.
+.
+.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetcursor.html b/lib/sdl/msvc/docs/html/sdlsetcursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..9c5443e53e7f16a94039166cbb15b62cedb45d7b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetcursor.html
@@ -0,0 +1,222 @@
+SDL_SetCursor
SDL_SetCursor -- Set the currently active mouse cursor.
Synopsis
#include "SDL.h"
void SDL_SetCursor(SDL_Cursor *cursor);
Description
Sets the currently active cursor to
+the specified one.
+If the cursor is currently visible, the change will be immediately
+represented on the display.
SDL_SetEventFilter -- Sets up a filter to process all events before they are posted
+to the event queue.
Synopsis
#include "SDL.h"
void SDL_SetEventFilter(SDL_EventFilter filter);
Description
This function sets up a filter to process all events before they are posted
+to the event queue. This is a very powerful and flexible feature. The filter
+is prototyped as:
+
typedef int (*SDL_EventFilter)(const SDL_Event *event);
+If the filter returns 1, then the event will be
+added to the internal queue. If it returns 0,
+then the event will be dropped from the queue. This allows selective
+filtering of dynamically.
There is one caveat when dealing with the SDL_QUITEVENT event type. The
+event filter is only called when the window manager desires to close the
+application window. If the event filter returns 1, then the window will
+be closed, otherwise the window will remain open if possible.
+If the quit event is generated by an interrupt signal, it will bypass the
+internal queue and be delivered to the application at the next event poll.
Note: Events pushed onto the queue with SDL_PushEvent or SDL_PeepEvents do not get passed through the event filter.
Note: Be Careful! The event filter function may run in a different thread so be careful what you do within it.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetgamma.html b/lib/sdl/msvc/docs/html/sdlsetgamma.html
new file mode 100644
index 0000000000000000000000000000000000000000..6443a966a2bad65dc5e5606b57c7687a083663ea
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetgamma.html
@@ -0,0 +1,231 @@
+SDL_SetGamma
SDL_SetGamma -- Sets the color gamma function for the display
Synopsis
#include "SDL.h"
int SDL_SetGamma(float redgamma, float greengamma, float bluegamma);
Description
Sets the "gamma function" for the display of each color component. Gamma
+controls the brightness/contrast of colors displayed on the screen.
+A gamma value of 1.0 is identity (i.e., no adjustment
+is made).
This function adjusts the gamma based on the "gamma function" parameter,
+you can directly specify lookup tables for gamma adjustment with
+SDL_SetGammaRamp.
Not all display hardware is able to change gamma.
Return Value
Returns -1 on error (or if gamma adjustment is not supported).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetgammaramp.html b/lib/sdl/msvc/docs/html/sdlsetgammaramp.html
new file mode 100644
index 0000000000000000000000000000000000000000..79599c8d5163d23aca459656b38a17bda2252dce
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetgammaramp.html
@@ -0,0 +1,230 @@
+SDL_SetGammaRamp
SDL_SetGammaRamp -- Sets the color gamma lookup tables for the display
Synopsis
#include "SDL.h"
int SDL_SetGammaRamp(Uint16 *redtable, Uint16 *greentable, Uint16 *bluetable);
Description
Sets the gamma lookup tables for the display for each color component.
+Each table is an array of 256 Uint16 values, representing a mapping
+between the input and output for that channel. The input is the index
+into the array, and the output is the 16-bit gamma value at that index,
+scaled to the output color precision. You may pass NULL to any of the
+channels to leave them unchanged.
This function adjusts the gamma based on lookup tables, you can also
+have the gamma calculated based on a "gamma function" parameter with
+SDL_SetGamma.
Not all display hardware is able to change gamma.
Return Value
Returns -1 on error (or if gamma adjustment is not supported).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetmodstate.html b/lib/sdl/msvc/docs/html/sdlsetmodstate.html
new file mode 100644
index 0000000000000000000000000000000000000000..ee69a3f5dfeb5a82e4ec382de8f36e1ba0bd661b
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetmodstate.html
@@ -0,0 +1,237 @@
+SDL_SetModState
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetpalette.html b/lib/sdl/msvc/docs/html/sdlsetpalette.html
new file mode 100644
index 0000000000000000000000000000000000000000..1622f1590fb71c118ad5082ba37e0f571316672d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetpalette.html
@@ -0,0 +1,352 @@
+SDL_SetPalette
SDL_SetPalette -- Sets the colors in the palette of an 8-bit surface.
Synopsis
#include "SDL.h"
int SDL_SetPalette(SDL_Surface *surface, int flags, SDL_Color *colors, int firstcolor, int ncolors);
Description
Sets a portion of the palette for the given 8-bit surface.
Palettized (8-bit) screen surfaces with the
+SDL_HWPALETTE flag have two palettes, a logical
+palette that is used for mapping blits to/from the surface and a
+physical palette (that determines how the hardware will map the colors
+to the display). SDL_BlitSurface
+always uses the logical palette when blitting surfaces (if it has to
+convert between surface pixel formats). Because of this, it is often
+useful to modify only one or the other palette to achieve various
+special color effects (e.g., screen fading, color flashes, screen dimming).
This function can modify either the logical or physical palette by
+specifing SDL_LOGPAL or
+SDL_PHYSPALthe in the flags
+parameter.
When surface is the surface associated with the current
+display, the display colormap will be updated with the requested colors. If
+SDL_HWPALETTE was set in SDL_SetVideoMode flags,
+SDL_SetPalette will always return 1,
+and the palette is guaranteed to be set the way you desire, even if the window
+colormap has to be warped or run under emulation.
The color components of a
+SDL_Color structure
+are 8-bits in size, giving you a total of
+2563=16777216 colors.
Return Value
If surface is not a palettized surface, this function
+does nothing, returning 0. If all of the colors were set
+as passed to SDL_SetPalette, it will return
+1. If not all the color entries were set exactly as
+given, it will return 0, and you should look at the
+surface palette to determine the actual color palette.
Example
/* Create a display surface with a grayscale palette */
+ SDL_Surface *screen;
+ SDL_Color colors[256];
+ int i;
+ .
+ .
+ .
+ /* Fill colors with color information */
+ for(i=0;i<256;i++){
+ colors[i].r=i;
+ colors[i].g=i;
+ colors[i].b=i;
+ }
+
+ /* Create display */
+ screen=SDL_SetVideoMode(640, 480, 8, SDL_HWPALETTE);
+ if(!screen){
+ printf("Couldn't set video mode: %s\n", SDL_GetError());
+ exit(-1);
+ }
+
+ /* Set palette */
+ SDL_SetPalette(screen, SDL_LOGPAL|SDL_PHYSPAL, colors, 0, 256);
+ .
+ .
+ .
+ .
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsettimer.html b/lib/sdl/msvc/docs/html/sdlsettimer.html
new file mode 100644
index 0000000000000000000000000000000000000000..40b737ce85345f466591d5c0978d162b274d9601
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsettimer.html
@@ -0,0 +1,267 @@
+SDL_SetTimer
SDL_SetTimer -- Set a callback to run after the specified number of milliseconds has
+elapsed.
Synopsis
#include "SDL.h"
int SDL_SetTimer(Uint32 interval, SDL_TimerCallback callback);
Callback
/* Function prototype for the timer callback function */
+typedef Uint32 (*SDL_TimerCallback)(Uint32 interval);
Description
Set a callback to run after the specified number of milliseconds has
+elapsed. The callback function is passed the current timer interval
+and returns the next timer interval. If the returned value is the
+same as the one passed in, the periodic alarm continues, otherwise a
+new alarm is scheduled.
To cancel a currently running timer, call
+SDL_SetTimer(0, NULL);
The timer callback function may run in a different thread than your
+main constant, and so shouldn't call any functions from within itself.
The maximum resolution of this timer is 10 ms, which means that if
+you request a 16 ms timer, your callback will run approximately 20 ms
+later on an unloaded system. If you wanted to set a flag signaling
+a frame update at 30 frames per second (every 33 ms), you might set a
+timer for 30 ms (see example below).
If you use this function, you need to pass SDL_INIT_TIMER
+to SDL_Init().
Note: This function is kept for compatibility but has been superseded
+by the new timer functions
+SDL_AddTimer and
+SDL_RemoveTimer which support
+multiple timers.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsetvideomode.html b/lib/sdl/msvc/docs/html/sdlsetvideomode.html
new file mode 100644
index 0000000000000000000000000000000000000000..8b309b048f70c7c66bce0ddb4f817e8c1c93cbd6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsetvideomode.html
@@ -0,0 +1,558 @@
+SDL_SetVideoMode
SDL_SetVideoMode -- Set up a video mode with the specified width, height and bits-per-pixel.
Synopsis
#include "SDL.h"
SDL_Surface *SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags);
Description
Set up a video mode with the specified width, height and bits-per-pixel.
If bpp is 0, it is treated as the
+current display bits per pixel.
The flags parameter is the same as the flags field of the SDL_Surface structure. OR'd combinations of the following values are valid.
SDL_SWSURFACE
Create the video surface in system memory
SDL_HWSURFACE
Create the video surface in video memory
SDL_ASYNCBLIT
Enables the use of asynchronous updates of the display surface. This will
+usually slow down blitting on single CPU machines, but may provide a speed
+increase on SMP systems.
SDL_ANYFORMAT
Normally, if a video surface of the requested bits-per-pixel (bpp) is not available, SDL will emulate one with a shadow surface. Passing SDL_ANYFORMAT prevents this and causes SDL to use the video surface, regardless of its pixel depth.
SDL_HWPALETTE
Give SDL exclusive palette access. Without this flag you may not always get the the colors you request with SDL_SetColors or SDL_SetPalette.
SDL_DOUBLEBUF
Enable hardware double buffering; only valid with SDL_HWSURFACE. Calling
+SDL_Flip will flip the
+buffers and update the screen. All drawing will take place on the surface
+that is not displayed at the moment. If double buffering could not be enabled
+then SDL_Flip will just perform a
+SDL_UpdateRect
+on the entire screen.
SDL_FULLSCREEN
SDL will attempt to use a fullscreen mode. If a hardware resolution change is
+not possible (for whatever reason), the next higher resolution will be used and
+the display window centered on a black background.
SDL_OPENGL
Create an OpenGL rendering context. You should have previously set OpenGL video attributes with SDL_GL_SetAttribute.
SDL_OPENGLBLIT
Create an OpenGL rendering context, like above, but allow normal blitting
+operations. The screen (2D) surface may have an alpha channel, and
+SDL_UpdateRects
+must be used for updating changes to the screen surface. NOTE: This option
+is kept for compatibility only, and is not recommended for
+new code.
SDL_RESIZABLE
Create a resizable window. When the window is resized by the user a SDL_VIDEORESIZE event is generated and SDL_SetVideoMode can be called again with the new size.
SDL_NOFRAME
If possible, SDL_NOFRAME causes SDL to create a window with no title bar or frame decoration. Fullscreen modes automatically have this flag set.
Note: Whatever flagsSDL_SetVideoMode could satisfy are set in the flags member of the returned surface.
Note: The bpp parameter is the number of bits per pixel,
+so a bpp of 24 uses the packed representation of
+3 bytes/pixel. For the more common 4 bytes/pixel mode, use a
+bpp of 32. Somewhat oddly, both 15 and 16 will
+request a 2 bytes/pixel mode, but different pixel formats.
Return Value
The framebuffer surface, or NULL if it fails.
+The surface returned is freed by SDL_Quit() and should nt be freed by
+the caller.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlshowcursor.html b/lib/sdl/msvc/docs/html/sdlshowcursor.html
new file mode 100644
index 0000000000000000000000000000000000000000..5a8f19da228eec679077943cb2e65bfc3c9ae13c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlshowcursor.html
@@ -0,0 +1,239 @@
+SDL_ShowCursor
SDL_ShowCursor -- Toggle whether or not the cursor is shown on the screen.
Synopsis
#include "SDL.h"
int SDL_ShowCursor(int toggle);
Description
Toggle whether or not the cursor is shown on the screen. Passing SDL_ENABLE displays the cursor and passing SDL_DISABLE hides it. The current state of the mouse cursor can be queried by passing SDL_QUERY, either SDL_DISABLE or SDL_ENABLE will be returned.
The cursor starts off displayed, but can be turned off.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsurface.html b/lib/sdl/msvc/docs/html/sdlsurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..fda55f173fd01a0bcc6338d8f1b9252a7a758ef6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsurface.html
@@ -0,0 +1,597 @@
+SDL_Surface
SDL_Surface's represent areas of "graphical"
+memory, memory that can be drawn to. The video framebuffer is returned
+as a SDL_Surface by
+SDL_SetVideoMode
+and SDL_GetVideoSurface.
+Most of the fields should be pretty obvious.
+w and h are the
+width and height of the surface in pixels.
+pixels is a pointer to the actual pixel data,
+the surface should be locked
+before accessing this field. The clip_rect field
+is the clipping rectangle as set by
+SDL_SetClipRect.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlsyswmevent.html b/lib/sdl/msvc/docs/html/sdlsyswmevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..fd7180ee218dd425cbd3a9384b69cfddbf708d70
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlsyswmevent.html
@@ -0,0 +1,233 @@
+SDL_SysWMEvent
The system window manager event contains a pointer to system-specific
+information about unknown window manager events. If you enable this event
+using
+SDL_EventState(),
+it will be generated whenever unhandled events are received from the window
+manager. This can be used, for example, to implement cut-and-paste in your
+application.
+
+
+
+If you want to obtain system-specific information about the window manager,
+you can fill the version member of a SDL_SysWMinfo
+structure (details can be found in SDL_syswm.h, which must be included) using the SDL_VERSION() macro found in
+SDL_version.h, and pass it to the
+function:
+
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlthreadid.html b/lib/sdl/msvc/docs/html/sdlthreadid.html
new file mode 100644
index 0000000000000000000000000000000000000000..e0bde2e2a3598786acf965f78d728bbc64a9c95c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlthreadid.html
@@ -0,0 +1,190 @@
+SDL_ThreadID
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlunlockaudio.html b/lib/sdl/msvc/docs/html/sdlunlockaudio.html
new file mode 100644
index 0000000000000000000000000000000000000000..0019bd692a0c956b558fb3ab7743e4485cad20d7
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlunlockaudio.html
@@ -0,0 +1,211 @@
+SDL_UnlockAudio
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlunlocksurface.html b/lib/sdl/msvc/docs/html/sdlunlocksurface.html
new file mode 100644
index 0000000000000000000000000000000000000000..13ba5fc8e2b0e63c316761e6ad038bfbab3e4e7e
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlunlocksurface.html
@@ -0,0 +1,219 @@
+SDL_UnlockSurface
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlunlockyuvoverlay.html b/lib/sdl/msvc/docs/html/sdlunlockyuvoverlay.html
new file mode 100644
index 0000000000000000000000000000000000000000..936ed9eaf7e100ca60d97ffb888e76183718428a
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlunlockyuvoverlay.html
@@ -0,0 +1,225 @@
+SDL_UnlockYUVOverlay
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlupdaterect.html b/lib/sdl/msvc/docs/html/sdlupdaterect.html
new file mode 100644
index 0000000000000000000000000000000000000000..f54d9f5e24366ba24e4ebdf4626a2b2edc95c763
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlupdaterect.html
@@ -0,0 +1,266 @@
+SDL_UpdateRect
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlupdaterects.html b/lib/sdl/msvc/docs/html/sdlupdaterects.html
new file mode 100644
index 0000000000000000000000000000000000000000..0553a7a9d06f35e745e63bb5de3d5e46b6175d19
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlupdaterects.html
@@ -0,0 +1,255 @@
+SDL_UpdateRects
SDL_UpdateRects -- Makes sure the given list of rectangles is updated on the given screen.
Synopsis
#include "SDL.h"
void SDL_UpdateRects(SDL_Surface *screen, int numrects, SDL_Rect *rects);
Description
Makes sure the given list of rectangles is updated on the given screen.
+The rectangles must all be confined within the screen boundaries (no
+clipping is done).
This function should not be called while screen is
+locked.
Note: It is adviced to call this function only once per frame, since each
+call has some processing overhead. This is no restriction since you
+can pass any number of rectangles each time.
The rectangles are not automatically merged or checked for overlap. In
+general, the programmer can use his knowledge about his particular
+rectangles to merge them in an efficient way, to avoid overdraw.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdluserevent.html b/lib/sdl/msvc/docs/html/sdluserevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..178769c51db324e05967f7c5d9987dcb4895ed5c
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdluserevent.html
@@ -0,0 +1,337 @@
+SDL_UserEvent
SDL_UserEvent is in the user member of the structure SDL_Event. This event is unique, it is never created by SDL but only by the user. The event can be pushed onto the event queue using SDL_PushEvent. The contents of the structure members or completely up to the programmer, the only requirement is that type is a value from SDL_USEREVENT to SDL_NUMEVENTS-1 (inclusive).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlvideodrivername.html b/lib/sdl/msvc/docs/html/sdlvideodrivername.html
new file mode 100644
index 0000000000000000000000000000000000000000..141965623f19c9741cd73c9016d076aec76542cc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlvideodrivername.html
@@ -0,0 +1,243 @@
+SDL_VideoDriverName
SDL_VideoDriverName -- Obtain the name of the video driver
Synopsis
#include "SDL.h"
char *SDL_VideoDriverName(char *namebuf, int maxlen);
Description
The buffer pointed to by namebuf is filled up to a maximum of maxlen characters (include the NULL terminator) with the name of the initialised video driver. The driver name is a simple one word identifier like "x11" or "windib".
Return Value
Returns NULL if video has not been initialised with SDL_Init or a pointer to namebuf otherwise.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlvideoinfo.html b/lib/sdl/msvc/docs/html/sdlvideoinfo.html
new file mode 100644
index 0000000000000000000000000000000000000000..3a0da31dadb79a487229e24d6996d4cbc1045c89
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlvideoinfo.html
@@ -0,0 +1,408 @@
+SDL_VideoInfo
This (read-only) structure is returned by SDL_GetVideoInfo. It contains information on either the 'best' available mode (if called before SDL_SetVideoMode) or the current video mode.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlvideomodeok.html b/lib/sdl/msvc/docs/html/sdlvideomodeok.html
new file mode 100644
index 0000000000000000000000000000000000000000..5d2d6c4eb956e9fa3374a1ebfcab5978b6a76a06
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlvideomodeok.html
@@ -0,0 +1,270 @@
+SDL_VideoModeOK
SDL_VideoModeOK -- Check to see if a particular video mode is supported.
Synopsis
#include "SDL.h"
int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
Description
SDL_VideoModeOK returns 0
+if the requested mode is not supported under any bit depth, or returns the
+bits-per-pixel of the closest available mode with the given width, height and requested surface flags (see SDL_SetVideoMode).
The bits-per-pixel value returned is only a suggested mode. You can usually request and bpp you want when setting the video mode and SDL will emulate that color depth with a shadow video surface.
The arguments to SDL_VideoModeOK are the same ones you
+would pass to SDL_SetVideoMode
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwaitevent.html b/lib/sdl/msvc/docs/html/sdlwaitevent.html
new file mode 100644
index 0000000000000000000000000000000000000000..b473d3b06e35cb29b2990a8312822ec97ab75c29
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwaitevent.html
@@ -0,0 +1,231 @@
+SDL_WaitEvent
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwaitthread.html b/lib/sdl/msvc/docs/html/sdlwaitthread.html
new file mode 100644
index 0000000000000000000000000000000000000000..2becfbc47f1ee64b8e8710b403bc29b517253768
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwaitthread.html
@@ -0,0 +1,231 @@
+SDL_WaitThread
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwarpmouse.html b/lib/sdl/msvc/docs/html/sdlwarpmouse.html
new file mode 100644
index 0000000000000000000000000000000000000000..e7b2d8d79f6f5be220afdfaf9dd0dbfe7976ddca
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwarpmouse.html
@@ -0,0 +1,205 @@
+SDL_WarpMouse
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwasinit.html b/lib/sdl/msvc/docs/html/sdlwasinit.html
new file mode 100644
index 0000000000000000000000000000000000000000..b4effeb6800c2a461478863d4dd7ec143e0e92ff
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwasinit.html
@@ -0,0 +1,284 @@
+SDL_WasInit
SDL_WasInit -- Check which subsystems are initialized
Synopsis
#include "SDL.h"
Uint32 SDL_WasInit(Uint32 flags);
Description
SDL_WasInit allows you to see which SDL subsytems have been initialized. flags is a bitwise OR'd combination of the subsystems you wish to check (see SDL_Init for a list of subsystem flags).
Return Value
SDL_WasInit returns a bitwised OR'd combination of the initialized subsystems.
Examples
/* Here are several ways you can use SDL_WasInit() */
+
+/* Get init data on all the subsystems */
+Uint32 subsystem_init;
+
+subsystem_init=SDL_WasInit(SDL_INIT_EVERYTHING);
+
+if(subsystem_init&SDL_INIT_VIDEO)
+ printf("Video is initialized.\n");
+else
+ printf("Video is not initialized.\n");
+
+
+
+/* Just check for one specfic subsystem */
+
+if(SDL_WasInit(SDL_INIT_VIDEO)!=0)
+ printf("Video is initialized.\n");
+else
+ printf("Video is not initialized.\n");
+
+
+
+
+/* Check for two subsystems */
+
+Uint32 subsystem_mask=SDL_INIT_VIDEO|SDL_INIT_AUDIO;
+
+if(SDL_WasInit(subsystem_mask)==subsystem_mask)
+ printf("Video and Audio initialized.\n");
+else
+ printf("Video and Audio not initialized.\n");
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmgetcaption.html b/lib/sdl/msvc/docs/html/sdlwmgetcaption.html
new file mode 100644
index 0000000000000000000000000000000000000000..829c68aaa1632b0dad9cf753f10ee63d6a6ca2bf
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmgetcaption.html
@@ -0,0 +1,222 @@
+SDL_WM_GetCaption
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmgrabinput.html b/lib/sdl/msvc/docs/html/sdlwmgrabinput.html
new file mode 100644
index 0000000000000000000000000000000000000000..740dcd6b29a103573f97f05d6d00a9bdd52f8140
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmgrabinput.html
@@ -0,0 +1,224 @@
+SDL_WM_GrabInput
SDL_WM_GrabInput -- Grabs mouse and keyboard input.
Synopsis
#include "SDL.h"
SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode);
Description
Grabbing means that the mouse is confined to the application window,
+and nearly all keyboard input is passed directly to the application,
+and not interpreted by a window manager, if any.
When mode is SDL_GRAB_QUERY the grab mode is not changed, but the current grab mode is returned.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmiconifywindow.html b/lib/sdl/msvc/docs/html/sdlwmiconifywindow.html
new file mode 100644
index 0000000000000000000000000000000000000000..11136568628006e9aa0c5a64b25b1d57b1825f71
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmiconifywindow.html
@@ -0,0 +1,211 @@
+SDL_WM_IconifyWindow
SDL_WM_IconifyWindow -- Iconify/Minimise the window
Synopsis
#include "SDL.h"
int SDL_WM_IconifyWindow(void);
Description
If the application is running in a window managed environment SDL attempts to iconify/minimise it. If SDL_WM_IconifyWindow is successful, the application will receive a SDL_APPACTIVE loss event.
Return Value
Returns non-zero on success or 0 if iconification is not support or was refused by the window manager.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmsetcaption.html b/lib/sdl/msvc/docs/html/sdlwmsetcaption.html
new file mode 100644
index 0000000000000000000000000000000000000000..bc47c278bdbd8a5c151a3f3a8037e5b90bc82186
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmsetcaption.html
@@ -0,0 +1,212 @@
+SDL_WM_SetCaption
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmseticon.html b/lib/sdl/msvc/docs/html/sdlwmseticon.html
new file mode 100644
index 0000000000000000000000000000000000000000..12eb207c69bd71540a296f1d6dbddedbf2898e57
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmseticon.html
@@ -0,0 +1,260 @@
+SDL_WM_SetIcon
Sets the icon for the display window. Win32 icons must be 32x32.
This function must be called before the first call to
+SDL_SetVideoMode.
The mask is a bitmask that describes the shape of the
+icon. If mask is NULL, then the shape is determined by
+the colorkey of icon, if any, or makes the icon
+rectangular (no transparency) otherwise.
If mask is non-NULL, it points to a bitmap with bits set
+where the corresponding pixel should be visible. The format of the bitmap is as
+follows: Scanlines come in the usual top-down order. Each scanline consists of
+(width / 8) bytes, rounded up. The most significant bit of each byte represents
+the leftmost pixel.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/sdlwmtogglefullscreen.html b/lib/sdl/msvc/docs/html/sdlwmtogglefullscreen.html
new file mode 100644
index 0000000000000000000000000000000000000000..b7973de551d585884f2ad57d38802b4919991bbc
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/sdlwmtogglefullscreen.html
@@ -0,0 +1,205 @@
+SDL_WM_ToggleFullScreen
int SDL_WM_ToggleFullScreen(SDL_Surface *surface);
Description
Toggles the application between windowed and fullscreen mode, if supported. (X11 is the only target currently supported, BeOS support is experimental).
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/thread.html b/lib/sdl/msvc/docs/html/thread.html
new file mode 100644
index 0000000000000000000000000000000000000000..c66018eff237ff05b063bf28a4b4403d527277a6
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/thread.html
@@ -0,0 +1,313 @@
+Multi-threaded Programming
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/time.html b/lib/sdl/msvc/docs/html/time.html
new file mode 100644
index 0000000000000000000000000000000000000000..854b7cb57e9d1764d41166777ceea8e28e1bc121
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/time.html
@@ -0,0 +1,206 @@
+Time
SDL_SetTimer -- Set a callback to run after the specified number of milliseconds has
+elapsed.
SDL provides several cross-platform functions for dealing with time.
+It provides a way to get the current time, a way to wait a little while,
+and a simple timer mechanism. These functions give you two ways of moving an
+object every x milliseconds:
+
+
Use a timer callback function. This may have the bad effect that it runs in a seperate thread or uses alarm signals, but it's easier to implement.
Or you can get the number of milliseconds passed, and move the object if, for example, 30 ms passed.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/video.html b/lib/sdl/msvc/docs/html/video.html
new file mode 100644
index 0000000000000000000000000000000000000000..9b1434e62da948dda0dc5ba808e969ba316ff09d
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/video.html
@@ -0,0 +1,507 @@
+Video
SDL presents a very simple interface to the display framebuffer. The
+framebuffer is represented as an offscreen surface to which you can write
+directly. If you want the screen to show what you have written, call the update function which will
+guarantee that the desired portion of the screen is updated.
Before you call any of the SDL video functions, you must first call
+SDL_Init(SDL_INIT_VIDEO), which initializes the video
+and events in the SDL library. Check the return code, which should be
+0, to see if there were any errors in starting up.
If you use both sound and video in your application, you need to call
+SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO) before opening the
+sound device, otherwise under Win32 DirectX, you won't be able to set
+full-screen display modes.
After you have initialized the library, you can start up the video display in a
+number of ways. The easiest way is to pick a common screen resolution and
+depth and just initialize the video, checking for errors. You will probably
+get what you want, but SDL may be emulating your requested mode and converting
+the display on update. The best way is to
+query, for the best
+video mode closest to the desired one, and then
+convert
+your images to that pixel format.
SDL currently supports any bit depth >= 8 bits per pixel. 8 bpp formats are
+considered 8-bit palettized modes, while 12, 15, 16, 24, and 32 bits per pixel
+are considered "packed pixel" modes, meaning each pixel contains the RGB color
+components packed in the bits of the pixel.
After you have initialized your video mode, you can take the surface that was
+returned, and write to it like any other framebuffer, calling the update
+routine as you go.
When you have finished your video access and are ready to quit your
+application, you should call "SDL_Quit()" to shutdown the
+video and events.
\ No newline at end of file
diff --git a/lib/sdl/msvc/docs/html/wm.html b/lib/sdl/msvc/docs/html/wm.html
new file mode 100644
index 0000000000000000000000000000000000000000..f53a349c1658adb84fa13245387303caf4459b32
--- /dev/null
+++ b/lib/sdl/msvc/docs/html/wm.html
@@ -0,0 +1,188 @@
+Window Management
SDL provides a small set of window management functions which allow applications to change their title and toggle from windowed mode to fullscreen (if available)
+This library is designed to make it easy to write games that run on many
+different platforms using the various native high-performance media interfaces,
+(for video, audio, etc) and presenting a single source-code level API to
+your application. This is a fairly low level API, but using this, completely
+portable applications can be written with a great deal of flexibility.
+
![[separator]](docs/images/rainbow.gif)
+