a14719f1cd
Fixed thread related bug in SoundStream. git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/trunk@1095 4e206d99-4929-0410-ac5d-dfc041789085
394 lines
14 KiB
C++
394 lines
14 KiB
C++
////////////////////////////////////////////////////////////
|
|
//
|
|
// PySFML - Python binding for SFML (Simple and Fast Multimedia Library)
|
|
// Copyright (C) 2007, 2008 Rémi Koenig (remi.k2620@gmail.com)
|
|
//
|
|
// 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 "Window.hpp"
|
|
|
|
#include "Event.hpp"
|
|
#include "VideoMode.hpp"
|
|
#include "Input.hpp"
|
|
#include "WindowSettings.hpp"
|
|
|
|
#include <SFML/Window/WindowStyle.hpp>
|
|
|
|
#include "compat.hpp"
|
|
|
|
|
|
extern PyTypeObject PySfEventType;
|
|
extern PyTypeObject PySfWindowSettingsType;
|
|
extern PyTypeObject PySfVideoModeType;
|
|
|
|
|
|
static void
|
|
PySfWindow_dealloc(PySfWindow* self)
|
|
{
|
|
delete self->obj;
|
|
free_object(self);
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
{
|
|
long Handle;
|
|
PySfWindowSettings *Params=NULL;
|
|
PySfWindow *self;
|
|
self = (PySfWindow *)type->tp_alloc(type, 0);
|
|
if (self != NULL)
|
|
{
|
|
if (PyArg_ParseTuple(args, "l|O!:Window.__new__", &Handle, &PySfWindowSettingsType, &Params))
|
|
{
|
|
if (Params)
|
|
{
|
|
PySfWindowSettingsUpdate(Params);
|
|
self->obj = new sf::Window((sf::WindowHandle)Handle, *(Params->obj));
|
|
}
|
|
else
|
|
self->obj = new sf::Window((sf::WindowHandle)Handle);
|
|
}
|
|
else
|
|
{
|
|
PyErr_Clear();
|
|
self->obj = new sf::Window();
|
|
}
|
|
}
|
|
return (PyObject *)self;
|
|
}
|
|
|
|
|
|
static PyObject*
|
|
PySfWindow_GetEvent(PySfWindow *self, PyObject *args)
|
|
{
|
|
PySfEvent *PyEvent = (PySfEvent *)args;
|
|
|
|
if (! PyObject_TypeCheck(PyEvent, &PySfEventType))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, "Window.GetEvent() Argument is not a sfEvent");
|
|
return NULL;
|
|
}
|
|
|
|
if (self->obj->GetEvent(*(PyEvent->obj)))
|
|
{
|
|
PyEvent->Type = PyEvent->obj->Type;
|
|
PyEvent->Text->Unicode = PyEvent->obj->Text.Unicode;
|
|
PyEvent->Key->Code = PyEvent->obj->Key.Code;
|
|
Py_DECREF(PyEvent->Key->Alt);
|
|
PyEvent->Key->Alt = PyBool_FromLong(PyEvent->obj->Key.Alt);
|
|
Py_DECREF(PyEvent->Key->Control);
|
|
PyEvent->Key->Control = PyBool_FromLong(PyEvent->obj->Key.Control);
|
|
Py_DECREF(PyEvent->Key->Shift);
|
|
PyEvent->Key->Shift = PyBool_FromLong(PyEvent->obj->Key.Shift);
|
|
PyEvent->MouseButton->Button = PyEvent->obj->MouseButton.Button;
|
|
PyEvent->MouseButton->X = PyEvent->obj->MouseButton.X;
|
|
PyEvent->MouseButton->Y = PyEvent->obj->MouseButton.Y;
|
|
PyEvent->MouseMove->X = PyEvent->obj->MouseMove.X;
|
|
PyEvent->MouseMove->Y = PyEvent->obj->MouseMove.Y;
|
|
PyEvent->JoyMove->JoystickId = PyEvent->obj->JoyMove.JoystickId;
|
|
PyEvent->JoyButton->JoystickId = PyEvent->obj->JoyButton.JoystickId;
|
|
PyEvent->JoyButton->Button = PyEvent->obj->JoyButton.Button;
|
|
PyEvent->JoyMove->Axis = PyEvent->obj->JoyMove.Axis;
|
|
PyEvent->JoyMove->Position = PyEvent->obj->JoyMove.Position;
|
|
PyEvent->Size->Width = PyEvent->obj->Size.Width;
|
|
PyEvent->Size->Height = PyEvent->obj->Size.Height;
|
|
PyEvent->MouseWheel->Delta = PyEvent->obj->MouseWheel.Delta;
|
|
Py_RETURN_TRUE;
|
|
}
|
|
else
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
|
|
PyObject*
|
|
PySfWindow_Create(PySfWindow* self, PyObject *args, PyObject *kwds)
|
|
{
|
|
PyObject *VideoModeTmp=NULL;
|
|
sf::VideoMode *VideoMode;
|
|
char *Title=NULL;
|
|
unsigned long WindowStyle = sf::Style::Resize | sf::Style::Close;
|
|
PySfWindowSettings *Params=NULL;
|
|
|
|
const char *kwlist[] = {"VideoMode", "Title", "WindowStyle", "Params", NULL};
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!s|IO!:Window.Create", (char **)kwlist, &PySfVideoModeType, &VideoModeTmp, &Title, &WindowStyle, &PySfWindowSettingsType, &Params))
|
|
return NULL;
|
|
|
|
VideoMode = ((PySfVideoMode *)VideoModeTmp)->obj;
|
|
|
|
if (Params)
|
|
{
|
|
PySfWindowSettingsUpdate(Params);
|
|
self->obj->Create(*VideoMode, Title, WindowStyle, *(Params->obj));
|
|
}
|
|
else
|
|
self->obj->Create(*VideoMode, Title, WindowStyle);
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static int
|
|
PySfWindow_init(PySfWindow *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
long Handle;
|
|
PySfWindowSettings *Params;
|
|
|
|
if (args != NULL)
|
|
{
|
|
if (PyArg_ParseTuple(args, "l|O!:Window.__new__", &Handle, &PySfWindowSettingsType, &Params))
|
|
return 0;
|
|
PyErr_Clear();
|
|
if (PySfWindow_Create(self, args, kwds) == NULL)
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_Close(PySfWindow *self)
|
|
{
|
|
self->obj->Close();
|
|
Py_RETURN_NONE;
|
|
}
|
|
static PyObject *
|
|
PySfWindow_IsOpened(PySfWindow *self)
|
|
{
|
|
return PyBool_FromLong(self->obj->IsOpened());
|
|
}
|
|
static PyObject *
|
|
PySfWindow_GetWidth(PySfWindow *self)
|
|
{
|
|
return PyLong_FromUnsignedLong(self->obj->GetWidth());
|
|
}
|
|
static PyObject *
|
|
PySfWindow_GetHeight(PySfWindow *self)
|
|
{
|
|
return PyLong_FromUnsignedLong(self->obj->GetHeight());
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_UseVerticalSync(PySfWindow *self, PyObject *args)
|
|
{
|
|
self->obj->UseVerticalSync(PyBool_AsBool(args));
|
|
Py_RETURN_NONE;
|
|
}
|
|
static PyObject *
|
|
PySfWindow_ShowMouseCursor(PySfWindow *self, PyObject *args)
|
|
{
|
|
self->obj->ShowMouseCursor(PyBool_AsBool(args));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_SetActive(PySfWindow *self, PyObject *args)
|
|
{
|
|
return PyBool_FromLong(self->obj->SetActive(PyBool_AsBool(args)));
|
|
}
|
|
static PyObject *
|
|
PySfWindow_Display(PySfWindow *self)
|
|
{
|
|
self->obj->Display();
|
|
Py_RETURN_NONE;
|
|
}
|
|
static PyObject *
|
|
PySfWindow_GetFrameTime(PySfWindow *self)
|
|
{
|
|
return PyFloat_FromDouble(self->obj->GetFrameTime());
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_GetInput(PySfWindow *self)
|
|
{
|
|
PySfInput *Input;
|
|
Input = GetNewPySfInput();
|
|
Input->obj = (sf::Input *)&self->obj->GetInput();
|
|
return (PyObject *)Input;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_GetSettings(PySfWindow *self)
|
|
{
|
|
PySfWindowSettings *Settings;
|
|
Settings = GetNewPySfWindowSettings();
|
|
Settings->obj = (sf::WindowSettings *)&self->obj->GetSettings();
|
|
Settings->DepthBits = Settings->obj->DepthBits;
|
|
Settings->StencilBits = Settings->obj->StencilBits;
|
|
Settings->AntialiasingLevel = Settings->obj->AntialiasingLevel;
|
|
return (PyObject *)Settings;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_SetPosition(PySfWindow* self, PyObject *args)
|
|
{
|
|
int Left=0, Top=0;
|
|
if (!PyArg_ParseTuple(args, "ii:Window.SetPosition", &Left, &Top))
|
|
return NULL;
|
|
self->obj->SetPosition(Left,Top);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_SetFramerateLimit(PySfWindow *self, PyObject *args)
|
|
{
|
|
self->obj->SetFramerateLimit(PyLong_AsUnsignedLong(args));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_Show(PySfWindow *self, PyObject *args)
|
|
{
|
|
self->obj->Show(PyBool_AsBool(args));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_EnableKeyRepeat(PySfWindow *self, PyObject *args)
|
|
{
|
|
self->obj->EnableKeyRepeat(PyBool_AsBool(args));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_SetCursorPosition(PySfWindow* self, PyObject *args)
|
|
{
|
|
unsigned int Left=0, Top=0;
|
|
if (!PyArg_ParseTuple(args, "II:Window.SetCursorPosition", &Left, &Top))
|
|
return NULL;
|
|
self->obj->SetCursorPosition(Left,Top);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_SetSize(PySfWindow* self, PyObject *args)
|
|
{
|
|
unsigned int Width=0, Height=0;
|
|
if (!PyArg_ParseTuple(args, "II:Window.SetSize", &Width, &Height))
|
|
return NULL;
|
|
self->obj->SetSize(Width, Height);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_SetJoystickThreshold(PySfWindow* self, PyObject *args)
|
|
{
|
|
self->obj->SetJoystickThreshold(PyFloat_AsDouble(args));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
PySfWindow_SetIcon(PySfWindow* self, PyObject *args)
|
|
{
|
|
unsigned int Width, Height, Size;
|
|
char *Data;
|
|
|
|
if (! PyArg_ParseTuple(args, "IIs#:Window.SetIcon", &Width, &Height, &Data, &Size))
|
|
return NULL;
|
|
|
|
self->obj->SetIcon(Width, Height, (sf::Uint8*) Data);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyMethodDef PySfWindow_methods[] = {
|
|
{"Close", (PyCFunction)PySfWindow_Close, METH_NOARGS, "Close()\nClose (destroy) the window. The sf.Window instance remains valid and you can call Create to recreate the window."},
|
|
{"Create", (PyCFunction)PySfWindow_Create, METH_VARARGS | METH_KEYWORDS, "Create(Mode, Title, sf.Style.Resize | sf.Style.Close, Params = sf.WindowSettings())\n\
|
|
Create a window.\n\
|
|
Mode : Video mode to use (sf.VideoMode instance)\n\
|
|
Title : Title of the window\n\
|
|
WindowStyle : Window style (Resize | Close by default)\n\
|
|
Params : Creation parameters (see default constructor for default values)"},
|
|
{"Display", (PyCFunction)PySfWindow_Display, METH_NOARGS, "Display()\nDisplay the window on screen."},
|
|
{"EnableKeyRepeat", (PyCFunction)PySfWindow_EnableKeyRepeat, METH_O, "EnableKeyRepeat(Enable)\nEnable or disable automatic key-repeat. Automatic key-repeat is enabled by default.\n Enabled : True to enable, false to disable"},
|
|
{"GetEvent", (PyCFunction)PySfWindow_GetEvent, METH_O, "GetEvent(Event)\nGet the event on top of events stack, if any, and pop it. Returns True if an event was returned, False if events stack was empty.\n EventReceived : Event to fill, if any."},
|
|
{"GetFrameTime", (PyCFunction)PySfWindow_GetFrameTime, METH_NOARGS, "GetFrameTime()\nGet time elapsed since last frame. Returns time elapsed, in seconds"},
|
|
{"GetHeight", (PyCFunction)PySfWindow_GetHeight, METH_NOARGS, "GetHeight()\nGet the height of the rendering region of the window."},
|
|
{"GetInput", (PyCFunction)PySfWindow_GetInput, METH_NOARGS, "GetInput()\nGet the input manager of the window."},
|
|
{"GetSettings", (PyCFunction)PySfWindow_GetSettings, METH_NOARGS, "GetSettings()\nGet the creation settings of the window."},
|
|
{"GetWidth", (PyCFunction)PySfWindow_GetWidth, METH_NOARGS, "GetWidth()\nGet the width of the rendering region of the window."},
|
|
{"IsOpened", (PyCFunction)PySfWindow_IsOpened, METH_NOARGS, "IsOpened()\nTell whether or not the window is opened (ie. has been created). Note that a hidden window (Show(False)) will still return True."},
|
|
{"SetActive", (PyCFunction)PySfWindow_SetActive, METH_O, "SetActive(Active)\nActivate of deactivate the window as the current target for rendering. Returns True if operation was successful, False otherwise.\n Active : True to activate, False to deactivate (True by default)"},
|
|
{"SetCursorPosition", (PyCFunction)PySfWindow_SetCursorPosition, METH_VARARGS, "SetCursorPosition(Left, Top)\nChange the position of the mouse cursor.\n Left : Left coordinate of the cursor, relative to the window\n Top : Top coordinate of the cursor, relative to the window"},
|
|
{"SetSize", (PyCFunction)PySfWindow_SetSize, METH_VARARGS, "SetSize(Width, Height)\nChange the size of the rendering region of the window.\n\
|
|
Width : New width\n Height : New height"},
|
|
{"SetFramerateLimit", (PyCFunction)PySfWindow_SetFramerateLimit, METH_O, "SetFramerateLimit(Limit)\nSet the framerate at a fixed frequency.\n Limit : Framerate limit, in frames per seconds (use 0 to disable limit)"},
|
|
{"SetJoystickThreshold", (PyCFunction)PySfWindow_SetJoystickThreshold, METH_O, "SetJoystickThreshold(Threshold)\nChange the joystick threshold, ie. the value below which no move event will be generated.\n Threshold : New threshold, in range [0., 100.]"},
|
|
{"SetPosition", (PyCFunction)PySfWindow_SetPosition, METH_VARARGS, "SetPosition(X, Y)\nChange the position of the window on screen. Only works for top-level windows\n Left : Left position\n Top : Top position"},
|
|
{"Show", (PyCFunction)PySfWindow_Show, METH_O, "Show(State)\nShow or hide the window.\n State : True to show, false to hide."},
|
|
{"ShowMouseCursor", (PyCFunction)PySfWindow_ShowMouseCursor, METH_O, "ShowMouseCursor(Show)\nShow or hide the mouse cursor.\n Show : True to show, false to hide."},
|
|
{"UseVerticalSync", (PyCFunction)PySfWindow_UseVerticalSync, METH_O, "UseVerticalSync(Enabled)\nEnable / disable vertical synchronization.\n Enabled : True to enable v-sync, False to deactivate"},
|
|
{"SetIcon", (PyCFunction)PySfWindow_SetIcon, METH_VARARGS, "SetIcon(Width, Height, Pixels)\n\
|
|
Change the window's icon.\n\
|
|
Width : Icon's width, in pixels\n\
|
|
Height : Icon's height, in pixels\n\
|
|
Pixels : Pointer to the pixels in memory, format must be RGBA 32 bits."},
|
|
{NULL} /* Sentinel */
|
|
};
|
|
|
|
PyTypeObject PySfWindowType = {
|
|
head_init
|
|
"Window", /*tp_name*/
|
|
sizeof(PySfWindow), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
(destructor)PySfWindow_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
0, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash */
|
|
0, /*tp_call*/
|
|
0, /*tp_str*/
|
|
0, /*tp_getattro*/
|
|
0, /*tp_setattro*/
|
|
0, /*tp_as_buffer*/
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
|
|
"sf.Window is a rendering window ; it can create a new window or connect to an existing one.\n\
|
|
Default constructor : sf.Window()\n\
|
|
Construct a new window : sf.Window(Mode, Title, sf.Style.Resize | sf.Style.Close, Params = sf.WindowSettings())\n\
|
|
Mode : Video mode to use (sf.VideoMode instance)\n\
|
|
Title : Title of the window\n\
|
|
WindowStyle : Window style (Resize | Close by default)\n\
|
|
Params : Creation parameters (see default constructor for default values)\n\
|
|
Construct the window from an existing control : sf.Window(Handle, Params)\n\
|
|
Handle : Platform-specific handle of the control\n\
|
|
Params : Creation parameters (see default constructor for default values)", /* tp_doc */
|
|
0, /* tp_traverse */
|
|
0, /* tp_clear */
|
|
0, /* tp_richcompare */
|
|
0, /* tp_weaklistoffset */
|
|
0, /* tp_iter */
|
|
0, /* tp_iternext */
|
|
PySfWindow_methods, /* tp_methods */
|
|
0, /* tp_members */
|
|
0, /* tp_getset */
|
|
0, /* tp_base */
|
|
0, /* tp_dict */
|
|
0, /* tp_descr_get */
|
|
0, /* tp_descr_set */
|
|
0, /* tp_dictoffset */
|
|
(initproc)PySfWindow_init, /* tp_init */
|
|
0, /* tp_alloc */
|
|
PySfWindow_new, /* tp_new */
|
|
};
|
|
|
|
|