Merged SDL2 changes from bartbes/love-experiments/SDL2 into default.

- Added love.system module, including clipboard functions.

- Added custom hardware cursors (love.mouse.newCursor, love.mouse.setCursor.)

- Revamped love.joystick:
-- added Joystick objects and moved love.joystick functions which operated on individual joysticks to methods on the Joystick objects.
-- Added love.joystick.getJoystick and love.joystick.getJoystickCount.
-- Added events for when joysticks are connected and disconnected.
-- Added 'Gamepad' methods to Joystick objects: Joystick:isGamepad, Joystick:getGamepadAxis, and Joystick:isGamepadDown. They're a common abstraction for xbox controller-like joystick across operating systems.

- Added monitor choosing support and "fullscreen desktop" mode to love.window.

- Moved unicode text input events to their own callback function (love.textinput), removed the key repeat functions from love.keyboard and made the second argument of love.keypressed a boolean saying whether the keypress was a repeat.

- liblove now works with love.window and love.graphics in OS X

src/modules/mouse/Cursor.cpp

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "Cursor.h"
+
+namespace love
+{
+namespace mouse
+{
+
+Cursor::~Cursor()
+{
+}
+
+bool Cursor::getConstant(const char *in, SystemCursor &out)
+{
+	return systemCursors.find(in, out);
+}
+
+bool Cursor::getConstant(SystemCursor in, const char *&out)
+{
+	return systemCursors.find(in, out);
+}
+
+bool Cursor::getConstant(const char *in, CursorType &out)
+{
+	return types.find(in, out);
+}
+
+bool Cursor::getConstant(CursorType in, const char *&out)
+{
+	return types.find(in, out);
+}
+
+StringMap<Cursor::SystemCursor, Cursor::CURSOR_MAX_ENUM>::Entry Cursor::systemCursorEntries[] =
+{
+	{"arrow", Cursor::CURSOR_ARROW},
+	{"ibeam", Cursor::CURSOR_IBEAM},
+	{"wait", Cursor::CURSOR_WAIT},
+	{"crosshair", Cursor::CURSOR_CROSSHAIR},
+	{"waitarrow", Cursor::CURSOR_WAITARROW},
+	{"sizenwse", Cursor::CURSOR_SIZENWSE},
+	{"sizenesw", Cursor::CURSOR_SIZENESW},
+	{"sizewe", Cursor::CURSOR_SIZEWE},
+	{"sizens", Cursor::CURSOR_SIZENS},
+	{"sizeall", Cursor::CURSOR_SIZEALL},
+	{"no", Cursor::CURSOR_NO},
+	{"hand", Cursor::CURSOR_HAND},
+};
+
+StringMap<Cursor::SystemCursor, Cursor::CURSOR_MAX_ENUM> Cursor::systemCursors(Cursor::systemCursorEntries, sizeof(Cursor::systemCursorEntries));
+
+StringMap<Cursor::CursorType, Cursor::CURSORTYPE_MAX_ENUM>::Entry Cursor::typeEntries[] =
+{
+	{"system", Cursor::CURSORTYPE_SYSTEM},
+	{"image", Cursor::CURSORTYPE_IMAGE},
+};
+
+StringMap<Cursor::CursorType, Cursor::CURSORTYPE_MAX_ENUM> Cursor::types(Cursor::typeEntries, sizeof(Cursor::typeEntries));
+
+} // mouse
+} // love

src/modules/mouse/Cursor.h

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_MOUSE_CURSOR_H
+#define LOVE_MOUSE_CURSOR_H
+
+// LOVE
+#include "image/ImageData.h"
+#include "common/Object.h"
+#include "common/StringMap.h"
+
+namespace love
+{
+namespace mouse
+{
+
+class Cursor : public Object
+{
+public:
+
+	// Types of system cursors.
+	enum SystemCursor
+	{
+		CURSOR_ARROW,
+		CURSOR_IBEAM,
+		CURSOR_WAIT,
+		CURSOR_CROSSHAIR,
+		CURSOR_WAITARROW,
+		CURSOR_SIZENWSE,
+		CURSOR_SIZENESW,
+		CURSOR_SIZEWE,
+		CURSOR_SIZENS,
+		CURSOR_SIZEALL,
+		CURSOR_NO,
+		CURSOR_HAND,
+		CURSOR_MAX_ENUM
+	};
+
+	enum CursorType
+	{
+		CURSORTYPE_SYSTEM,
+		CURSORTYPE_IMAGE,
+		CURSORTYPE_MAX_ENUM
+	};
+
+	virtual ~Cursor();
+
+	/**
+	 * Returns a pointer to the implementation-dependent handle of this Cursor.
+	 **/
+	virtual void *getHandle() const = 0;
+
+	/**
+	 * Returns whether this Cursor is system-defined or a custom image.
+	 **/
+	virtual CursorType getType() const = 0;
+
+	/**
+	 * Returns the type type of system cursor used, if this Cursor is using a
+	 * system-defined image.
+	 **/
+	virtual SystemCursor getSystemType() const = 0;
+
+	static bool getConstant(const char *in, SystemCursor &out);
+	static bool getConstant(SystemCursor in, const char *&out);
+
+	static bool getConstant(const char *in, CursorType &out);
+	static bool getConstant(CursorType in, const char *&out);
+
+private:
+
+	static StringMap<SystemCursor, CURSOR_MAX_ENUM>::Entry systemCursorEntries[];
+	static StringMap<SystemCursor, CURSOR_MAX_ENUM> systemCursors;
+
+	static StringMap<CursorType, CURSORTYPE_MAX_ENUM>::Entry typeEntries[];
+	static StringMap<CursorType, CURSORTYPE_MAX_ENUM> types;
+
+};
+
+} // mouse
+} // love
+
+#endif // LOVE_MOUSE_CURSOR_H

src/modules/mouse/Mouse.h

@@ -22,8 +22,10 @@
 #define LOVE_MOUSE_MOUSE_H
 
 // LOVE
+#include "Cursor.h"
 #include "common/Module.h"
 #include "common/StringMap.h"
+#include "image/ImageData.h"
 
 namespace love
 {
@@ -49,6 +51,14 @@ public:
 
 	virtual ~Mouse() {};
 
+	virtual Cursor *newCursor(love::image::ImageData *data, int hotx, int hoty) = 0;
+	virtual Cursor *newCursor(Cursor::SystemCursor cursortype) = 0;
+
+	virtual void setCursor(Cursor *cursor) = 0;
+	virtual void setCursor() = 0;
+
+	virtual Cursor *getCursor() const = 0;
+
 	virtual int getX() const = 0;
 	virtual int getY() const = 0;
 	virtual void getPosition(int &x, int &y) const = 0;

src/modules/mouse/sdl/Cursor.cpp

@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+// LOVE
+#include "Cursor.h"
+#include "common/config.h"
+
+namespace love
+{
+namespace mouse
+{
+namespace sdl
+{
+
+Cursor::Cursor(image::ImageData *data, int hotx, int hoty)
+	: cursor(0)
+	, type(CURSORTYPE_IMAGE)
+	, systemType(CURSOR_MAX_ENUM)
+{
+	Uint32 rmask, gmask, bmask, amask;
+#ifdef LOVE_BIG_ENDIAN
+	rmask = 0xFF000000;
+	gmask = 0x00FF0000;
+	bmask = 0x0000FF00;
+	amask = 0x000000FF;
+#else
+	rmask = 0x000000FF;
+	gmask = 0x0000FF00;
+	bmask = 0x00FF0000;
+	amask = 0xFF000000;
+#endif
+
+	int w = data->getWidth();
+	int h = data->getHeight();
+	int pitch = w * 4;
+
+	SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(data->getData(), w, h, 32, pitch, rmask, gmask, bmask, amask);
+	if (!surface)
+		throw love::Exception("Cannot create cursor: out of memory!");
+
+	cursor = SDL_CreateColorCursor(surface, hotx, hoty);
+	SDL_FreeSurface(surface);
+
+	if (!cursor)
+		throw love::Exception("Cannot create cursor: %s", SDL_GetError());
+}
+
+Cursor::Cursor(mouse::Cursor::SystemCursor cursortype)
+	: cursor(0)
+	, type(CURSORTYPE_SYSTEM)
+	, systemType(cursortype)
+{
+	SDL_SystemCursor sdlcursortype;
+
+	if (systemCursors.find(cursortype, sdlcursortype))
+		cursor = SDL_CreateSystemCursor(sdlcursortype);
+	else
+		throw love::Exception("Cannot create system cursor: invalid type.");
+
+	if (!cursor)
+		throw love::Exception("Cannot create system cursor: %s", SDL_GetError());
+}
+
+Cursor::~Cursor()
+{
+	if (cursor)
+		SDL_FreeCursor(cursor);
+}
+
+void *Cursor::getHandle() const
+{
+	return cursor;
+}
+
+Cursor::CursorType Cursor::getType() const
+{
+	return type;
+}
+
+Cursor::SystemCursor Cursor::getSystemType() const
+{
+	return systemType;
+}
+
+EnumMap<Cursor::SystemCursor, SDL_SystemCursor, Cursor::CURSOR_MAX_ENUM>::Entry Cursor::systemCursorEntries[] =
+{
+	{Cursor::CURSOR_ARROW, SDL_SYSTEM_CURSOR_ARROW},
+	{Cursor::CURSOR_IBEAM, SDL_SYSTEM_CURSOR_IBEAM},
+	{Cursor::CURSOR_WAIT, SDL_SYSTEM_CURSOR_WAIT},
+	{Cursor::CURSOR_CROSSHAIR, SDL_SYSTEM_CURSOR_CROSSHAIR},
+	{Cursor::CURSOR_WAITARROW, SDL_SYSTEM_CURSOR_WAITARROW},
+	{Cursor::CURSOR_SIZENWSE, SDL_SYSTEM_CURSOR_SIZENWSE},
+	{Cursor::CURSOR_SIZENESW, SDL_SYSTEM_CURSOR_SIZENESW},
+	{Cursor::CURSOR_SIZEWE, SDL_SYSTEM_CURSOR_SIZEWE},
+	{Cursor::CURSOR_SIZENS, SDL_SYSTEM_CURSOR_SIZENS},
+	{Cursor::CURSOR_SIZEALL, SDL_SYSTEM_CURSOR_SIZEALL},
+	{Cursor::CURSOR_NO, SDL_SYSTEM_CURSOR_NO},
+	{Cursor::CURSOR_HAND, SDL_SYSTEM_CURSOR_HAND},
+};
+
+EnumMap<Cursor::SystemCursor, SDL_SystemCursor, Cursor::CURSOR_MAX_ENUM> Cursor::systemCursors(Cursor::systemCursorEntries, sizeof(Cursor::systemCursorEntries));
+
+} // sdl
+} // mouse
+} // love

src/modules/mouse/sdl/Cursor.h

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_MOUSE_SDL_CURSOR_H
+#define LOVE_MOUSE_SDL_CURSOR_H
+
+// LOVE
+#include "mouse/Cursor.h"
+#include "common/EnumMap.h"
+
+// SDL
+#include <SDL_mouse.h>
+
+namespace love
+{
+namespace mouse
+{
+namespace sdl
+{
+
+class Cursor : public love::mouse::Cursor
+{
+public:
+
+	Cursor(image::ImageData *imageData, int hotx, int hoty);
+	Cursor(SystemCursor cursortype);
+	~Cursor();
+
+	void *getHandle() const;
+	CursorType getType() const;
+	SystemCursor getSystemType() const;
+
+private:
+
+	SDL_Cursor *cursor;
+	CursorType type;
+	SystemCursor systemType;
+
+	static EnumMap<SystemCursor, SDL_SystemCursor, CURSOR_MAX_ENUM>::Entry systemCursorEntries[];
+	static EnumMap<SystemCursor, SDL_SystemCursor, CURSOR_MAX_ENUM> systemCursors;
+};
+
+} // sdl
+} // mouse
+} // love
+
+#endif // LOVE_MOUSE_SDL_CURSOR_H

src/modules/mouse/sdl/Mouse.cpp

@@ -18,10 +18,12 @@
  * 3. This notice may not be removed or altered from any source distribution.
  **/
 
+// LOVE
 #include "Mouse.h"
+#include "window/sdl/Window.h"
 
 // SDL
-#include <SDL.h>
+#include <SDL_mouse.h>
 
 namespace love
 {
@@ -35,6 +37,50 @@ const char *Mouse::getName() const
 	return "love.mouse.sdl";
 }
 
+Mouse::Mouse()
+	: curCursor(0)
+{
+}
+
+Mouse::~Mouse()
+{
+	if (curCursor)
+		setCursor();
+}
+
+love::mouse::Cursor *Mouse::newCursor(love::image::ImageData *data, int hotx, int hoty)
+{
+	return new Cursor(data, hotx, hoty);
+}
+
+love::mouse::Cursor *Mouse::newCursor(love::mouse::Cursor::SystemCursor cursortype)
+{
+	return new Cursor(cursortype);
+}
+
+void Mouse::setCursor(love::mouse::Cursor *cursor)
+{
+	Object::AutoRelease cursorrelease(curCursor);
+
+	curCursor = cursor;
+	curCursor->retain();
+
+	SDL_SetCursor((SDL_Cursor *) cursor->getHandle());
+}
+
+void Mouse::setCursor()
+{
+	Object::AutoRelease cursorrelease(curCursor);
+	curCursor = NULL;
+
+	SDL_SetCursor(SDL_GetDefaultCursor());
+}
+
+love::mouse::Cursor *Mouse::getCursor() const
+{
+	return curCursor;
+}
+
 int Mouse::getX() const
 {
 	int x;
@@ -56,7 +102,13 @@ void Mouse::getPosition(int &x, int &y) const
 
 void Mouse::setPosition(int x, int y)
 {
-	SDL_WarpMouse(x, y);
+	love::window::Window *window = love::window::sdl::Window::getSingleton();
+
+	SDL_Window *handle = NULL;
+	if (window)
+		handle = (SDL_Window *) window->getHandle();
+
+	SDL_WarpMouseInWindow(handle, x, y);
 }
 
 void Mouse::setX(int x)
@@ -91,17 +143,23 @@ bool Mouse::isDown(Button *buttonlist) const
 
 bool Mouse::isVisible() const
 {
-	return (SDL_ShowCursor(SDL_QUERY) == SDL_ENABLE) ? true : false;
+	return SDL_ShowCursor(SDL_QUERY) == SDL_ENABLE;
 }
 
 void Mouse::setGrab(bool grab)
 {
-	SDL_WM_GrabInput(grab ? SDL_GRAB_ON : SDL_GRAB_OFF);
+	love::window::Window *window = love::window::sdl::Window::getSingleton();
+	if (window)
+		window->setMouseGrab(grab);
 }
 
 bool Mouse::isGrabbed() const
 {
-	return (SDL_WM_GrabInput(SDL_GRAB_QUERY) ==  SDL_GRAB_ON ? true : false);
+	love::window::Window *window = love::window::sdl::Window::getSingleton();
+	if (window)
+		return window->isMouseGrabbed();
+	else
+		return false;
 }
 
 } // sdl

src/modules/mouse/sdl/Mouse.h

@@ -23,6 +23,7 @@
 
 // LOVE
 #include "mouse/Mouse.h"
+#include "Cursor.h"
 
 namespace love
 {
@@ -38,6 +39,17 @@ public:
 	// Implements Module.
 	const char *getName() const;
 
+	Mouse();
+	~Mouse();
+
+	love::mouse::Cursor *newCursor(love::image::ImageData *data, int hotx, int hoty);
+	love::mouse::Cursor *newCursor(love::mouse::Cursor::SystemCursor cursortype);
+
+	void setCursor(love::mouse::Cursor *cursor);
+	void setCursor();
+
+	love::mouse::Cursor *getCursor() const;
+
 	int getX() const;
 	int getY() const;
 	void getPosition(int &x, int &y) const;
@@ -49,6 +61,11 @@ public:
 	bool isVisible() const;
 	void setGrab(bool grab);
 	bool isGrabbed() const;
+
+private:
+
+	love::mouse::Cursor *curCursor;
+
 }; // Mouse
 
 } // sdl

src/modules/mouse/wrap_Cursor.cpp

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+// LOVE
+#include "wrap_Cursor.h"
+#include "Cursor.h"
+
+namespace love
+{
+namespace mouse
+{
+
+int w_getType(lua_State *L)
+{
+	mouse::Cursor *cursor = luax_checktype<mouse::Cursor>(L, 1, "Cursor", MOUSE_CURSOR_T);
+
+	Cursor::CursorType ctype = cursor->getType();
+	const char *ctypestr;
+
+	if (!mouse::Cursor::getConstant(ctype, ctypestr))
+		return luaL_error(L, "Unknown cursor type.");
+
+	lua_pushstring(L, ctypestr);
+
+	Cursor::SystemCursor systype = cursor->getSystemType();
+	const char *systypestr;
+
+	if (mouse::Cursor::getConstant(systype, systypestr))
+	{
+		lua_pushstring(L, systypestr);
+		return 2;
+	}
+
+	return 1;
+};
+
+static const luaL_Reg functions[] =
+{
+	{ "getType", w_getType },
+	{ 0, 0 },
+};
+
+extern "C" int luaopen_cursor(lua_State *L)
+{
+	return luax_register_type(L, "Cursor", functions);
+}
+
+} // mouse
+} // love

src/modules/mouse/wrap_Cursor.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_MOUSE_WRAP_CURSOR_H
+#define LOVE_MOUSE_WRAP_CURSOR_H
+
+// LOVE
+#include "common/runtime.h"
+
+namespace love
+{
+namespace mouse
+{
+
+int w_getType(lua_State *L);
+extern "C" int luaopen_cursor(lua_State *L);
+
+} // mouse
+} // love
+
+
+#endif // LOVE_MOUSE_WRAP_CURSOR_H

src/modules/mouse/wrap_Mouse.cpp

@@ -18,12 +18,13 @@
  * 3. This notice may not be removed or altered from any source distribution.
  **/
 
+// LOVE
+#include "wrap_Mouse.h"
+#include "wrap_Cursor.h"
 #include "common/config.h"
 
 #include "sdl/Mouse.h"
 
-#include "wrap_Mouse.h"
-
 namespace love
 {
 namespace mouse
@@ -31,6 +32,78 @@ namespace mouse
 
 static Mouse *instance = 0;
 
+int w_newCursor(lua_State *L)
+{
+	Cursor *cursor = 0;
+
+	if (lua_isstring(L, 1))
+	{
+		// System cursor type.
+		const char *str = luaL_checkstring(L, 1);
+		Cursor::SystemCursor systemCursor;
+
+		if (!Cursor::getConstant(str, systemCursor))
+			return luaL_error(L, "Invalid cursor type %s", str);
+
+		try
+		{
+			cursor = instance->newCursor(systemCursor);
+		}
+		catch (love::Exception &e)
+		{
+			return luaL_error(L, "%s", e.what());
+		}
+	}
+	else
+	{
+		// Custom image.
+		love::image::ImageData *data = luax_checktype<love::image::ImageData>(L, 1, "ImageData", IMAGE_IMAGE_DATA_T);
+		int hotx = luaL_optint(L, 2, 0);
+		int hoty = luaL_optint(L, 3, 0);
+
+		try
+		{
+			cursor = instance->newCursor(data, hotx, hoty);
+		}
+		catch (love::Exception &e)
+		{
+			return luaL_error(L, "%s", e.what());
+		}
+	}
+
+	luax_newtype(L, "Cursor", MOUSE_CURSOR_T, (void *) cursor);
+	return 1;
+}
+
+int w_setCursor(lua_State *L)
+{
+	// Revert to the default system cursor if no argument is given.
+	if (lua_isnoneornil(L, 1))
+	{
+		instance->setCursor();
+		return 0;
+	}
+
+	Cursor *cursor = luax_checktype<Cursor>(L, 1, "Cursor", MOUSE_CURSOR_T);
+	instance->setCursor(cursor);
+	return 0;
+}
+
+int w_getCursor(lua_State *L)
+{
+	Cursor *cursor = instance->getCursor();
+
+	if (cursor)
+	{
+		cursor->retain();
+		luax_newtype(L, "Cursor", MOUSE_CURSOR_T, (void *) cursor);
+	}
+	else
+		lua_pushnil(L);
+
+	return 1;
+}
+
 int w_getX(lua_State *L)
 {
 	lua_pushnumber(L, instance->getX());
@@ -122,6 +195,9 @@ int w_isGrabbed(lua_State *L)
 // List of functions to wrap.
 static const luaL_Reg functions[] =
 {
+	{ "newCursor", w_newCursor },
+	{ "setCursor", w_setCursor },
+	{ "getCursor", w_getCursor },
 	{ "getX", w_getX },
 	{ "getY", w_getY },
 	{ "setX", w_setX },
@@ -136,6 +212,13 @@ static const luaL_Reg functions[] =
 	{ 0, 0 }
 };
 
+// Types for this module.
+static const lua_CFunction types[] =
+{
+	luaopen_cursor,
+	0,
+};
+
 extern "C" int luaopen_love_mouse(lua_State *L)
 {
 	if (instance == 0)
@@ -157,7 +240,7 @@ extern "C" int luaopen_love_mouse(lua_State *L)
 	w.name = "mouse";
 	w.flags = MODULE_T;
 	w.functions = functions;
-	w.types = 0;
+	w.types = types;
 
 	return luax_register_module(L, w);
 }

src/modules/mouse/wrap_Mouse.h

@@ -22,13 +22,17 @@
 #define LOVE_MOUSE_WRAP_MOUSE_H
 
 // LOVE
-#include "Mouse.h"
+#include "common/runtime.h"
+#include "common/config.h"
 
 namespace love
 {
 namespace mouse
 {
 
+int w_newCursor(lua_State *L);
+int w_setCursor(lua_State *L);
+int w_getCursor(lua_State *L);
 int w_getX(lua_State *L);
 int w_getY(lua_State *L);
 int w_getPosition(lua_State *L);