lauchmelder/SFML
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Implemented global inputs (sf::Keyboard, sf::Mouse, sf::Joystick) and removed the event-based sf::Input.

Browse source 
Window::WaitEvent now works with joystick events as well.
Added Event::JoystickConnected and Event::JoystickDisconnected.
Added Window::GetCursorPosition.
This commit is contained in:
Laurent Gomila 2011-07-04 08:21:40 +02:00 • committed by Marco Antognini
parent edf82be16b
commit c850d3b111
48 changed files with 2969 additions and 1517 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/SFML/Graphics/Shader.cpp
View file

@ -257,7 +257,7 @@ void Shader::SetCurrentTexture(const std::string& name)
EnsureGlContext();
// Find the location of the variable in the shader
int myCurrentTexture = glGetUniformLocationARB(myShaderProgram, name.c_str());
myCurrentTexture = glGetUniformLocationARB(myShaderProgram, name.c_str());
if (myCurrentTexture == -1)
Err() << "Texture \"" << name << "\" not found in shader" << std::endl;
}

25
src/SFML/Window/CMakeLists.txt
View file

@ -12,9 +12,16 @@ set(SRC
${INCROOT}/GlResource.hpp
${INCROOT}/ContextSettings.hpp
${INCROOT}/Event.hpp
${SRCROOT}/Input.cpp
${INCROOT}/Input.hpp
${SRCROOT}/Joystick.hpp
${SRCROOT}/InputImpl.hpp
${INCROOT}/Joystick.hpp
${SRCROOT}/Joystick.cpp
${SRCROOT}/JoystickImpl.hpp
${SRCROOT}/JoystickManager.cpp
${SRCROOT}/JoystickManager.hpp
${INCROOT}/Keyboard.hpp
${SRCROOT}/Keyboard.cpp
${INCROOT}/Mouse.hpp
${SRCROOT}/Mouse.cpp
${SRCROOT}/VideoMode.cpp
${INCROOT}/VideoMode.hpp
${SRCROOT}/VideoModeImpl.hpp
@ -32,8 +39,10 @@ if(WINDOWS)
${SRC}
${SRCROOT}/Win32/WglContext.cpp
${SRCROOT}/Win32/WglContext.hpp
${SRCROOT}/Win32/Joystick.cpp
${SRCROOT}/Win32/Joystick.hpp
${SRCROOT}/Win32/InputImpl.cpp
${SRCROOT}/Win32/InputImpl.hpp
${SRCROOT}/Win32/JoystickImpl.cpp
${SRCROOT}/Win32/JoystickImpl.hpp
${SRCROOT}/Win32/VideoModeImpl.cpp
${SRCROOT}/Win32/WindowImplWin32.cpp
${SRCROOT}/Win32/WindowImplWin32.hpp
@ -43,8 +52,10 @@ elseif(LINUX)
${SRC}
${SRCROOT}/Linux/GlxContext.cpp
${SRCROOT}/Linux/GlxContext.hpp
${SRCROOT}/Linux/Joystick.cpp
${SRCROOT}/Linux/Joystick.hpp
${SRCROOT}/Linux/InputImpl.cpp
${SRCROOT}/Linux/InputImpl.hpp
${SRCROOT}/Linux/JoystickImpl.cpp
${SRCROOT}/Linux/JoystickImpl.hpp
${SRCROOT}/Linux/VideoModeImpl.cpp
${SRCROOT}/Linux/WindowImplX11.cpp
${SRCROOT}/Linux/WindowImplX11.hpp

149
src/SFML/Window/Input.cpp
View file

@ -1,149 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Input.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
Input::Input() :
myMouseX(0),
myMouseY(0)
{
ResetStates();
}
////////////////////////////////////////////////////////////
bool Input::IsKeyDown(Key::Code key) const
{
return myKeys[key];
}
////////////////////////////////////////////////////////////
bool Input::IsMouseButtonDown(Mouse::Button button) const
{
return myMouseButtons[button];
}
////////////////////////////////////////////////////////////
bool Input::IsJoystickButtonDown(unsigned int joystick, unsigned int button) const
{
if ((joystick < Joy::Count) && (button < Joy::ButtonCount))
return myJoystickButtons[joystick][button];
else
return false;
}
////////////////////////////////////////////////////////////
int Input::GetMouseX() const
{
return myMouseX;
}
////////////////////////////////////////////////////////////
int Input::GetMouseY() const
{
return myMouseY;
}
////////////////////////////////////////////////////////////
float Input::GetJoystickAxis(unsigned int joystick, Joy::Axis axis) const
{
if (joystick < Joy::Count)
return myJoystickAxis[joystick][axis];
else
return 0.f;
}
////////////////////////////////////////////////////////////
void Input::OnEvent(const Event& event)
{
switch (event.Type)
{
// Key events
case Event::KeyPressed : myKeys[event.Key.Code] = true; break;
case Event::KeyReleased : myKeys[event.Key.Code] = false; break;
// Mouse event
case Event::MouseButtonPressed : myMouseButtons[event.MouseButton.Button] = true; break;
case Event::MouseButtonReleased : myMouseButtons[event.MouseButton.Button] = false; break;
// Mouse move event
case Event::MouseMoved :
myMouseX = event.MouseMove.X;
myMouseY = event.MouseMove.Y;
break;
// Joystick button events
case Event::JoyButtonPressed : myJoystickButtons[event.JoyButton.JoystickId][event.JoyButton.Button] = true; break;
case Event::JoyButtonReleased : myJoystickButtons[event.JoyButton.JoystickId][event.JoyButton.Button] = false; break;
// Joystick move event
case Event::JoyMoved :
myJoystickAxis[event.JoyMove.JoystickId][event.JoyMove.Axis] = event.JoyMove.Position;
break;
// Lost focus event : we must reset all persistent states
case Event::LostFocus :
ResetStates();
break;
default :
break;
}
}
////////////////////////////////////////////////////////////
void Input::ResetStates()
{
for (int i = 0; i < Key::Count; ++i)
myKeys[i] = false;
for (int i = 0; i < Mouse::ButtonCount; ++i)
myMouseButtons[i] = false;
for (int i = 0; i < Joy::Count; ++i)
{
for (int j = 0; j < Joy::ButtonCount; ++j)
myJoystickButtons[i][j] = false;
for (int j = 0; j < Joy::AxisCount; ++j)
myJoystickAxis[i][j] = 0.f;
myJoystickAxis[i][Joy::AxisPOV] = -1.f;
}
}
} // namespace sf

48
src/SFML/Window/InputImpl.hpp Normal file
View file

@ -0,0 +1,48 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_INPUTIMPL_HPP
#define SFML_INPUTIMPL_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#if defined(SFML_SYSTEM_WINDOWS)
#include <SFML/Window/Win32/InputImpl.hpp>
#elif defined(SFML_SYSTEM_LINUX) || defined(SFML_SYSTEM_FREEBSD)
#include <SFML/Window/Linux/InputImpl.hpp>
#elif defined(SFML_SYSTEM_MACOS)
#include <SFML/Window/OSX/InputImpl.hpp>
#endif
#endif // SFML_INPUTIMPL_HPP

75
src/SFML/Window/Joystick.cpp Normal file
View file

@ -0,0 +1,75 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Joystick.hpp>
#include <SFML/Window/JoystickManager.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
bool Joystick::IsConnected(unsigned int joystick)
{
return priv::JoystickManager::GetInstance().GetState(joystick).Connected;
}
////////////////////////////////////////////////////////////
unsigned int Joystick::GetButtonCount(unsigned int joystick)
{
return priv::JoystickManager::GetInstance().GetCapabilities(joystick).ButtonCount;
}
////////////////////////////////////////////////////////////
bool Joystick::HasAxis(unsigned int joystick, Axis axis)
{
return priv::JoystickManager::GetInstance().GetCapabilities(joystick).Axes[axis];
}
////////////////////////////////////////////////////////////
bool Joystick::IsButtonPressed(unsigned int joystick, int button)
{
return priv::JoystickManager::GetInstance().GetState(joystick).Buttons[button];
}
////////////////////////////////////////////////////////////
float Joystick::GetAxisPosition(unsigned int joystick, Axis axis)
{
return priv::JoystickManager::GetInstance().GetState(joystick).Axes[axis];
}
////////////////////////////////////////////////////////////
void Joystick::Update()
{
return priv::JoystickManager::GetInstance().Update();
}
} // namespace sf

95
src/SFML/Window/JoystickImpl.hpp Normal file
View file

@ -0,0 +1,95 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICKIMPL_HPP
#define SFML_JOYSTICKIMPL_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <SFML/Window/Joystick.hpp>
#include <algorithm>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Structure holding a joystick's capabilities
///
////////////////////////////////////////////////////////////
struct JoystickCaps
{
JoystickCaps()
{
ButtonCount = 0;
std::fill(Axes, Axes + Joystick::AxisCount, false);
}
unsigned int ButtonCount; ///< Number of buttons supported by the joystick
bool Axes[Joystick::AxisCount]; ///< Support for each axis
};
////////////////////////////////////////////////////////////
/// \brief Structure holding a joystick's state
///
////////////////////////////////////////////////////////////
struct JoystickState
{
JoystickState()
{
Connected = false;
std::fill(Axes, Axes + Joystick::AxisCount, 0.f);
std::fill(Buttons, Buttons + Joystick::ButtonCount, false);
}
bool Connected; ///< Is the joystick currently connected?
float Axes[Joystick::AxisCount]; ///< Position of each axis, in range [-100, 100]
bool Buttons[Joystick::ButtonCount]; ///< Status of each button (true = pressed)
};
} // namespace priv
} // namespace sf
#if defined(SFML_SYSTEM_WINDOWS)
#include <SFML/Window/Win32/JoystickImpl.hpp>
#elif defined(SFML_SYSTEM_LINUX) || defined(SFML_SYSTEM_FREEBSD)
#include <SFML/Window/Linux/JoystickImpl.hpp>
#elif defined(SFML_SYSTEM_MACOS)
#include <SFML/Window/OSX/JoystickImpl.hpp>
#endif
#endif // SFML_JOYSTICKIMPL_HPP

111
src/SFML/Window/JoystickManager.cpp Normal file
View file

@ -0,0 +1,111 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/JoystickManager.hpp>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
JoystickManager& JoystickManager::GetInstance()
{
static JoystickManager instance;
return instance;
}
////////////////////////////////////////////////////////////
const JoystickCaps& JoystickManager::GetCapabilities(unsigned int joystick) const
{
return myJoysticks[joystick].Capabilities;
}
////////////////////////////////////////////////////////////
const JoystickState& JoystickManager::GetState(unsigned int joystick) const
{
return myJoysticks[joystick].State;
}
////////////////////////////////////////////////////////////
void JoystickManager::Update()
{
for (int i = 0; i < Joystick::Count; ++i)
{
Item& item = myJoysticks[i];
if (item.State.Connected)
{
// Get the current state of the joystick
item.State = item.Joystick.Update();
// Check if it's still connected
if (!item.State.Connected)
{
item.Joystick.Close();
item.Capabilities = JoystickCaps();
item.State = JoystickState();
}
}
else
{
// Check if the joystick was connected since last update
if (JoystickImpl::IsConnected(i))
{
if (item.Joystick.Open(i))
{
item.Capabilities = item.Joystick.GetCapabilities();
item.State = item.Joystick.Update();
}
}
}
}
}
////////////////////////////////////////////////////////////
JoystickManager::JoystickManager()
{
}
////////////////////////////////////////////////////////////
JoystickManager::~JoystickManager()
{
for (int i = 0; i < Joystick::Count; ++i)
{
if (myJoysticks[i].State.Connected)
myJoysticks[i].Joystick.Close();
}
}
} // namespace priv
} // namespace sf

118
src/SFML/Window/JoystickManager.hpp Normal file
View file

@ -0,0 +1,118 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICKMANAGER_HPP
#define SFML_JOYSTICKMANAGER_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Joystick.hpp>
#include <SFML/Window/JoystickImpl.hpp>
#include <SFML/System/NonCopyable.hpp>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Global joystick manager
///
////////////////////////////////////////////////////////////
class JoystickManager : NonCopyable
{
public :
////////////////////////////////////////////////////////////
/// \brief Get the global unique instance of the manager
///
/// \return Unique instance of the joystick manager
///
////////////////////////////////////////////////////////////
static JoystickManager& GetInstance();
////////////////////////////////////////////////////////////
/// \brief Get the capabilities of an open joystick
///
/// \param joystick Index of the joystick
///
/// \return Capabilities of the joystick
///
////////////////////////////////////////////////////////////
const JoystickCaps& GetCapabilities(unsigned int joystick) const;
////////////////////////////////////////////////////////////
/// \brief Get the current state of an open joystick
///
/// \param joystick Index of the joystick
///
/// \return Current state of the joystick
///
////////////////////////////////////////////////////////////
const JoystickState& GetState(unsigned int joystick) const;
////////////////////////////////////////////////////////////
/// \brief Update the state of all the joysticks
///
////////////////////////////////////////////////////////////
void Update();
private:
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
////////////////////////////////////////////////////////////
JoystickManager();
////////////////////////////////////////////////////////////
/// \brief Destructor
///
////////////////////////////////////////////////////////////
~JoystickManager();
////////////////////////////////////////////////////////////
/// \brief Joystick information and state
///
////////////////////////////////////////////////////////////
struct Item
{
JoystickImpl Joystick; ///< Joystick implementation
JoystickState State; ///< The current joystick state
JoystickCaps Capabilities; ///< The joystick capabilities
};
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
Item myJoysticks[Joystick::Count]; ///< Joysticks information and state
};
} // namespace priv
} // namespace sf
#endif // SFML_JOYSTICKMANAGER_HPP

40
src/SFML/Window/Keyboard.cpp Normal file
View file

@ -0,0 +1,40 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Keyboard.hpp>
#include <SFML/Window/InputImpl.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
bool Keyboard::IsKeyPressed(Key key)
{
return priv::InputImpl::IsKeyPressed(key);
}
} // namespace sf

228
src/SFML/Window/Linux/InputImpl.cpp Normal file
View file

@ -0,0 +1,228 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Linux/InputImpl.hpp>
#include <X11/Xlib.h>
#include <X11/keysym.h>
namespace
{
// Open, store and close a X display
struct GlobalDisplay
{
GlobalDisplay()
{
display = XOpenDisplay(NULL);
window = DefaultRootWindow(display);
}
~GlobalDisplay()
{
XCloseDisplay(display);
}
::Display* display;
::Window window;
};
// Global connection with the X server, used in global input functions
GlobalDisplay global;
}
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
bool InputImpl::IsKeyPressed(Keyboard::Key key)
{
// Get the corresponding X11 keysym
KeySym keysym = 0;
switch (key)
{
case Keyboard::A: keysym = XK_A; break;
case Keyboard::B: keysym = XK_B; break;
case Keyboard::C: keysym = XK_C; break;
case Keyboard::D: keysym = XK_D; break;
case Keyboard::E: keysym = XK_E; break;
case Keyboard::F: keysym = XK_F; break;
case Keyboard::G: keysym = XK_G; break;
case Keyboard::H: keysym = XK_H; break;
case Keyboard::I: keysym = XK_I; break;
case Keyboard::J: keysym = XK_J; break;
case Keyboard::K: keysym = XK_K; break;
case Keyboard::L: keysym = XK_L; break;
case Keyboard::M: keysym = XK_M; break;
case Keyboard::N: keysym = XK_N; break;
case Keyboard::O: keysym = XK_O; break;
case Keyboard::P: keysym = XK_P; break;
case Keyboard::Q: keysym = XK_Q; break;
case Keyboard::R: keysym = XK_R; break;
case Keyboard::S: keysym = XK_S; break;
case Keyboard::T: keysym = XK_T; break;
case Keyboard::U: keysym = XK_U; break;
case Keyboard::V: keysym = XK_V; break;
case Keyboard::W: keysym = XK_W; break;
case Keyboard::X: keysym = XK_X; break;
case Keyboard::Y: keysym = XK_Y; break;
case Keyboard::Z: keysym = XK_Z; break;
case Keyboard::Num0: keysym = XK_0; break;
case Keyboard::Num1: keysym = XK_1; break;
case Keyboard::Num2: keysym = XK_2; break;
case Keyboard::Num3: keysym = XK_3; break;
case Keyboard::Num4: keysym = XK_4; break;
case Keyboard::Num5: keysym = XK_5; break;
case Keyboard::Num6: keysym = XK_6; break;
case Keyboard::Num7: keysym = XK_7; break;
case Keyboard::Num8: keysym = XK_8; break;
case Keyboard::Num9: keysym = XK_9; break;
case Keyboard::Escape: keysym = XK_Escape; break;
case Keyboard::LControl: keysym = XK_Control_L; break;
case Keyboard::LShift: keysym = XK_Shift_L; break;
case Keyboard::LAlt: keysym = XK_Alt_L; break;
case Keyboard::LSystem: keysym = XK_Super_L; break;
case Keyboard::RControl: keysym = XK_Control_R; break;
case Keyboard::RShift: keysym = XK_Shift_R; break;
case Keyboard::RAlt: keysym = XK_Alt_R; break;
case Keyboard::RSystem: keysym = XK_Super_R; break;
case Keyboard::Menu: keysym = XK_Menu; break;
case Keyboard::LBracket: keysym = XK_bracketleft; break;
case Keyboard::RBracket: keysym = XK_bracketright; break;
case Keyboard::SemiColon: keysym = XK_semicolon; break;
case Keyboard::Comma: keysym = XK_comma; break;
case Keyboard::Period: keysym = XK_period; break;
case Keyboard::Quote: keysym = XK_dead_acute; break;
case Keyboard::Slash: keysym = XK_slash; break;
case Keyboard::BackSlash: keysym = XK_backslash; break;
case Keyboard::Tilde: keysym = XK_dead_grave; break;
case Keyboard::Equal: keysym = XK_equal; break;
case Keyboard::Dash: keysym = XK_minus; break;
case Keyboard::Space: keysym = XK_space; break;
case Keyboard::Return: keysym = XK_Return; break;
case Keyboard::Back: keysym = XK_BackSpace; break;
case Keyboard::Tab: keysym = XK_Tab; break;
case Keyboard::PageUp: keysym = XK_Prior; break;
case Keyboard::PageDown: keysym = XK_Next; break;
case Keyboard::End: keysym = XK_End; break;
case Keyboard::Home: keysym = XK_Home; break;
case Keyboard::Insert: keysym = XK_Insert; break;
case Keyboard::Delete: keysym = XK_Delete; break;
case Keyboard::Add: keysym = XK_KP_Add; break;
case Keyboard::Subtract: keysym = XK_KP_Subtract; break;
case Keyboard::Multiply: keysym = XK_KP_Multiply; break;
case Keyboard::Divide: keysym = XK_KP_Divide; break;
case Keyboard::Left: keysym = XK_Left; break;
case Keyboard::Right: keysym = XK_Right; break;
case Keyboard::Up: keysym = XK_Up; break;
case Keyboard::Down: keysym = XK_Down; break;
case Keyboard::Numpad0: keysym = XK_KP_0; break;
case Keyboard::Numpad1: keysym = XK_KP_1; break;
case Keyboard::Numpad2: keysym = XK_KP_2; break;
case Keyboard::Numpad3: keysym = XK_KP_3; break;
case Keyboard::Numpad4: keysym = XK_KP_4; break;
case Keyboard::Numpad5: keysym = XK_KP_5; break;
case Keyboard::Numpad6: keysym = XK_KP_6; break;
case Keyboard::Numpad7: keysym = XK_KP_7; break;
case Keyboard::Numpad8: keysym = XK_KP_8; break;
case Keyboard::Numpad9: keysym = XK_KP_9; break;
case Keyboard::F1: keysym = XK_F1; break;
case Keyboard::F2: keysym = XK_F2; break;
case Keyboard::F3: keysym = XK_F3; break;
case Keyboard::F4: keysym = XK_F4; break;
case Keyboard::F5: keysym = XK_F5; break;
case Keyboard::F6: keysym = XK_F6; break;
case Keyboard::F7: keysym = XK_F7; break;
case Keyboard::F8: keysym = XK_F8; break;
case Keyboard::F9: keysym = XK_F9; break;
case Keyboard::F10: keysym = XK_F10; break;
case Keyboard::F11: keysym = XK_F11; break;
case Keyboard::F12: keysym = XK_F12; break;
case Keyboard::F13: keysym = XK_F13; break;
case Keyboard::F14: keysym = XK_F14; break;
case Keyboard::F15: keysym = XK_F15; break;
case Keyboard::Pause: keysym = XK_Pause; break;
}
// Convert to keycode
KeyCode keycode = XKeysymToKeycode(global.display, keysym);
if (keycode != 0)
{
// Get the whole keyboard state
char keys[32];
XQueryKeymap(global.display, keys);
// Check our keycode
return (keys[keycode / 8] & (1 << (keycode % 8))) != 0;
}
return false;
}
////////////////////////////////////////////////////////////
bool InputImpl::IsMouseButtonPressed(Mouse::Button button)
{
// we don't care about these but they are required
::Window root, child;
int wx, wy;
int gx, gy;
unsigned int buttons = 0;
XQueryPointer(global.display, global.window, &root, &child, &gx, &gy, &wx, &wy, &buttons);
switch (button)
{
case Mouse::Left: return buttons & Button1Mask;
case Mouse::Right: return buttons & Button3Mask;
case Mouse::Middle: return buttons & Button2Mask;
case Mouse::XButton1: return false; // not supported by X
case Mouse::XButton2: return false; // not supported by X
}
return false;
}
////////////////////////////////////////////////////////////
Vector2i InputImpl::GetMousePosition()
{
// we don't care about these but they are required
::Window root, child;
int wx, wy;
unsigned int buttons;
int x = 0;
int y = 0;
XQueryPointer(global.display, global.window, &root, &child, &x, &y, &wx, &wy, &buttons);
return Vector2i(x, y);
}
} // namespace priv
} // namespace sf

83
src/SFML/Window/Linux/InputImpl.hpp Normal file
View file

@ -0,0 +1,83 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_INPUTIMPLX11_HPP
#define SFML_INPUTIMPLX11_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Keyboard.hpp>
#include <SFML/Window/Mouse.hpp>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Linux (X11) implementation of inputs (keyboard + mouse)
///
////////////////////////////////////////////////////////////
class InputImpl
{
public :
////////////////////////////////////////////////////////////
/// \brief Check if a key is pressed
///
/// \param key Key to check
///
/// \return True if the key is pressed, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsKeyPressed(Keyboard::Key key);
////////////////////////////////////////////////////////////
/// \brief Check if a mouse button is pressed
///
/// \param button Button to check
///
/// \return True if the button is pressed, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsMouseButtonPressed(Mouse::Button button);
////////////////////////////////////////////////////////////
/// \brief Get the current position of the mouse
///
/// This function returns the mouse position in desktop coordinates.
///
/// \return Current position of the mouse
///
////////////////////////////////////////////////////////////
static Vector2i GetMousePosition();
};
} // namespace priv
} // namespace sf
#endif // SFML_INPUTIMPLX11_HPP

204
src/SFML/Window/Linux/Joystick.cpp
View file

@ -1,204 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Joystick.hpp>
#include <sstream>
namespace sf
{
namespace priv
{
#if defined(SFML_SYSTEM_LINUX)
////////////////////////////////////////////////////////////
void Joystick::Initialize(unsigned int index)
{
// Initial state
myNbButtons = 0;
myPovX = 0;
myPovY = 0;
for (int i = 0; i < Joy::ButtonCount; ++i)
{
myState.Buttons[i] = false;
}
for (int i = 0; i < Joy::AxisCount; ++i)
{
myState.Axis[i] = 0.f;
myAxes[i] = false;
}
// Open the joystick handle
std::ostringstream oss;
oss << "/dev/input/js" << index;
myDescriptor = open(oss.str().c_str(), O_RDONLY);
if (myDescriptor > 0)
{
// Use non-blocking mode
fcntl(myDescriptor, F_SETFL, O_NONBLOCK);
// Get number of buttons
char nbButtons;
ioctl(myDescriptor, JSIOCGBUTTONS, &nbButtons);
myNbButtons = nbButtons;
if (myNbButtons > Joy::ButtonCount)
myNbButtons = Joy::ButtonCount;
// Get the supported axes
char nbAxes;
ioctl(myDescriptor, JSIOCGAXES, &nbAxes);
ioctl(myDescriptor, JSIOCGAXMAP, myAxesMapping);
for (int i = 0; i < nbAxes; ++i)
{
switch (myAxesMapping[i])
{
case ABS_X : myAxes[Joy::AxisX] = true; break;
case ABS_Y : myAxes[Joy::AxisY] = true; break;
case ABS_Z : case ABS_THROTTLE : myAxes[Joy::AxisZ] = true; break;
case ABS_RZ: case ABS_RUDDER: myAxes[Joy::AxisR] = true; break;
case ABS_RX : myAxes[Joy::AxisU] = true; break;
case ABS_RY : myAxes[Joy::AxisV] = true; break;
case ABS_HAT0X : case ABS_HAT0Y : myAxes[Joy::AxisPOV] = true; break;
default : break;
}
}
}
}
////////////////////////////////////////////////////////////
JoystickState Joystick::UpdateState()
{
if (myDescriptor > 0)
{
js_event joyState;
while (read(myDescriptor, &joyState, sizeof(joyState)) > 0)
{
switch (joyState.type & ~JS_EVENT_INIT)
{
// An axis has been moved
case JS_EVENT_AXIS :
{
switch (myAxesMapping[joyState.number])
{
case ABS_X : myState.Axis[Joy::AxisX] = joyState.value * 100.f / 32767.f; break;
case ABS_Y : myState.Axis[Joy::AxisY] = joyState.value * 100.f / 32767.f; break;
case ABS_Z : case ABS_THROTTLE : myState.Axis[Joy::AxisZ] = joyState.value * 100.f / 32767.f; break;
case ABS_RZ: case ABS_RUDDER: myState.Axis[Joy::AxisR] = joyState.value * 100.f / 32767.f; break;
case ABS_RX : myState.Axis[Joy::AxisU] = joyState.value * 100.f / 32767.f; break;
case ABS_RY : myState.Axis[Joy::AxisV] = joyState.value * 100.f / 32767.f; break;
case ABS_HAT0X : myPovX = joyState.value; break;
case ABS_HAT0Y : myPovY = joyState.value; break;
default : break;
}
// Compute the new POV angle
if (myPovX > 0)
{
if (myPovY > 0) myState.Axis[Joy::AxisPOV] = 135.f;
else if (myPovY < 0) myState.Axis[Joy::AxisPOV] = 45.f;
else myState.Axis[Joy::AxisPOV] = 90.f;
}
else if (myPovX < 0)
{
if (myPovY > 0) myState.Axis[Joy::AxisPOV] = 225.f;
else if (myPovY < 0) myState.Axis[Joy::AxisPOV] = 315.f;
else myState.Axis[Joy::AxisPOV] = 270.f;
}
else
{
if (myPovY > 0) myState.Axis[Joy::AxisPOV] = 180.f;
else if (myPovY < 0) myState.Axis[Joy::AxisPOV] = 0.f;
else myState.Axis[Joy::AxisPOV] = -1.f;
}
break;
}
// A button has been pressed
case JS_EVENT_BUTTON :
{
if (joyState.number < GetButtonsCount())
myState.Buttons[joyState.number] = (joyState.value != 0);
break;
}
}
}
}
return myState;
}
////////////////////////////////////////////////////////////
bool Joystick::HasAxis(Joy::Axis Axis) const
{
return myAxes[Axis];
}
////////////////////////////////////////////////////////////
unsigned int Joystick::GetButtonsCount() const
{
return myNbButtons;
}
#elif defined(SFML_SYSTEM_FREEBSD)
////////////////////////////////////////////////////////////
void Joystick::Initialize(unsigned int index)
{
}
////////////////////////////////////////////////////////////
JoystickState Joystick::UpdateState()
{
return JoystickState();
}
////////////////////////////////////////////////////////////
bool Joystick::HasAxis(Joy::Axis Axis) const
{
return false;
}
////////////////////////////////////////////////////////////
unsigned int Joystick::GetButtonsCount() const
{
return 0;
}
#endif // defined(SFML_SYSTEM_FREEBSD)
} // namespace priv
} // namespace sf

168
src/SFML/Window/Linux/JoystickImpl.cpp Normal file
View file

@ -0,0 +1,168 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/JoystickImpl.hpp>
#include <sys/stat.h>
#include <errno.h>
#include <sstream>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
bool JoystickImpl::IsConnected(unsigned int index)
{
std::ostringstream oss;
oss << "/dev/input/js" << index;
struct stat info;
return stat(oss.str().c_str(), &info) == 0;
}
////////////////////////////////////////////////////////////
bool JoystickImpl::Open(unsigned int index)
{
std::ostringstream oss;
oss << "/dev/input/js" << index;
myFile = open(oss.str().c_str(), O_RDONLY);
if (myFile > 0)
{
// Use non-blocking mode
fcntl(myFile, F_SETFL, O_NONBLOCK);
// Retrieve the axes mapping
ioctl(myFile, JSIOCGAXMAP, myMapping);
// Reset the joystick state
myState = JoystickState();
return true;
}
else
{
return false;
}
}
////////////////////////////////////////////////////////////
void JoystickImpl::Close()
{
close(myFile);
}
////////////////////////////////////////////////////////////
JoystickCaps JoystickImpl::GetCapabilities() const
{
JoystickCaps caps;
// Get the number of buttons
char buttonCount;
ioctl(myFile, JSIOCGBUTTONS, &buttonCount);
caps.ButtonCount = buttonCount;
if (caps.ButtonCount > Joystick::ButtonCount)
caps.ButtonCount = Joystick::ButtonCount;
// Get the supported axes
char axesCount;
ioctl(myFile, JSIOCGAXES, &axesCount);
for (int i = 0; i < axesCount; ++i)
{
switch (myMapping[i])
{
case ABS_X : caps.Axes[Joystick::X] = true; break;
case ABS_Y : caps.Axes[Joystick::Y] = true; break;
case ABS_Z :
case ABS_THROTTLE : caps.Axes[Joystick::Z] = true; break;
case ABS_RZ:
case ABS_RUDDER: caps.Axes[Joystick::R] = true; break;
case ABS_RX : caps.Axes[Joystick::U] = true; break;
case ABS_RY : caps.Axes[Joystick::V] = true; break;
case ABS_HAT0X : caps.Axes[Joystick::PovX] = true; break;
case ABS_HAT0Y : caps.Axes[Joystick::PovY] = true; break;
default : break;
}
}
return caps;
}
////////////////////////////////////////////////////////////
JoystickState JoystickImpl::JoystickImpl::Update()
{
// pop events from the joystick file
js_event joyState;
while (read(myFile, &joyState, sizeof(joyState)) > 0)
{
switch (joyState.type & ~JS_EVENT_INIT)
{
// An axis was moved
case JS_EVENT_AXIS :
{
float value = joyState.value * 100.f / 32767.f;
switch (myMapping[joyState.number])
{
case ABS_X : myState.Axes[Joystick::X] = value; break;
case ABS_Y : myState.Axes[Joystick::Y] = value; break;
case ABS_Z :
case ABS_THROTTLE : myState.Axes[Joystick::Z] = value; break;
case ABS_RZ:
case ABS_RUDDER: myState.Axes[Joystick::R] = value; break;
case ABS_RX : myState.Axes[Joystick::U] = value; break;
case ABS_RY : myState.Axes[Joystick::V] = value; break;
case ABS_HAT0X : myState.Axes[Joystick::PovX] = value; break;
case ABS_HAT0Y : myState.Axes[Joystick::PovY] = value; break;
default : break;
}
break;
}
// A button was pressed
case JS_EVENT_BUTTON :
{
if (joyState.number < Joystick::ButtonCount)
myState.Buttons[joyState.number] = (joyState.value != 0);
break;
}
}
}
// Check the connection state of the joystick (read() fails with an error != EGAIN if it's no longer connected)
myState.Connected = (errno == EAGAIN);
return myState;
}
} // namespace priv
} // namespace sf

214
src/SFML/Window/Linux/Joystick.hpp → src/SFML/Window/Linux/JoystickImpl.hpp
View file

@ -1,105 +1,109 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICKLINUX_HPP
#define SFML_JOYSTICKLINUX_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#if defined(SFML_SYSTEM_LINUX)
#include <linux/joystick.h>
#include <fcntl.h>
#elif defined(SFML_SYSTEM_FREEBSD)
// #include <sys/joystick.h> ?
#define ABS_MAX 1
#endif
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Linux implementation of Joystick
///
////////////////////////////////////////////////////////////
class Joystick
{
public :
////////////////////////////////////////////////////////////
/// \brief Initialize the instance and bind it to a physical joystick
///
/// \param index Index of the physical joystick to bind to
///
////////////////////////////////////////////////////////////
void Initialize(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Update the current joystick and return its new state
///
/// \return Current state of the joystick
///
////////////////////////////////////////////////////////////
JoystickState UpdateState();
////////////////////////////////////////////////////////////
/// \brief Check if the joystick supports the given axis
///
/// \param axis Axis to check
///
/// \return True of the axis is supported, false otherwise
///
////////////////////////////////////////////////////////////
bool HasAxis(Joy::Axis Axis) const;
////////////////////////////////////////////////////////////
/// \brief Get the number of buttons supported by the joystick
///
/// \return Number of buttons
///
////////////////////////////////////////////////////////////
unsigned int GetButtonsCount() const;
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
int myDescriptor; ///< Linux descriptor of the joystick
unsigned int myNbButtons; ///< Number of buttons supported by the joystick
bool myAxes[Joy::AxisCount]; ///< Supported axes
JoystickState myState; ///< Current state of the joystick
int myPovX; ///< Last X position of the POV
int myPovY; ///< Last Y position of the POV
char myAxesMapping[ABS_MAX + 1]; ///< Axes mapping (index --> axis id)
};
} // namespace priv
} // namespace sf
#endif // SFML_JOYSTICKLINUX_HPP
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICKIMPLLINUX_HPP
#define SFML_JOYSTICKIMPLLINUX_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#if defined(SFML_SYSTEM_LINUX)
#include <linux/joystick.h>
#include <fcntl.h>
#elif defined(SFML_SYSTEM_FREEBSD)
// #include <sys/joystick.h> ?
#define ABS_MAX 1
#endif
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Linux implementation of joysticks
///
////////////////////////////////////////////////////////////
class JoystickImpl
{
public :
////////////////////////////////////////////////////////////
/// \brief Check if a joystick is currently connected
///
/// \param index Index of the joystick to check
///
/// \return True if the joystick is connected, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsConnected(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Open the joystick
///
/// \param index Index assigned to the joystick
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool Open(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Close the joystick
///
////////////////////////////////////////////////////////////
void Close();
////////////////////////////////////////////////////////////
/// \brief Get the joystick capabilities
///
/// \return Joystick capabilities
///
////////////////////////////////////////////////////////////
JoystickCaps GetCapabilities() const;
////////////////////////////////////////////////////////////
/// \brief Update the joystick and get its new state
///
/// \return Joystick state
///
////////////////////////////////////////////////////////////
JoystickState Update();
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
int myFile; ///< File descriptor of the joystick
char myMapping[ABS_MAX + 1]; ///< Axes mapping (index to axis id)
JoystickState myState; ///< Current state of the joystick
};
} // namespace priv
} // namespace sf
#endif // SFML_JOYSTICKIMPLLINUX_HPP

248
src/SFML/Window/Linux/WindowImplX11.cpp
View file

@ -284,26 +284,12 @@ WindowHandle WindowImplX11::GetSystemHandle() const
////////////////////////////////////////////////////////////
void WindowImplX11::ProcessEvents(bool block)
void WindowImplX11::ProcessEvents()
{
if (block)
XEvent event;
while (XCheckIfEvent(myDisplay, &event, &CheckEvent, reinterpret_cast<XPointer>(myWindow)))
{
// Blocking -- wait and process events in the event queue until a valid event is found
XEvent event;
do
{
XIfEvent(myDisplay, &event, &CheckEvent, reinterpret_cast<XPointer>(myWindow));
}
while (!ProcessEvent(event));
}
else
{
// Non-blocking -- process all events in the event queue
XEvent event;
while (XCheckIfEvent(myDisplay, &event, &CheckEvent, reinterpret_cast<XPointer>(myWindow)))
{
ProcessEvent(event);
}
ProcessEvent(event);
}
}
@ -324,6 +310,22 @@ void WindowImplX11::SetCursorPosition(unsigned int x, unsigned int y)
}
////////////////////////////////////////////////////////////
Vector2i WindowImplX11::GetCursorPosition() const
{
// we don't care about these but they are required
::Window root, child;
int gx, gy;
unsigned int buttons;
int x = 0;
int y = 0;
XQueryPointer(myDisplay, myWindow, &root, &child, &gx, &gy, &x, &y, &buttons);
return Vector2i(x, y);
}
////////////////////////////////////////////////////////////
void WindowImplX11::SetPosition(int x, int y)
{
@ -590,7 +592,7 @@ bool WindowImplX11::ProcessEvent(XEvent windowEvent)
// and we need to properly forward the first one.
char keys[32];
XQueryKeymap(myDisplay, keys);
if (keys[windowEvent.xkey.keycode >> 3] & (1 << (windowEvent.xkey.keycode % 8)))
if (keys[windowEvent.xkey.keycode / 8] & (1 << (windowEvent.xkey.keycode % 8)))
{
// KeyRelease event + key down = repeated event --> discard
if (windowEvent.type == KeyRelease)
@ -847,7 +849,7 @@ bool WindowImplX11::ProcessEvent(XEvent windowEvent)
////////////////////////////////////////////////////////////
Key::Code WindowImplX11::KeysymToSF(KeySym symbol)
Keyboard::Key WindowImplX11::KeysymToSF(KeySym symbol)
{
// First convert to uppercase (to avoid dealing with two different keysyms for the same key)
KeySym lower, key;
@ -855,111 +857,111 @@ Key::Code WindowImplX11::KeysymToSF(KeySym symbol)
switch (key)
{
case XK_Shift_L : return Key::LShift;
case XK_Shift_R : return Key::RShift;
case XK_Control_L : return Key::LControl;
case XK_Control_R : return Key::RControl;
case XK_Alt_L : return Key::LAlt;
case XK_Alt_R : return Key::RAlt;
case XK_Super_L : return Key::LSystem;
case XK_Super_R : return Key::RSystem;
case XK_Menu : return Key::Menu;
case XK_Escape : return Key::Escape;
case XK_semicolon : return Key::SemiColon;
case XK_slash : return Key::Slash;
case XK_equal : return Key::Equal;
case XK_minus : return Key::Dash;
case XK_bracketleft : return Key::LBracket;
case XK_bracketright : return Key::RBracket;
case XK_comma : return Key::Comma;
case XK_period : return Key::Period;
case XK_dead_acute : return Key::Quote;
case XK_backslash : return Key::BackSlash;
case XK_dead_grave : return Key::Tilde;
case XK_space : return Key::Space;
case XK_Return : return Key::Return;
case XK_KP_Enter : return Key::Return;
case XK_BackSpace : return Key::Back;
case XK_Tab : return Key::Tab;
case XK_Prior : return Key::PageUp;
case XK_Next : return Key::PageDown;
case XK_End : return Key::End;
case XK_Home : return Key::Home;
case XK_Insert : return Key::Insert;
case XK_Delete : return Key::Delete;
case XK_KP_Add : return Key::Add;
case XK_KP_Subtract : return Key::Subtract;
case XK_KP_Multiply : return Key::Multiply;
case XK_KP_Divide : return Key::Divide;
case XK_Pause : return Key::Pause;
case XK_F1 : return Key::F1;
case XK_F2 : return Key::F2;
case XK_F3 : return Key::F3;
case XK_F4 : return Key::F4;
case XK_F5 : return Key::F5;
case XK_F6 : return Key::F6;
case XK_F7 : return Key::F7;
case XK_F8 : return Key::F8;
case XK_F9 : return Key::F9;
case XK_F10 : return Key::F10;
case XK_F11 : return Key::F11;
case XK_F12 : return Key::F12;
case XK_F13 : return Key::F13;
case XK_F14 : return Key::F14;
case XK_F15 : return Key::F15;
case XK_Left : return Key::Left;
case XK_Right : return Key::Right;
case XK_Up : return Key::Up;
case XK_Down : return Key::Down;
case XK_KP_0 : return Key::Numpad0;
case XK_KP_1 : return Key::Numpad1;
case XK_KP_2 : return Key::Numpad2;
case XK_KP_3 : return Key::Numpad3;
case XK_KP_4 : return Key::Numpad4;
case XK_KP_5 : return Key::Numpad5;
case XK_KP_6 : return Key::Numpad6;
case XK_KP_7 : return Key::Numpad7;
case XK_KP_8 : return Key::Numpad8;
case XK_KP_9 : return Key::Numpad9;
case XK_A : return Key::A;
case XK_Z : return Key::Z;
case XK_E : return Key::E;
case XK_R : return Key::R;
case XK_T : return Key::T;
case XK_Y : return Key::Y;
case XK_U : return Key::U;
case XK_I : return Key::I;
case XK_O : return Key::O;
case XK_P : return Key::P;
case XK_Q : return Key::Q;
case XK_S : return Key::S;
case XK_D : return Key::D;
case XK_F : return Key::F;
case XK_G : return Key::G;
case XK_H : return Key::H;
case XK_J : return Key::J;
case XK_K : return Key::K;
case XK_L : return Key::L;
case XK_M : return Key::M;
case XK_W : return Key::W;
case XK_X : return Key::X;
case XK_C : return Key::C;
case XK_V : return Key::V;
case XK_B : return Key::B;
case XK_N : return Key::N;
case XK_0 : return Key::Num0;
case XK_1 : return Key::Num1;
case XK_2 : return Key::Num2;
case XK_3 : return Key::Num3;
case XK_4 : return Key::Num4;
case XK_5 : return Key::Num5;
case XK_6 : return Key::Num6;
case XK_7 : return Key::Num7;
case XK_8 : return Key::Num8;
case XK_9 : return Key::Num9;
case XK_Shift_L : return Keyboard::LShift;
case XK_Shift_R : return Keyboard::RShift;
case XK_Control_L : return Keyboard::LControl;
case XK_Control_R : return Keyboard::RControl;
case XK_Alt_L : return Keyboard::LAlt;
case XK_Alt_R : return Keyboard::RAlt;
case XK_Super_L : return Keyboard::LSystem;
case XK_Super_R : return Keyboard::RSystem;
case XK_Menu : return Keyboard::Menu;
case XK_Escape : return Keyboard::Escape;
case XK_semicolon : return Keyboard::SemiColon;
case XK_slash : return Keyboard::Slash;
case XK_equal : return Keyboard::Equal;
case XK_minus : return Keyboard::Dash;
case XK_bracketleft : return Keyboard::LBracket;
case XK_bracketright : return Keyboard::RBracket;
case XK_comma : return Keyboard::Comma;
case XK_period : return Keyboard::Period;
case XK_dead_acute : return Keyboard::Quote;
case XK_backslash : return Keyboard::BackSlash;
case XK_dead_grave : return Keyboard::Tilde;
case XK_space : return Keyboard::Space;
case XK_Return : return Keyboard::Return;
case XK_KP_Enter : return Keyboard::Return;
case XK_BackSpace : return Keyboard::Back;
case XK_Tab : return Keyboard::Tab;
case XK_Prior : return Keyboard::PageUp;
case XK_Next : return Keyboard::PageDown;
case XK_End : return Keyboard::End;
case XK_Home : return Keyboard::Home;
case XK_Insert : return Keyboard::Insert;
case XK_Delete : return Keyboard::Delete;
case XK_KP_Add : return Keyboard::Add;
case XK_KP_Subtract : return Keyboard::Subtract;
case XK_KP_Multiply : return Keyboard::Multiply;
case XK_KP_Divide : return Keyboard::Divide;
case XK_Pause : return Keyboard::Pause;
case XK_F1 : return Keyboard::F1;
case XK_F2 : return Keyboard::F2;
case XK_F3 : return Keyboard::F3;
case XK_F4 : return Keyboard::F4;
case XK_F5 : return Keyboard::F5;
case XK_F6 : return Keyboard::F6;
case XK_F7 : return Keyboard::F7;
case XK_F8 : return Keyboard::F8;
case XK_F9 : return Keyboard::F9;
case XK_F10 : return Keyboard::F10;
case XK_F11 : return Keyboard::F11;
case XK_F12 : return Keyboard::F12;
case XK_F13 : return Keyboard::F13;
case XK_F14 : return Keyboard::F14;
case XK_F15 : return Keyboard::F15;
case XK_Left : return Keyboard::Left;
case XK_Right : return Keyboard::Right;
case XK_Up : return Keyboard::Up;
case XK_Down : return Keyboard::Down;
case XK_KP_0 : return Keyboard::Numpad0;
case XK_KP_1 : return Keyboard::Numpad1;
case XK_KP_2 : return Keyboard::Numpad2;
case XK_KP_3 : return Keyboard::Numpad3;
case XK_KP_4 : return Keyboard::Numpad4;
case XK_KP_5 : return Keyboard::Numpad5;
case XK_KP_6 : return Keyboard::Numpad6;
case XK_KP_7 : return Keyboard::Numpad7;
case XK_KP_8 : return Keyboard::Numpad8;
case XK_KP_9 : return Keyboard::Numpad9;
case XK_A : return Keyboard::A;
case XK_Z : return Keyboard::Z;
case XK_E : return Keyboard::E;
case XK_R : return Keyboard::R;
case XK_T : return Keyboard::T;
case XK_Y : return Keyboard::Y;
case XK_U : return Keyboard::U;
case XK_I : return Keyboard::I;
case XK_O : return Keyboard::O;
case XK_P : return Keyboard::P;
case XK_Q : return Keyboard::Q;
case XK_S : return Keyboard::S;
case XK_D : return Keyboard::D;
case XK_F : return Keyboard::F;
case XK_G : return Keyboard::G;
case XK_H : return Keyboard::H;
case XK_J : return Keyboard::J;
case XK_K : return Keyboard::K;
case XK_L : return Keyboard::L;
case XK_M : return Keyboard::M;
case XK_W : return Keyboard::W;
case XK_X : return Keyboard::X;
case XK_C : return Keyboard::C;
case XK_V : return Keyboard::V;
case XK_B : return Keyboard::B;
case XK_N : return Keyboard::N;
case XK_0 : return Keyboard::Num0;
case XK_1 : return Keyboard::Num1;
case XK_2 : return Keyboard::Num2;
case XK_3 : return Keyboard::Num3;
case XK_4 : return Keyboard::Num4;
case XK_5 : return Keyboard::Num5;
case XK_6 : return Keyboard::Num6;
case XK_7 : return Keyboard::Num7;
case XK_8 : return Keyboard::Num8;
case XK_9 : return Keyboard::Num9;
}
return Key::Code(0);
return Keyboard::Key(0);
}
} // namespace priv

14
src/SFML/Window/Linux/WindowImplX11.hpp
View file

@ -94,10 +94,8 @@ private :
////////////////////////////////////////////////////////////
/// \brief Process incoming events from the operating system
///
/// \param block Use true to block the thread until an event arrives
///
////////////////////////////////////////////////////////////
virtual void ProcessEvents(bool block);
virtual void ProcessEvents();
////////////////////////////////////////////////////////////
/// \brief Show or hide the mouse cursor
@ -116,6 +114,14 @@ private :
////////////////////////////////////////////////////////////
virtual void SetCursorPosition(unsigned int x, unsigned int y);
////////////////////////////////////////////////////////////
/// \brief Get the position of the mouse cursor
///
/// \return Current mouse cursor position, relative to the window
///
////////////////////////////////////////////////////////////
virtual Vector2i GetCursorPosition() const;
////////////////////////////////////////////////////////////
/// \brief Change the position of the window on screen
///
@ -212,7 +218,7 @@ private :
/// \return Corrsponding SFML key code
///
////////////////////////////////////////////////////////////
static Key::Code KeysymToSF(KeySym symbol);
static Keyboard::Key KeysymToSF(KeySym symbol);
////////////////////////////////////////////////////////////
// Member data

58
src/SFML/Window/Mouse.cpp Normal file
View file

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Mouse.hpp>
#include <SFML/Window/InputImpl.hpp>
#include <SFML/Window/Window.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
bool Mouse::IsButtonPressed(Button button)
{
return priv::InputImpl::IsMouseButtonPressed(button);
}
////////////////////////////////////////////////////////////
Vector2i Mouse::GetPosition()
{
const Window* focusWindow = Window::GetMouseFocusWindow();
if (focusWindow)
{
// Position relative to the focus window
return focusWindow->GetCursorPosition();
}
else
{
// Desktop position
return priv::InputImpl::GetMousePosition();
}
}
} // namespace sf

60
src/SFML/Window/OSX/InputImpl.cpp Normal file
View file

@ -0,0 +1,60 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/OSX/InputImpl.hpp>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
bool InputImpl::IsKeyPressed(Keyboard::Key key)
{
// @to be implemented
return false;
}
////////////////////////////////////////////////////////////
bool InputImpl::IsMouseButtonPressed(Mouse::Button button)
{
// @to be implemented
return false;
}
////////////////////////////////////////////////////////////
Vector2i InputImpl::GetMousePosition()
{
// @to be implemented
return Vector2i();
}
} // namespace priv
} // namespace sf

83
src/SFML/Window/OSX/InputImpl.hpp Normal file
View file

@ -0,0 +1,83 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_INPUTIMPLOSX_HPP
#define SFML_INPUTIMPLOSX_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Keyboard.hpp>
#include <SFML/Window/Mouse.hpp>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Mac OS X implementation of inputs (keyboard + mouse)
///
////////////////////////////////////////////////////////////
class InputImpl
{
public :
////////////////////////////////////////////////////////////
/// \brief Check if a key is pressed
///
/// \param key Key to check
///
/// \return True if the key is pressed, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsKeyPressed(Keyboard::Key key);
////////////////////////////////////////////////////////////
/// \brief Check if a mouse button is pressed
///
/// \param button Button to check
///
/// \return True if the button is pressed, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsMouseButtonPressed(Mouse::Button button);
////////////////////////////////////////////////////////////
/// \brief Get the current position of the mouse
///
/// This function returns the mouse position in desktop coordinates.
///
/// \return Current position of the mouse
///
////////////////////////////////////////////////////////////
static Vector2i GetMousePosition();
};
} // namespace priv
} // namespace sf
#endif // SFML_INPUTIMPLOSX_HPP

74
src/SFML/Window/Joystick.hpp → src/SFML/Window/OSX/JoystickImpl.cpp
View file

@ -22,14 +22,10 @@
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICK_HPP
#define SFML_JOYSTICK_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Window/JoystickImpl.hpp>
namespace sf
@ -37,45 +33,43 @@ namespace sf
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Structure holding the joystick state's parameters
///
////////////////////////////////////////////////////////////
struct JoystickState
bool JoystickImpl::IsConnected(unsigned int index)
{
JoystickState()
{
// Default value for axes
for (int i = 0; i < Joy::AxisCount; ++i)
Axis[i] = 0.f;
Axis[Joy::AxisPOV] = -1.f;
// @to be implemented
return false;
}
// Default value for buttons
for (int i = 0; i < Joy::ButtonCount; ++i)
Buttons[i] = false;
}
float Axis[Joy::AxisCount]; ///< Position on each axis in range [-100, 100] (except POV which is [0, 360])
bool Buttons[Joy::ButtonCount]; ///< Status of each button (true = pressed)
};
////////////////////////////////////////////////////////////
bool JoystickImpl::Open(unsigned int index)
{
// @to be implemented
return false;
}
////////////////////////////////////////////////////////////
void JoystickImpl::Close()
{
// @to be implemented
}
////////////////////////////////////////////////////////////
JoystickCaps JoystickImpl::GetCapabilities() const
{
// @to be implemented
return JoystickCaps();
}
////////////////////////////////////////////////////////////
JoystickState JoystickImpl::Update()
{
// @to be implemented
return JoystickState();
}
} // namespace priv
} // namespace sf
#if defined(SFML_SYSTEM_WINDOWS)
#include <SFML/Window/Win32/Joystick.hpp>
#elif defined(SFML_SYSTEM_LINUX) || defined(SFML_SYSTEM_FREEBSD)
#include <SFML/Window/Linux/Joystick.hpp>
#elif defined(SFML_SYSTEM_MACOS)
#include <SFML/Window/OSX/Joystick.hpp>
#endif
#endif // SFML_JOYSTICK_HPP

196
src/SFML/Window/Win32/Joystick.hpp → src/SFML/Window/OSX/JoystickImpl.hpp
View file

@ -1,96 +1,100 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICKWIN32_HPP
#define SFML_JOYSTICKWIN32_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Windows implementation of Joystick
///
////////////////////////////////////////////////////////////
class Joystick
{
public :
////////////////////////////////////////////////////////////
/// \brief Initialize the instance and bind it to a physical joystick
///
/// \param index Index of the physical joystick to bind to
///
////////////////////////////////////////////////////////////
void Initialize(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Update the current joystick and return its new state
///
/// \return Current state of the joystick
///
////////////////////////////////////////////////////////////
JoystickState UpdateState();
////////////////////////////////////////////////////////////
/// \brief Check if the joystick supports the given axis
///
/// \param Axis : Axis to check
///
/// \return True of the axis is supported, false otherwise
///
////////////////////////////////////////////////////////////
bool HasAxis(Joy::Axis Axis) const;
////////////////////////////////////////////////////////////
/// \brief Get the number of buttons supported by the joystick
///
/// \return Number of buttons
///
////////////////////////////////////////////////////////////
unsigned int GetButtonsCount() const;
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
bool myIsConnected; ///< Is there a joystick connected?
unsigned int myIndex; ///< Windows ID of the joystick
unsigned int myNbButtons; ///< Number of buttons supported by the joystick
bool myAxes[Joy::AxisCount]; ///< Supported axes
bool myHasContinuousPOV; ///< True if the driver supports continuous values for the POV
};
} // namespace priv
} // namespace sf
#endif // SFML_JOYSTICKWIN32_HPP
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICKIMPLOSX_HPP
#define SFML_JOYSTICKIMPLOSX_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/JoystickImpl.hpp>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Mac OS X implementation of joysticks
///
////////////////////////////////////////////////////////////
class JoystickImpl
{
public :
////////////////////////////////////////////////////////////
/// \brief Check if a joystick is currently connected
///
/// \param index Index of the joystick to check
///
/// \return True if the joystick is connected, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsConnected(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Open the joystick
///
/// \param index Index assigned to the joystick
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool Open(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Close the joystick
///
////////////////////////////////////////////////////////////
void Close();
////////////////////////////////////////////////////////////
/// \brief Get the joystick capabilities
///
/// \return Joystick capabilities
///
////////////////////////////////////////////////////////////
JoystickCaps GetCapabilities() const;
////////////////////////////////////////////////////////////
/// \brief Update the joystick and get its new state
///
/// \return Joystick state
///
////////////////////////////////////////////////////////////
JoystickState Update();
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
};
} // namespace priv
} // namespace sf
#endif // SFML_JOYSTICKIMPLOSX_HPP

4
src/SFML/Window/OSX/SFApplication.h
View file

@ -38,9 +38,7 @@
////////////////////////////////////////////////////////////
/// \brief Event processing
///
/// \param block blocking mode means at least one event is proccessed.
///
////////////////////////////////////////////////////////////
+(void)processEventWithBlockingMode:(BOOL)block;
+(void)processEvent
@end

11
src/SFML/Window/OSX/SFApplication.m
View file

@ -35,20 +35,11 @@
////////////////////////////////////////////////////////////
+(void)processEventWithBlockingMode:(BOOL)block
+(void)processEvent
{
[NSApplication sharedApplication]; // Make sure NSApp exists
NSEvent* event = nil;
if (block) { // At least one event is read.
event = [NSApp nextEventMatchingMask:NSAnyEventMask
untilDate:[NSDate distantFuture]
inMode:NSDefaultRunLoopMode
dequeue:YES]; // Remove the event from the dequeue
[NSApp sendEvent:event];
}
// If there are some other event read them.
while ((event = [NSApp nextEventMatchingMask:NSAnyEventMask
untilDate:[NSDate distantPast]
inMode:NSDefaultRunLoopMode

4
src/SFML/Window/OSX/SFWindowController.mm
View file

@ -404,7 +404,7 @@
////////////////////////////////////////////////////////
-(void)processEventWithBlockingMode:(BOOL)block
-(void)processEvent
{
// If we are not on the main thread we stop here and advice the user.
if ([NSThread currentThread] != [NSThread mainThread]) {
@ -421,7 +421,7 @@
// If we don't have a requester we don't fetch event.
if (myRequester != 0) {
[SFApplication processEventWithBlockingMode:block];
[SFApplication processEvent];
}
}

13
src/SFML/Window/OSX/WindowImplCocoa.hpp
View file

@ -233,13 +233,12 @@ public:
static void SetUpProcess(void);
private:
////////////////////////////////////////////////////////////
/// \brief Process incoming events from the operating system
///
/// \param block Use true to block the thread until an event arrives
///
////////////////////////////////////////////////////////////
virtual void ProcessEvents(bool block);
virtual void ProcessEvents();
////////////////////////////////////////////////////////////
/// \brief Get the OS-specific handle of the window
@ -266,6 +265,14 @@ private:
////////////////////////////////////////////////////////////
virtual void SetCursorPosition(unsigned int x, unsigned int y);
////////////////////////////////////////////////////////////
/// \brief Get the position of the mouse cursor
///
/// \return Current mouse cursor position, relative to the window
///
////////////////////////////////////////////////////////////
virtual Vector2i GetCursorPosition() const;
////////////////////////////////////////////////////////////
/// \brief Change the position of the window on screen
///

12
src/SFML/Window/OSX/WindowImplCocoa.mm
View file

@ -312,9 +312,9 @@ void WindowImplCocoa::TextEntered(unichar charcode)
#pragma mark WindowImplCocoa's event-related methods
////////////////////////////////////////////////////////////
void WindowImplCocoa::ProcessEvents(bool block)
void WindowImplCocoa::ProcessEvents()
{
[myDelegate processEventWithBlockingMode:(block ? YES : NO)];
[myDelegate processEvent];
}
#pragma mark
@ -344,6 +344,14 @@ void WindowImplCocoa::SetCursorPosition(unsigned int x, unsigned int y)
[myDelegate setCursorPositionToX:x Y:y];
}
////////////////////////////////////////////////////////////
Vector2i WindowImplCocoa::GetCursorPosition() const
{
// @to be implemented
return Vector2i();
}
////////////////////////////////////////////////////////////
void WindowImplCocoa::SetPosition(int x, int y)

179
src/SFML/Window/Win32/InputImpl.cpp Normal file
View file

@ -0,0 +1,179 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#define _WIN32_WINDOWS 0x0501
#define _WIN32_WINNT 0x0501
#include <SFML/Window/Win32/InputImpl.hpp>
#include <windows.h>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
bool InputImpl::IsKeyPressed(Keyboard::Key key)
{
int vkey = 0;
switch (key)
{
case Keyboard::A: vkey = 'A'; break;
case Keyboard::B: vkey = 'B'; break;
case Keyboard::C: vkey = 'C'; break;
case Keyboard::D: vkey = 'D'; break;
case Keyboard::E: vkey = 'E'; break;
case Keyboard::F: vkey = 'F'; break;
case Keyboard::G: vkey = 'G'; break;
case Keyboard::H: vkey = 'H'; break;
case Keyboard::I: vkey = 'I'; break;
case Keyboard::J: vkey = 'J'; break;
case Keyboard::K: vkey = 'K'; break;
case Keyboard::L: vkey = 'L'; break;
case Keyboard::M: vkey = 'M'; break;
case Keyboard::N: vkey = 'N'; break;
case Keyboard::O: vkey = 'O'; break;
case Keyboard::P: vkey = 'P'; break;
case Keyboard::Q: vkey = 'Q'; break;
case Keyboard::R: vkey = 'R'; break;
case Keyboard::S: vkey = 'S'; break;
case Keyboard::T: vkey = 'T'; break;
case Keyboard::U: vkey = 'U'; break;
case Keyboard::V: vkey = 'V'; break;
case Keyboard::W: vkey = 'W'; break;
case Keyboard::X: vkey = 'X'; break;
case Keyboard::Y: vkey = 'Y'; break;
case Keyboard::Z: vkey = 'Z'; break;
case Keyboard::Num0: vkey = '0'; break;
case Keyboard::Num1: vkey = '1'; break;
case Keyboard::Num2: vkey = '2'; break;
case Keyboard::Num3: vkey = '3'; break;
case Keyboard::Num4: vkey = '4'; break;
case Keyboard::Num5: vkey = '5'; break;
case Keyboard::Num6: vkey = '6'; break;
case Keyboard::Num7: vkey = '7'; break;
case Keyboard::Num8: vkey = '8'; break;
case Keyboard::Num9: vkey = '9'; break;
case Keyboard::Escape: vkey = VK_ESCAPE; break;
case Keyboard::LControl: vkey = VK_LCONTROL; break;
case Keyboard::LShift: vkey = VK_LSHIFT; break;
case Keyboard::LAlt: vkey = VK_LMENU; break;
case Keyboard::LSystem: vkey = VK_LWIN; break;
case Keyboard::RControl: vkey = VK_RCONTROL; break;
case Keyboard::RShift: vkey = VK_RSHIFT; break;
case Keyboard::RAlt: vkey = VK_RMENU; break;
case Keyboard::RSystem: vkey = VK_RWIN; break;
case Keyboard::Menu: vkey = VK_APPS; break;
case Keyboard::LBracket: vkey = VK_OEM_4; break;
case Keyboard::RBracket: vkey = VK_OEM_6; break;
case Keyboard::SemiColon: vkey = VK_OEM_1; break;
case Keyboard::Comma: vkey = VK_OEM_COMMA; break;
case Keyboard::Period: vkey = VK_OEM_PERIOD; break;
case Keyboard::Quote: vkey = VK_OEM_7; break;
case Keyboard::Slash: vkey = VK_OEM_2; break;
case Keyboard::BackSlash: vkey = VK_OEM_5; break;
case Keyboard::Tilde: vkey = VK_OEM_3; break;
case Keyboard::Equal: vkey = VK_OEM_PLUS; break;
case Keyboard::Dash: vkey = VK_OEM_MINUS; break;
case Keyboard::Space: vkey = VK_SPACE; break;
case Keyboard::Return: vkey = VK_RETURN; break;
case Keyboard::Back: vkey = VK_BACK; break;
case Keyboard::Tab: vkey = VK_TAB; break;
case Keyboard::PageUp: vkey = VK_PRIOR; break;
case Keyboard::PageDown: vkey = VK_NEXT; break;
case Keyboard::End: vkey = VK_END; break;
case Keyboard::Home: vkey = VK_HOME; break;
case Keyboard::Insert: vkey = VK_INSERT; break;
case Keyboard::Delete: vkey = VK_DELETE; break;
case Keyboard::Add: vkey = VK_ADD; break;
case Keyboard::Subtract: vkey = VK_SUBTRACT; break;
case Keyboard::Multiply: vkey = VK_MULTIPLY; break;
case Keyboard::Divide: vkey = VK_DIVIDE; break;
case Keyboard::Left: vkey = VK_LEFT; break;
case Keyboard::Right: vkey = VK_RIGHT; break;
case Keyboard::Up: vkey = VK_UP; break;
case Keyboard::Down: vkey = VK_DOWN; break;
case Keyboard::Numpad0: vkey = VK_NUMPAD0; break;
case Keyboard::Numpad1: vkey = VK_NUMPAD1; break;
case Keyboard::Numpad2: vkey = VK_NUMPAD2; break;
case Keyboard::Numpad3: vkey = VK_NUMPAD3; break;
case Keyboard::Numpad4: vkey = VK_NUMPAD4; break;
case Keyboard::Numpad5: vkey = VK_NUMPAD5; break;
case Keyboard::Numpad6: vkey = VK_NUMPAD6; break;
case Keyboard::Numpad7: vkey = VK_NUMPAD7; break;
case Keyboard::Numpad8: vkey = VK_NUMPAD8; break;
case Keyboard::Numpad9: vkey = VK_NUMPAD9; break;
case Keyboard::F1: vkey = VK_F1; break;
case Keyboard::F2: vkey = VK_F2; break;
case Keyboard::F3: vkey = VK_F3; break;
case Keyboard::F4: vkey = VK_F4; break;
case Keyboard::F5: vkey = VK_F5; break;
case Keyboard::F6: vkey = VK_F6; break;
case Keyboard::F7: vkey = VK_F7; break;
case Keyboard::F8: vkey = VK_F8; break;
case Keyboard::F9: vkey = VK_F9; break;
case Keyboard::F10: vkey = VK_F10; break;
case Keyboard::F11: vkey = VK_F11; break;
case Keyboard::F12: vkey = VK_F12; break;
case Keyboard::F13: vkey = VK_F13; break;
case Keyboard::F14: vkey = VK_F14; break;
case Keyboard::F15: vkey = VK_F16; break;
case Keyboard::Pause: vkey = VK_PAUSE; break;
}
return GetAsyncKeyState(vkey) != 0;
}
////////////////////////////////////////////////////////////
bool InputImpl::IsMouseButtonPressed(Mouse::Button button)
{
int vkey = 0;
switch (button)
{
case Mouse::Left: vkey = VK_LBUTTON; break;
case Mouse::Right: vkey = VK_RBUTTON; break;
case Mouse::Middle: vkey = VK_MBUTTON; break;
case Mouse::XButton1: vkey = VK_XBUTTON1; break;
case Mouse::XButton2: vkey = VK_XBUTTON2; break;
}
return GetAsyncKeyState(vkey) != 0;
}
////////////////////////////////////////////////////////////
Vector2i InputImpl::GetMousePosition()
{
POINT position;
GetCursorPos(&position);
return Vector2i(position.x, position.y);
}
} // namespace priv
} // namespace sf

83
src/SFML/Window/Win32/InputImpl.hpp Normal file
View file

@ -0,0 +1,83 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_INPUTIMPLWIN32_HPP
#define SFML_INPUTIMPLWIN32_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Keyboard.hpp>
#include <SFML/Window/Mouse.hpp>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Windows implementation of inputs (keyboard + mouse)
///
////////////////////////////////////////////////////////////
class InputImpl
{
public :
////////////////////////////////////////////////////////////
/// \brief Check if a key is pressed
///
/// \param key Key to check
///
/// \return True if the key is pressed, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsKeyPressed(Keyboard::Key key);
////////////////////////////////////////////////////////////
/// \brief Check if a mouse button is pressed
///
/// \param button Button to check
///
/// \return True if the button is pressed, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsMouseButtonPressed(Mouse::Button button);
////////////////////////////////////////////////////////////
/// \brief Get the current position of the mouse
///
/// This function returns the mouse position in desktop coordinates.
///
/// \return Current position of the mouse
///
////////////////////////////////////////////////////////////
static Vector2i GetMousePosition();
};
} // namespace priv
} // namespace sf
#endif // SFML_INPUTIMPLWIN32_HPP

149
src/SFML/Window/Win32/Joystick.cpp
View file

@ -1,149 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#define _WIN32_WINDOWS 0x0501
#define _WIN32_WINNT 0x0501
#include <SFML/Window/Joystick.hpp>
#include <windows.h>
#include <mmsystem.h>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
void Joystick::Initialize(unsigned int index)
{
// Reset state
myIndex = JOYSTICKID1;
myNbButtons = 0;
myIsConnected = false;
myHasContinuousPOV = false;
for (int i = 0; i < Joy::AxisCount; ++i)
myAxes[i] = false;
// Get the Index-th connected joystick
MMRESULT error;
JOYINFOEX joyInfos;
joyInfos.dwSize = sizeof(joyInfos);
joyInfos.dwFlags = JOY_RETURNALL;
for (unsigned int found = 0; (error = joyGetPosEx(myIndex, &joyInfos)) != JOYERR_PARMS; myIndex++)
{
// Check if the current joystick is connected
if (error == JOYERR_NOERROR)
{
// Check if it's the required index
if (found == index)
{
// Ok : store its parameters and return
myIsConnected = true;
JOYCAPS caps;
joyGetDevCaps(myIndex, &caps, sizeof(caps));
myNbButtons = caps.wNumButtons;
if (myNbButtons > Joy::ButtonCount)
myNbButtons = Joy::ButtonCount;
myAxes[Joy::AxisX] = true;
myAxes[Joy::AxisY] = true;
myAxes[Joy::AxisZ] = (caps.wCaps & JOYCAPS_HASZ) != 0;
myAxes[Joy::AxisR] = (caps.wCaps & JOYCAPS_HASR) != 0;
myAxes[Joy::AxisU] = (caps.wCaps & JOYCAPS_HASU) != 0;
myAxes[Joy::AxisV] = (caps.wCaps & JOYCAPS_HASV) != 0;
myAxes[Joy::AxisPOV] = (caps.wCaps & JOYCAPS_HASPOV) != 0;
myHasContinuousPOV = (caps.wCaps & JOYCAPS_POVCTS) != 0;
return;
}
// Go to the next valid joystick
++found;
}
}
}
////////////////////////////////////////////////////////////
JoystickState Joystick::UpdateState()
{
JoystickState state;
if (myIsConnected)
{
// Get the joystick caps (for range conversions)
JOYCAPS caps;
if (joyGetDevCaps(myIndex, &caps, sizeof(caps)) == JOYERR_NOERROR)
{
// Get the current joystick state
JOYINFOEX pos;
pos.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNR | JOY_RETURNU | JOY_RETURNV | JOY_RETURNBUTTONS;
pos.dwFlags |= myHasContinuousPOV ? JOY_RETURNPOVCTS : JOY_RETURNPOV;
pos.dwSize = sizeof(JOYINFOEX);
if (joyGetPosEx(myIndex, &pos) == JOYERR_NOERROR)
{
// Axes
state.Axis[Joy::AxisX] = (pos.dwXpos - (caps.wXmax + caps.wXmin) / 2.f) * 200.f / (caps.wXmax - caps.wXmin);
state.Axis[Joy::AxisY] = (pos.dwYpos - (caps.wYmax + caps.wYmin) / 2.f) * 200.f / (caps.wYmax - caps.wYmin);
state.Axis[Joy::AxisZ] = (pos.dwZpos - (caps.wZmax + caps.wZmin) / 2.f) * 200.f / (caps.wZmax - caps.wZmin);
state.Axis[Joy::AxisR] = (pos.dwRpos - (caps.wRmax + caps.wRmin) / 2.f) * 200.f / (caps.wRmax - caps.wRmin);
state.Axis[Joy::AxisU] = (pos.dwUpos - (caps.wUmax + caps.wUmin) / 2.f) * 200.f / (caps.wUmax - caps.wUmin);
state.Axis[Joy::AxisV] = (pos.dwVpos - (caps.wVmax + caps.wVmin) / 2.f) * 200.f / (caps.wVmax - caps.wVmin);
// POV
if (pos.dwPOV != 0xFFFF)
state.Axis[Joy::AxisPOV] = pos.dwPOV / 100.f;
else
state.Axis[Joy::AxisPOV] = -1.f;
// Buttons
for (unsigned int i = 0; i < GetButtonsCount(); ++i)
state.Buttons[i] = (pos.dwButtons & (1 << i)) != 0;
}
}
}
return state;
}
////////////////////////////////////////////////////////////
bool Joystick::HasAxis(Joy::Axis Axis) const
{
return myAxes[Axis];
}
////////////////////////////////////////////////////////////
unsigned int Joystick::GetButtonsCount() const
{
return myNbButtons;
}
} // namespace priv
} // namespace sf

134
src/SFML/Window/Win32/JoystickImpl.cpp Normal file
View file

@ -0,0 +1,134 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/JoystickImpl.hpp>
#include <windows.h>
#include <cmath>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
bool JoystickImpl::IsConnected(unsigned int index)
{
JOYINFOEX joyInfo;
joyInfo.dwSize = sizeof(joyInfo);
joyInfo.dwFlags = 0;
return joyGetPosEx(JOYSTICKID1 + index, &joyInfo) == JOYERR_NOERROR;
}
////////////////////////////////////////////////////////////
bool JoystickImpl::Open(unsigned int index)
{
// No explicit "open" action is required
myIndex = JOYSTICKID1 + index;
// Store the joystick capabilities
return joyGetDevCaps(myIndex, &myCaps, sizeof(myCaps)) == JOYERR_NOERROR;
}
////////////////////////////////////////////////////////////
void JoystickImpl::Close()
{
// Nothing to do
}
////////////////////////////////////////////////////////////
JoystickCaps JoystickImpl::GetCapabilities() const
{
JoystickCaps caps;
caps.ButtonCount = myCaps.wNumButtons;
if (caps.ButtonCount > Joystick::ButtonCount)
caps.ButtonCount = Joystick::ButtonCount;
caps.Axes[Joystick::X] = true;
caps.Axes[Joystick::Y] = true;
caps.Axes[Joystick::Z] = (myCaps.wCaps & JOYCAPS_HASZ) != 0;
caps.Axes[Joystick::R] = (myCaps.wCaps & JOYCAPS_HASR) != 0;
caps.Axes[Joystick::U] = (myCaps.wCaps & JOYCAPS_HASU) != 0;
caps.Axes[Joystick::V] = (myCaps.wCaps & JOYCAPS_HASV) != 0;
caps.Axes[Joystick::PovX] = (myCaps.wCaps & JOYCAPS_HASPOV) != 0;
caps.Axes[Joystick::PovY] = (myCaps.wCaps & JOYCAPS_HASPOV) != 0;
return caps;
}
////////////////////////////////////////////////////////////
JoystickState JoystickImpl::Update()
{
JoystickState state;
// Get the current joystick state
JOYINFOEX pos;
pos.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNR | JOY_RETURNU | JOY_RETURNV | JOY_RETURNBUTTONS;
pos.dwFlags |= (myCaps.wCaps & JOYCAPS_POVCTS) ? JOY_RETURNPOVCTS : JOY_RETURNPOV;
pos.dwSize = sizeof(JOYINFOEX);
if (joyGetPosEx(myIndex, &pos) == JOYERR_NOERROR)
{
// The joystick is connected
state.Connected = true;
// Axes
state.Axes[Joystick::X] = (pos.dwXpos - (myCaps.wXmax + myCaps.wXmin) / 2.f) * 200.f / (myCaps.wXmax - myCaps.wXmin);
state.Axes[Joystick::Y] = (pos.dwYpos - (myCaps.wYmax + myCaps.wYmin) / 2.f) * 200.f / (myCaps.wYmax - myCaps.wYmin);
state.Axes[Joystick::Z] = (pos.dwZpos - (myCaps.wZmax + myCaps.wZmin) / 2.f) * 200.f / (myCaps.wZmax - myCaps.wZmin);
state.Axes[Joystick::R] = (pos.dwRpos - (myCaps.wRmax + myCaps.wRmin) / 2.f) * 200.f / (myCaps.wRmax - myCaps.wRmin);
state.Axes[Joystick::U] = (pos.dwUpos - (myCaps.wUmax + myCaps.wUmin) / 2.f) * 200.f / (myCaps.wUmax - myCaps.wUmin);
state.Axes[Joystick::V] = (pos.dwVpos - (myCaps.wVmax + myCaps.wVmin) / 2.f) * 200.f / (myCaps.wVmax - myCaps.wVmin);
// Special case for POV, it is given as an angle
if (pos.dwPOV != 0xFFFF)
{
float angle = pos.dwPOV / 36000.f * 3.141592654f;
state.Axes[Joystick::PovX] = std::cos(angle) * 100;
state.Axes[Joystick::PovY] = std::sin(angle) * 100;
}
else
{
state.Axes[Joystick::PovX] = 0;
state.Axes[Joystick::PovY] = 0;
}
// Buttons
for (unsigned int i = 0; i < Joystick::ButtonCount; ++i)
state.Buttons[i] = (pos.dwButtons & (1 << i)) != 0;
}
return state;
}
} // namespace priv
} // namespace sf

107
src/SFML/Window/Win32/JoystickImpl.hpp Normal file
View file

@ -0,0 +1,107 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@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.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICKIMPLWIN32_HPP
#define SFML_JOYSTICKIMPLWIN32_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#define _WIN32_WINDOWS 0x0501
#define _WIN32_WINNT 0x0501
#include <SFML/Window/JoystickImpl.hpp>
#include <windows.h>
#include <mmsystem.h>
#include <cmath>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Windows implementation of joysticks
///
////////////////////////////////////////////////////////////
class JoystickImpl
{
public :
////////////////////////////////////////////////////////////
/// \brief Check if a joystick is currently connected
///
/// \param index Index of the joystick to check
///
/// \return True if the joystick is connected, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsConnected(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Open the joystick
///
/// \param index Index assigned to the joystick
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool Open(unsigned int index);
////////////////////////////////////////////////////////////
/// \brief Close the joystick
///
////////////////////////////////////////////////////////////
void Close();
////////////////////////////////////////////////////////////
/// \brief Get the joystick capabilities
///
/// \return Joystick capabilities
///
////////////////////////////////////////////////////////////
JoystickCaps GetCapabilities() const;
////////////////////////////////////////////////////////////
/// \brief Update the joystick and get its new state
///
/// \return Joystick state
///
////////////////////////////////////////////////////////////
JoystickState Update();
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
unsigned int myIndex; ///< Index of the joystick
JOYCAPS myCaps; ///< Joystick capabilities
};
} // namespace priv
} // namespace sf
#endif // SFML_JOYSTICKIMPLWIN32_HPP

216
src/SFML/Window/Win32/WindowImplWin32.cpp
View file

@ -204,14 +204,11 @@ WindowHandle WindowImplWin32::GetSystemHandle() const
////////////////////////////////////////////////////////////
void WindowImplWin32::ProcessEvents(bool block)
void WindowImplWin32::ProcessEvents()
{
// We process the window events only if we own it
if (!myCallback)
{
if (block)
WaitMessage();
MSG message;
while (PeekMessage(&message, myHandle, 0, 0, PM_REMOVE))
{
@ -243,6 +240,17 @@ void WindowImplWin32::SetCursorPosition(unsigned int x, unsigned int y)
}
////////////////////////////////////////////////////////////
Vector2i WindowImplWin32::GetCursorPosition() const
{
POINT position;
GetCursorPos(&position);
ScreenToClient(myHandle, &position);
return Vector2i(position.x, position.y);
}
////////////////////////////////////////////////////////////
void WindowImplWin32::SetPosition(int x, int y)
{
@ -676,7 +684,7 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam)
////////////////////////////////////////////////////////////
Key::Code WindowImplWin32::VirtualKeyCodeToSF(WPARAM key, LPARAM flags)
Keyboard::Key WindowImplWin32::VirtualKeyCodeToSF(WPARAM key, LPARAM flags)
{
switch (key)
{
@ -685,114 +693,114 @@ Key::Code WindowImplWin32::VirtualKeyCodeToSF(WPARAM key, LPARAM flags)
{
static UINT lShift = MapVirtualKey(VK_LSHIFT, MAPVK_VK_TO_VSC);
UINT scancode = static_cast<UINT>((flags & (0xFF << 16)) >> 16);
return scancode == lShift ? Key::LShift : Key::RShift;
return scancode == lShift ? Keyboard::LShift : Keyboard::RShift;
}
// Check the "extended" flag to distinguish between left and right alt
case VK_MENU : return (HIWORD(flags) & KF_EXTENDED) ? Key::RAlt : Key::LAlt;
case VK_MENU : return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::RAlt : Keyboard::LAlt;
// Check the "extended" flag to distinguish between left and right control
case VK_CONTROL : return (HIWORD(flags) & KF_EXTENDED) ? Key::RControl : Key::LControl;
case VK_CONTROL : return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::RControl : Keyboard::LControl;
// Other keys are reported properly
case VK_LWIN : return Key::LSystem;
case VK_RWIN : return Key::RSystem;
case VK_APPS : return Key::Menu;
case VK_OEM_1 : return Key::SemiColon;
case VK_OEM_2 : return Key::Slash;
case VK_OEM_PLUS : return Key::Equal;
case VK_OEM_MINUS : return Key::Dash;
case VK_OEM_4 : return Key::LBracket;
case VK_OEM_6 : return Key::RBracket;
case VK_OEM_COMMA : return Key::Comma;
case VK_OEM_PERIOD : return Key::Period;
case VK_OEM_7 : return Key::Quote;
case VK_OEM_5 : return Key::BackSlash;
case VK_OEM_3 : return Key::Tilde;
case VK_ESCAPE : return Key::Escape;
case VK_SPACE : return Key::Space;
case VK_RETURN : return Key::Return;
case VK_BACK : return Key::Back;
case VK_TAB : return Key::Tab;
case VK_PRIOR : return Key::PageUp;
case VK_NEXT : return Key::PageDown;
case VK_END : return Key::End;
case VK_HOME : return Key::Home;
case VK_INSERT : return Key::Insert;
case VK_DELETE : return Key::Delete;
case VK_ADD : return Key::Add;
case VK_SUBTRACT : return Key::Subtract;
case VK_MULTIPLY : return Key::Multiply;
case VK_DIVIDE : return Key::Divide;
case VK_PAUSE : return Key::Pause;
case VK_F1 : return Key::F1;
case VK_F2 : return Key::F2;
case VK_F3 : return Key::F3;
case VK_F4 : return Key::F4;
case VK_F5 : return Key::F5;
case VK_F6 : return Key::F6;
case VK_F7 : return Key::F7;
case VK_F8 : return Key::F8;
case VK_F9 : return Key::F9;
case VK_F10 : return Key::F10;
case VK_F11 : return Key::F11;
case VK_F12 : return Key::F12;
case VK_F13 : return Key::F13;
case VK_F14 : return Key::F14;
case VK_F15 : return Key::F15;
case VK_LEFT : return Key::Left;
case VK_RIGHT : return Key::Right;
case VK_UP : return Key::Up;
case VK_DOWN : return Key::Down;
case VK_NUMPAD0 : return Key::Numpad0;
case VK_NUMPAD1 : return Key::Numpad1;
case VK_NUMPAD2 : return Key::Numpad2;
case VK_NUMPAD3 : return Key::Numpad3;
case VK_NUMPAD4 : return Key::Numpad4;
case VK_NUMPAD5 : return Key::Numpad5;
case VK_NUMPAD6 : return Key::Numpad6;
case VK_NUMPAD7 : return Key::Numpad7;
case VK_NUMPAD8 : return Key::Numpad8;
case VK_NUMPAD9 : return Key::Numpad9;
case 'A' : return Key::A;
case 'Z' : return Key::Z;
case 'E' : return Key::E;
case 'R' : return Key::R;
case 'T' : return Key::T;
case 'Y' : return Key::Y;
case 'U' : return Key::U;
case 'I' : return Key::I;
case 'O' : return Key::O;
case 'P' : return Key::P;
case 'Q' : return Key::Q;
case 'S' : return Key::S;
case 'D' : return Key::D;
case 'F' : return Key::F;
case 'G' : return Key::G;
case 'H' : return Key::H;
case 'J' : return Key::J;
case 'K' : return Key::K;
case 'L' : return Key::L;
case 'M' : return Key::M;
case 'W' : return Key::W;
case 'X' : return Key::X;
case 'C' : return Key::C;
case 'V' : return Key::V;
case 'B' : return Key::B;
case 'N' : return Key::N;
case '0' : return Key::Num0;
case '1' : return Key::Num1;
case '2' : return Key::Num2;
case '3' : return Key::Num3;
case '4' : return Key::Num4;
case '5' : return Key::Num5;
case '6' : return Key::Num6;
case '7' : return Key::Num7;
case '8' : return Key::Num8;
case '9' : return Key::Num9;
case VK_LWIN : return Keyboard::LSystem;
case VK_RWIN : return Keyboard::RSystem;
case VK_APPS : return Keyboard::Menu;
case VK_OEM_1 : return Keyboard::SemiColon;
case VK_OEM_2 : return Keyboard::Slash;
case VK_OEM_PLUS : return Keyboard::Equal;
case VK_OEM_MINUS : return Keyboard::Dash;
case VK_OEM_4 : return Keyboard::LBracket;
case VK_OEM_6 : return Keyboard::RBracket;
case VK_OEM_COMMA : return Keyboard::Comma;
case VK_OEM_PERIOD : return Keyboard::Period;
case VK_OEM_7 : return Keyboard::Quote;
case VK_OEM_5 : return Keyboard::BackSlash;
case VK_OEM_3 : return Keyboard::Tilde;
case VK_ESCAPE : return Keyboard::Escape;
case VK_SPACE : return Keyboard::Space;
case VK_RETURN : return Keyboard::Return;
case VK_BACK : return Keyboard::Back;
case VK_TAB : return Keyboard::Tab;
case VK_PRIOR : return Keyboard::PageUp;
case VK_NEXT : return Keyboard::PageDown;
case VK_END : return Keyboard::End;
case VK_HOME : return Keyboard::Home;
case VK_INSERT : return Keyboard::Insert;
case VK_DELETE : return Keyboard::Delete;
case VK_ADD : return Keyboard::Add;
case VK_SUBTRACT : return Keyboard::Subtract;
case VK_MULTIPLY : return Keyboard::Multiply;
case VK_DIVIDE : return Keyboard::Divide;
case VK_PAUSE : return Keyboard::Pause;
case VK_F1 : return Keyboard::F1;
case VK_F2 : return Keyboard::F2;
case VK_F3 : return Keyboard::F3;
case VK_F4 : return Keyboard::F4;
case VK_F5 : return Keyboard::F5;
case VK_F6 : return Keyboard::F6;
case VK_F7 : return Keyboard::F7;
case VK_F8 : return Keyboard::F8;
case VK_F9 : return Keyboard::F9;
case VK_F10 : return Keyboard::F10;
case VK_F11 : return Keyboard::F11;
case VK_F12 : return Keyboard::F12;
case VK_F13 : return Keyboard::F13;
case VK_F14 : return Keyboard::F14;
case VK_F15 : return Keyboard::F15;
case VK_LEFT : return Keyboard::Left;
case VK_RIGHT : return Keyboard::Right;
case VK_UP : return Keyboard::Up;
case VK_DOWN : return Keyboard::Down;
case VK_NUMPAD0 : return Keyboard::Numpad0;
case VK_NUMPAD1 : return Keyboard::Numpad1;
case VK_NUMPAD2 : return Keyboard::Numpad2;
case VK_NUMPAD3 : return Keyboard::Numpad3;
case VK_NUMPAD4 : return Keyboard::Numpad4;
case VK_NUMPAD5 : return Keyboard::Numpad5;
case VK_NUMPAD6 : return Keyboard::Numpad6;
case VK_NUMPAD7 : return Keyboard::Numpad7;
case VK_NUMPAD8 : return Keyboard::Numpad8;
case VK_NUMPAD9 : return Keyboard::Numpad9;
case 'A' : return Keyboard::A;
case 'Z' : return Keyboard::Z;
case 'E' : return Keyboard::E;
case 'R' : return Keyboard::R;
case 'T' : return Keyboard::T;
case 'Y' : return Keyboard::Y;
case 'U' : return Keyboard::U;
case 'I' : return Keyboard::I;
case 'O' : return Keyboard::O;
case 'P' : return Keyboard::P;
case 'Q' : return Keyboard::Q;
case 'S' : return Keyboard::S;
case 'D' : return Keyboard::D;
case 'F' : return Keyboard::F;
case 'G' : return Keyboard::G;
case 'H' : return Keyboard::H;
case 'J' : return Keyboard::J;
case 'K' : return Keyboard::K;
case 'L' : return Keyboard::L;
case 'M' : return Keyboard::M;
case 'W' : return Keyboard::W;
case 'X' : return Keyboard::X;
case 'C' : return Keyboard::C;
case 'V' : return Keyboard::V;
case 'B' : return Keyboard::B;
case 'N' : return Keyboard::N;
case '0' : return Keyboard::Num0;
case '1' : return Keyboard::Num1;
case '2' : return Keyboard::Num2;
case '3' : return Keyboard::Num3;
case '4' : return Keyboard::Num4;
case '5' : return Keyboard::Num5;
case '6' : return Keyboard::Num6;
case '7' : return Keyboard::Num7;
case '8' : return Keyboard::Num8;
case '9' : return Keyboard::Num9;
}
return Key::Code(0);
return Keyboard::Key(0);
}

14
src/SFML/Window/Win32/WindowImplWin32.hpp
View file

@ -83,10 +83,8 @@ private :
////////////////////////////////////////////////////////////
/// \brief Process incoming events from the operating system
///
/// \param block Use true to block the thread until an event arrives
///
////////////////////////////////////////////////////////////
virtual void ProcessEvents(bool block);
virtual void ProcessEvents();
////////////////////////////////////////////////////////////
/// \brief Show or hide the mouse cursor
@ -105,6 +103,14 @@ private :
////////////////////////////////////////////////////////////
virtual void SetCursorPosition(unsigned int x, unsigned int y);
////////////////////////////////////////////////////////////
/// \brief Get the position of the mouse cursor
///
/// \return Current mouse cursor position, relative to the window
///
////////////////////////////////////////////////////////////
virtual Vector2i GetCursorPosition() const;
////////////////////////////////////////////////////////////
/// \brief Change the position of the window on screen
///
@ -196,7 +202,7 @@ private :
/// \return SFML key code corresponding to the key
///
////////////////////////////////////////////////////////////
static Key::Code VirtualKeyCodeToSF(WPARAM key, LPARAM flags);
static Keyboard::Key VirtualKeyCodeToSF(WPARAM key, LPARAM flags);
////////////////////////////////////////////////////////////
/// \brief Check if the current version of the OS supports

35
src/SFML/Window/Window.cpp
View file

@ -38,6 +38,7 @@
namespace
{
const sf::Window* fullscreenWindow = NULL;
const sf::Window* mouseFocusWindow = NULL;
}
@ -249,6 +250,13 @@ void Window::SetCursorPosition(unsigned int x, unsigned int y)
}
////////////////////////////////////////////////////////////
Vector2i Window::GetCursorPosition() const
{
return myWindow ? myWindow->GetCursorPosition() : Vector2i(0, 0);
}
////////////////////////////////////////////////////////////
void Window::SetPosition(int x, int y)
{
@ -340,13 +348,6 @@ void Window::Display()
}
////////////////////////////////////////////////////////////
const Input& Window::GetInput() const
{
return myInput;
}
////////////////////////////////////////////////////////////
void Window::SetFramerateLimit(unsigned int limit)
{
@ -376,6 +377,13 @@ WindowHandle Window::GetSystemHandle() const
}
////////////////////////////////////////////////////////////
const Window* Window::GetMouseFocusWindow()
{
return mouseFocusWindow;
}
////////////////////////////////////////////////////////////
void Window::OnCreate()
{
@ -393,13 +401,20 @@ void Window::OnResize()
////////////////////////////////////////////////////////////
bool Window::FilterEvent(const Event& event)
{
// Notify the input object
myInput.OnEvent(event);
// Notify resize events to the derived class
if (event.Type == Event::Resized)
OnResize();
// Watch mouse move/left events to track the window which is under the cursor
if (event.Type == Event::MouseMoved)
{
mouseFocusWindow = this;
}
else if ((event.Type == Event::MouseLeft) && (mouseFocusWindow == this))
{
mouseFocusWindow = NULL;
}
return true;
}

114
src/SFML/Window/WindowImpl.cpp
View file

@ -27,6 +27,7 @@
////////////////////////////////////////////////////////////
#include <SFML/Window/WindowImpl.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Window/JoystickManager.hpp>
#include <algorithm>
#include <cmath>
@ -72,12 +73,10 @@ myWidth (0),
myHeight (0),
myJoyThreshold(0.1f)
{
// Initialize the joysticks
for (unsigned int i = 0; i < Joy::Count; ++i)
{
myJoysticks[i].Initialize(i);
myJoyStates[i] = myJoysticks[i].UpdateState();
}
// Get the initial joystick states
JoystickManager::GetInstance().Update();
for (unsigned int i = 0; i < Joystick::Count; ++i)
myJoyStates[i] = JoystickManager::GetInstance().GetState(i);
}
@ -115,21 +114,25 @@ bool WindowImpl::PopEvent(Event& event, bool block)
// If the event queue is empty, let's first check if new events are available from the OS
if (myEvents.empty())
{
// Special handling of joystick events (we must use polling)
ProcessJoystickEvents();
if (block)
if (!block)
{
// If we are blocking, loop until we actually received a SFML event
// (there may be OS events that make ProcessEvents(true) return, but
// which don't translate to SFML events)
while (myEvents.empty())
ProcessEvents(true);
// Non-blocking mode: process events and continue
ProcessJoystickEvents();
ProcessEvents();
}
else
{
// If we are not blocking, just process the pending events
ProcessEvents(false);
// Blocking mode: process events until one is triggered
// Here we use a manual wait loop instead of the optimized
// wait-event provided by the OS, so that we don't skip joystick
// events (which require polling)
while (myEvents.empty())
{
ProcessJoystickEvents();
ProcessEvents();
Sleep(10);
}
}
}
@ -156,45 +159,62 @@ void WindowImpl::PushEvent(const Event& event)
////////////////////////////////////////////////////////////
void WindowImpl::ProcessJoystickEvents()
{
for (unsigned int i = 0; i < Joy::Count; ++i)
// First update the global joystick states
JoystickManager::GetInstance().Update();
for (unsigned int i = 0; i < Joystick::Count; ++i)
{
// Copy the previous state of the joystick and get the new one
JoystickState previousState = myJoyStates[i];
myJoyStates[i] = myJoysticks[i].UpdateState();
myJoyStates[i] = JoystickManager::GetInstance().GetState(i);
JoystickCaps caps = JoystickManager::GetInstance().GetCapabilities(i);
// Axis
for (unsigned int j = 0; j < Joy::AxisCount; ++j)
// Connection state
bool connected = myJoyStates[i].Connected;
if (previousState.Connected ^ connected)
{
Joy::Axis axis = static_cast<Joy::Axis>(j);
if (myJoysticks[i].HasAxis(axis))
{
float prevPos = previousState.Axis[axis];
float currPos = myJoyStates[i].Axis[axis];
if (fabs(currPos - prevPos) >= myJoyThreshold)
{
Event event;
event.Type = Event::JoyMoved;
event.JoyMove.JoystickId = i;
event.JoyMove.Axis = axis;
event.JoyMove.Position = currPos;
PushEvent(event);
}
}
Event event;
event.Type = connected ? Event::JoystickConnected : Event::JoystickDisconnected;
event.JoystickButton.JoystickId = i;
PushEvent(event);
}
// Buttons
for (unsigned int j = 0; j < myJoysticks[i].GetButtonsCount(); ++j)
if (connected)
{
bool prevPressed = previousState.Buttons[j];
bool currPressed = myJoyStates[i].Buttons[j];
if ((!prevPressed && currPressed) || (prevPressed && !currPressed))
// Axes
for (unsigned int j = 0; j < Joystick::AxisCount; ++j)
{
Event event;
event.Type = currPressed ? Event::JoyButtonPressed : Event::JoyButtonReleased;
event.JoyButton.JoystickId = i;
event.JoyButton.Button = j;
PushEvent(event);
if (caps.Axes[j])
{
Joystick::Axis axis = static_cast<Joystick::Axis>(j);
float prevPos = previousState.Axes[axis];
float currPos = myJoyStates[i].Axes[axis];
if (fabs(currPos - prevPos) >= myJoyThreshold)
{
Event event;
event.Type = Event::JoystickMoved;
event.JoystickMove.JoystickId = i;
event.JoystickMove.Axis = axis;
event.JoystickMove.Position = currPos;
PushEvent(event);
}
}
}
// Buttons
for (unsigned int j = 0; j < caps.ButtonCount; ++j)
{
bool prevPressed = previousState.Buttons[j];
bool currPressed = myJoyStates[i].Buttons[j];
if (prevPressed ^ currPressed)
{
Event event;
event.Type = currPressed ? Event::JoystickButtonPressed : Event::JoystickButtonReleased;
event.JoystickButton.JoystickId = i;
event.JoystickButton.Button = j;
PushEvent(event);
}
}
}
}

20
src/SFML/Window/WindowImpl.hpp
View file

@ -32,6 +32,7 @@
#include <SFML/System/NonCopyable.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Window/Joystick.hpp>
#include <SFML/Window/JoystickImpl.hpp>
#include <SFML/Window/VideoMode.hpp>
#include <SFML/Window/WindowHandle.hpp>
#include <queue>
@ -149,6 +150,14 @@ public :
////////////////////////////////////////////////////////////
virtual void SetCursorPosition(unsigned int x, unsigned int y) = 0;
////////////////////////////////////////////////////////////
/// \brief Get the position of the mouse cursor
///
/// \return Current mouse cursor position, relative to the window
///
////////////////////////////////////////////////////////////
virtual Vector2i GetCursorPosition() const = 0;
////////////////////////////////////////////////////////////
/// \brief Change the position of the window on screen
///
@ -238,18 +247,15 @@ private :
////////////////////////////////////////////////////////////
/// \brief Process incoming events from the operating system
///
/// \param block Use true to block the thread until an event arrives
///
////////////////////////////////////////////////////////////
virtual void ProcessEvents(bool block) = 0;
virtual void ProcessEvents() = 0;
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::queue<Event> myEvents; ///< Queue of available events
Joystick myJoysticks[Joy::Count]; ///< Joysticks to observe
JoystickState myJoyStates[Joy::Count]; ///< Current states of the joysticks
float myJoyThreshold; ///< Joystick threshold (minimum motion for MOVE event to be generated)
std::queue<Event> myEvents; ///< Queue of available events
JoystickState myJoyStates[Joystick::Count]; ///< Previous state of the joysticks
float myJoyThreshold; ///< Joystick threshold (minimum motion for MOVE event to be generated)
};
} // namespace priv