ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dolphin/Source/Plugins/Plugin_VideoOGL/Src/Win32Window.cpp

804 lines
24 KiB
C++
Raw Blame History

#include "Win32Window.h"
// Static member data
unsigned int Win32Window::ourWindowCount = 0;
const char* Win32Window::ourClassName = _T("DolphinEmuWnd");
Win32Window* Win32Window::ourFullscreenWindow = NULL;
Win32Window::Win32Window() : GLWindow(),
myHandle (NULL),
myCallback (0),
myCursor (NULL),
myIcon (NULL),
myKeyRepeatEnabled (true),
myIsCursorIn (false)
{
// Register the window class at first call
if (ourWindowCount == 0)
RegisterWindowClass();
// Use small dimensions
//SetWinSize(1, 1);
// Create the rendering window
if (!(myHandle = CreateWindow(ourClassName, _T(""), WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
GetXwin(), GetYwin(), NULL, NULL, myhInstance, this))) {
PanicAlert("Error creating GL Window");
}
ShowWindow(myHandle, SW_SHOW);
// Create the rendering context
if (myHandle)
{
VideoMode Mode;
Mode.Width = GetXwin();
Mode.Height = GetYwin();
Mode.BitsPerPixel = 32;
Mode.DepthBits = 24;
Mode.StencilBits = 8;
Mode.AntialiasingLevel = 0;
CreateContext(Mode);
// Don't activate by default
//SetNotActive();
}
}
Win32Window::~Win32Window()
{
// Destroy the custom icon, if any
if (myIcon)
DestroyIcon(myIcon);
if (!myCallback)
{
// Destroy the window
if (myHandle)
DestroyWindow(myHandle);
// Decrement the window count
ourWindowCount--;
// Unregister window class if we were the last window
if (ourWindowCount == 0)
UnregisterClass(ourClassName, GetModuleHandle(NULL));
}
else
{
// The window is external : remove the hook on its message callback
SetWindowLongPtr(myHandle, GWLP_WNDPROC, myCallback);
}
}
void Win32Window::SwapBuffers()
{
if (myDeviceContext && myGLContext)
::SwapBuffers(myDeviceContext);
}
void Win32Window::SetWindowText(const char *text)
{
::SetWindowText(GetWnd(), text);
}
void Win32Window::ShowMouseCursor(bool Show)
{
if (Show)
myCursor = LoadCursor(NULL, IDC_ARROW);
else
myCursor = NULL;
SetCursor(myCursor);
}
bool Win32Window::PeekMessages()
{
// We update the window only if we own it
if (!myCallback)
{
MSG Message;
while (PeekMessage(&Message, myHandle, 0, 0, PM_REMOVE))
{
TranslateMessage(&Message);
DispatchMessage(&Message);
}
}
return true; // I don't know why this is bool...
}
void Win32Window::Update()
{
// We just check all of our events here
// TODO
PeekMessages();
eventHandler->Update();
updateDim();
}
bool Win32Window::MakeCurrent()
{
if (myDeviceContext && myGLContext && (wglGetCurrentContext() != myGLContext))
{
wglMakeCurrent(myDeviceContext, myGLContext);
return true;
}
else
return false;
}
void Win32Window::RegisterWindowClass()
{
WNDCLASS WindowClass;
myhInstance = GetModuleHandle(NULL);
WindowClass.style = CS_OWNDC;
WindowClass.lpfnWndProc = &Win32Window::GlobalOnEvent;
WindowClass.cbClsExtra = 0;
WindowClass.cbWndExtra = 0;
WindowClass.hInstance = myhInstance;
WindowClass.hIcon = NULL;
WindowClass.hCursor = 0;
WindowClass.hbrBackground = 0;
WindowClass.lpszMenuName = NULL;
WindowClass.lpszClassName = ourClassName;
if (!RegisterClass(&WindowClass))
ERROR_LOG("Failed To Register The Window Class\n");
}
void Win32Window::SwitchToFullscreen(const VideoMode& Mode)
{
DEVMODE DevMode;
DevMode.dmSize = sizeof(DEVMODE);
DevMode.dmPelsWidth = Mode.Width;
DevMode.dmPelsHeight = Mode.Height;
DevMode.dmBitsPerPel = Mode.BitsPerPixel;
DevMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
// Apply fullscreen mode
if (ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
ERROR_LOG("Failed to change display mode for fullscreen\n");
return;
}
// Change window style (no border, no titlebar, ...)
SetWindowLong(myHandle, GWL_STYLE, WS_POPUP);
SetWindowLong(myHandle, GWL_EXSTYLE, WS_EX_APPWINDOW);
// And resize it so that it fits the entire screen
SetWindowPos(myHandle, HWND_TOP, 0, 0, Mode.Width, Mode.Height, SWP_FRAMECHANGED);
ShowWindow(myHandle, SW_SHOW);
// Set "this" as the current fullscreen window
ourFullscreenWindow = this;
// SetPixelFormat can fail (really ?) if window style doesn't contain these flags
long Style = GetWindowLong(myHandle, GWL_STYLE);
SetWindowLong(myHandle, GWL_STYLE, Style | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
}
//VideoMode Win32Window::GetSupportedVideoModes(std::vector<VideoMode>& Modes)
//{
// // First, clear array to fill
// Modes.clear();
//
// // Enumerate all available video modes for primary display adapter
// DEVMODE Win32Mode;
// Win32Mode.dmSize = sizeof(DEVMODE);
// for (int Count = 0; EnumDisplaySettings(NULL, Count, &Win32Mode); ++Count)
// {
// // Convert to sfVideoMode
// VideoMode Mode(Win32Mode.dmPelsWidth, Win32Mode.dmPelsHeight, Win32Mode.dmBitsPerPel);
//
// // Add it only if it is not already in the array
// if (std::find(Modes.begin(), Modes.end(), Mode) == Modes.end())
// Modes.push_back(Mode);
// }
//}
void Win32Window::CreateContext(VideoMode& Mode)
{
// TESTING
Mode.DepthBits = 24;
Mode.StencilBits = 8;
//Mode.AntialiasingLevel = 4;
// Get the device context attached to the window
myDeviceContext = GetDC(myHandle);
if (myDeviceContext == NULL)
{
ERROR_LOG("Failed to get device context of window -- cannot create OpenGL context\n");
return;
}
// Let's find a suitable pixel format -- first try with antialiasing
int BestFormat = 0;
if (Mode.AntialiasingLevel > 0)
{
// Get the wglChoosePixelFormatARB function (it is an extension)
PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = reinterpret_cast<PFNWGLCHOOSEPIXELFORMATARBPROC>(wglGetProcAddress("wglChoosePixelFormatARB"));
// Define the basic attributes we want for our window
int IntAttributes[] =
{
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_SAMPLE_BUFFERS_ARB, (Mode.AntialiasingLevel ? GL_TRUE : GL_FALSE),
WGL_SAMPLES_ARB, Mode.AntialiasingLevel,
0, 0
};
// Let's check how many formats are supporting our requirements
int Formats[128];
UINT NbFormats;
float FloatAttributes[] = {0, 0};
bool IsValid = wglChoosePixelFormatARB(myDeviceContext, IntAttributes, FloatAttributes, sizeof(Formats) / sizeof(*Formats), Formats, &NbFormats) != 0;
if (!IsValid || (NbFormats == 0))
{
if (Mode.AntialiasingLevel > 2)
{
// No format matching our needs : reduce the multisampling level
char errMsg[256];
sprintf(errMsg, "Failed to find a pixel format supporting %u antialiasing levels ; trying with 2 levels\n", Mode.AntialiasingLevel);
ERROR_LOG(errMsg);
Mode.AntialiasingLevel = IntAttributes[1] = 2;
IsValid = wglChoosePixelFormatARB(myDeviceContext, IntAttributes, FloatAttributes, sizeof(Formats) / sizeof(*Formats), Formats, &NbFormats) != 0;
}
if (!IsValid || (NbFormats == 0))
{
// Cannot find any pixel format supporting multisampling ; disabling antialiasing
ERROR_LOG("Failed to find a pixel format supporting antialiasing ; antialiasing will be disabled\n");
Mode.AntialiasingLevel = 0;
}
}
// Get the best format among the returned ones
if (IsValid && (NbFormats > 0))
{
int BestScore = 0xFFFF;
for (UINT i = 0; i < NbFormats; ++i)
{
// Get the current format's attributes
PIXELFORMATDESCRIPTOR Attribs;
Attribs.nSize = sizeof(PIXELFORMATDESCRIPTOR);
Attribs.nVersion = 1;
DescribePixelFormat(myDeviceContext, Formats[i], sizeof(PIXELFORMATDESCRIPTOR), &Attribs);
// Evaluate the current configuration
int Color = Attribs.cRedBits + Attribs.cGreenBits + Attribs.cBlueBits + Attribs.cAlphaBits;
int Score = abs(static_cast<int>(Mode.BitsPerPixel - Color)) + // The EvaluateConfig function
abs(static_cast<int>(Mode.DepthBits - Attribs.cDepthBits)) +
abs(static_cast<int>(Mode.StencilBits - Attribs.cStencilBits));
// Keep it if it's better than the current best
if (Score < BestScore)
{
BestScore = Score;
BestFormat = Formats[i];
}
}
}
}
// Find a pixel format with no antialiasing, if not needed or not supported
if (BestFormat == 0)
{
// Setup a pixel format descriptor from the rendering settings
PIXELFORMATDESCRIPTOR PixelDescriptor;
ZeroMemory(&PixelDescriptor, sizeof(PIXELFORMATDESCRIPTOR));
PixelDescriptor.nSize = sizeof(PIXELFORMATDESCRIPTOR);
PixelDescriptor.nVersion = 1;
PixelDescriptor.iLayerType = PFD_MAIN_PLANE;
PixelDescriptor.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
PixelDescriptor.iPixelType = PFD_TYPE_RGBA;
PixelDescriptor.cColorBits = static_cast<BYTE>(Mode.BitsPerPixel);
PixelDescriptor.cDepthBits = static_cast<BYTE>(Mode.DepthBits);
PixelDescriptor.cStencilBits = static_cast<BYTE>(Mode.StencilBits);
// Get the pixel format that best matches our requirements
BestFormat = ChoosePixelFormat(myDeviceContext, &PixelDescriptor);
if (BestFormat == 0)
{
ERROR_LOG("Failed to find a suitable pixel format for device context -- cannot create OpenGL context\n");
return;
}
}
// Extract the depth and stencil bits from the chosen format
PIXELFORMATDESCRIPTOR ActualFormat;
ActualFormat.nSize = sizeof(PIXELFORMATDESCRIPTOR);
ActualFormat.nVersion = 1;
DescribePixelFormat(myDeviceContext, BestFormat, sizeof(PIXELFORMATDESCRIPTOR), &ActualFormat);
Mode.DepthBits = ActualFormat.cDepthBits;
Mode.StencilBits = ActualFormat.cStencilBits;
// Set the chosen pixel format
if (!SetPixelFormat(myDeviceContext, BestFormat, &ActualFormat))
{
ERROR_LOG("Failed to set pixel format for device context -- cannot create OpenGL context\n");
return;
}
// Create the OpenGL context from the device context
myGLContext = wglCreateContext(myDeviceContext);
if (myGLContext == NULL)
{
ERROR_LOG("Failed to create an OpenGL context for this window\n");
return;
}
// Share display lists with other contexts
HGLRC CurrentContext = wglGetCurrentContext();
if (CurrentContext)
wglShareLists(CurrentContext, myGLContext);
// Activate the context
MakeCurrent();
// Enable multisampling
if (Mode.AntialiasingLevel > 0)
glEnable(GL_MULTISAMPLE_ARB);
}
void Win32Window::Cleanup()
{
// Restore the previous video mode (in case we were running in fullscreen)
if (ourFullscreenWindow == this)
{
ChangeDisplaySettings(NULL, 0);
ourFullscreenWindow = NULL;
}
// Unhide the mouse cursor (in case it was hidden)
ShowMouseCursor(true);
//GetProperty(OGL_HIDECURSOR)
// Destroy the OpenGL context
if (myGLContext)
{
// Unbind the context before destroying it
//SetNotActive();
wglDeleteContext(myGLContext);
myGLContext = NULL;
}
if (myDeviceContext)
{
ReleaseDC(myHandle, myDeviceContext);
myDeviceContext = NULL;
}
}
////////////////////////////////////////////////////////////
/// Process a Win32 Event
////////////////////////////////////////////////////////////
void Win32Window::ProcessEvent(UINT Message, WPARAM WParam, LPARAM LParam)
{
// Don't process any message until window is created
if (myHandle == NULL)
return;
switch (Message)
{
// Destroy Event
case WM_DESTROY :
{
// Here we must cleanup resources !
Cleanup();
break;
}
// Set cursor Event
case WM_SETCURSOR :
{
// The mouse has moved, if the cursor is in our window we must refresh the cursor
if (LOWORD(LParam) == HTCLIENT)
SetCursor(myCursor);
break;
}
case WM_CLOSE :
{
sf::Event Evt;
Evt.Type = sf::Event::Closed;
eventHandler->addEvent(&Evt);
break;
}
// Resize Event
case WM_SIZE :
{
// Update window size
RECT Rect;
GetClientRect(myHandle, &Rect);
SetWinSize(Rect.right - Rect.left, Rect.bottom - Rect.top);
sf::Event Evt;
Evt.Type = sf::Event::Resized;
Evt.Size.Width = GetXwin();
Evt.Size.Height = GetYwin();
eventHandler->addEvent(&Evt);
break;
}
// Gain focus Event
case WM_SETFOCUS :
{
sf::Event Evt;
Evt.Type = sf::Event::GainedFocus;
eventHandler->addEvent(&Evt);
break;
}
// Lost focus Event
case WM_KILLFOCUS :
{
sf::Event Evt;
Evt.Type = sf::Event::LostFocus;
eventHandler->addEvent(&Evt);
break;
}
// Text Event
case WM_CHAR :
{
sf::Event Evt;
Evt.Type = sf::Event::TextEntered;
Evt.Text.Unicode = static_cast<u32>(WParam);
eventHandler->addEvent(&Evt);
break;
}
// Keydown Event
case WM_KEYDOWN :
case WM_SYSKEYDOWN :
{
if (myKeyRepeatEnabled || ((LParam & (1 << 30)) == 0))
{
sf::Event Evt;
Evt.Type = sf::Event::KeyPressed;
Evt.Key.Code = (WParam == VK_SHIFT) ? GetShiftState(true) : VirtualKeyCodeToSF(WParam, LParam);
Evt.Key.Alt = HIWORD(GetAsyncKeyState(VK_MENU)) != 0;
Evt.Key.Control = HIWORD(GetAsyncKeyState(VK_CONTROL)) != 0;
Evt.Key.Shift = HIWORD(GetAsyncKeyState(VK_SHIFT)) != 0;
eventHandler->addEvent(&Evt);
}
break;
}
// Keyup Event
case WM_KEYUP :
case WM_SYSKEYUP :
{
sf::Event Evt;
Evt.Type = sf::Event::KeyReleased;
Evt.Key.Code = (WParam == VK_SHIFT) ? GetShiftState(false) : VirtualKeyCodeToSF(WParam, LParam);
Evt.Key.Alt = HIWORD(GetAsyncKeyState(VK_MENU)) != 0;
Evt.Key.Control = HIWORD(GetAsyncKeyState(VK_CONTROL)) != 0;
Evt.Key.Shift = HIWORD(GetAsyncKeyState(VK_SHIFT)) != 0;
eventHandler->addEvent(&Evt);
break;
}
// Mouse wheel Event
case WM_MOUSEWHEEL :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseWheelMoved;
Evt.MouseWheel.Delta = static_cast<s16>(HIWORD(WParam)) / 120;
eventHandler->addEvent(&Evt);
break;
}
// Mouse left button down Event
case WM_LBUTTONDOWN :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonPressed;
Evt.MouseButton.Button = sf::Mouse::Left;
Evt.MouseButton.X = LOWORD(LParam);
Evt.MouseButton.Y = HIWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse left button up Event
case WM_LBUTTONUP :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonReleased;
Evt.MouseButton.Button = sf::Mouse::Left;
Evt.MouseButton.X = LOWORD(LParam);
Evt.MouseButton.Y = HIWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse right button down Event
case WM_RBUTTONDOWN :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonPressed;
Evt.MouseButton.Button = sf::Mouse::Right;
Evt.MouseButton.X = LOWORD(LParam);
Evt.MouseButton.Y = HIWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse right button up Event
case WM_RBUTTONUP :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonReleased;
Evt.MouseButton.Button = sf::Mouse::Right;
Evt.MouseButton.X = LOWORD(LParam);
Evt.MouseButton.Y = HIWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse wheel button down Event
case WM_MBUTTONDOWN :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonPressed;
Evt.MouseButton.Button = sf::Mouse::Middle;
Evt.MouseButton.X = LOWORD(LParam);
Evt.MouseButton.Y = HIWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse wheel button up Event
case WM_MBUTTONUP :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonReleased;
Evt.MouseButton.Button = sf::Mouse::Middle;
Evt.MouseButton.X = LOWORD(LParam);
Evt.MouseButton.Y = HIWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse X button down Event
case WM_XBUTTONDOWN :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonPressed;
Evt.MouseButton.Button = HIWORD(WParam) == XBUTTON1 ? sf::Mouse::XButton1 : sf::Mouse::XButton2;
Evt.MouseButton.X = LOWORD(LParam);
Evt.MouseButton.Y = HIWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse X button up Event
case WM_XBUTTONUP :
{
sf::Event Evt;
Evt.Type = sf::Event::MouseButtonReleased;
Evt.MouseButton.Button = HIWORD(WParam) == XBUTTON1 ? sf::Mouse::XButton1 : sf::Mouse::XButton2;
Evt.MouseButton.X = LOWORD(LParam);
eventHandler->addEvent(&Evt);
break;
}
// Mouse move Event
case WM_MOUSEMOVE :
{
// Check if we need to generate a MouseEntered Event
if (!myIsCursorIn)
{
TRACKMOUSEEVENT MouseEvent;
MouseEvent.cbSize = sizeof(TRACKMOUSEEVENT);
MouseEvent.hwndTrack = myHandle;
MouseEvent.dwFlags = TME_LEAVE;
TrackMouseEvent(&MouseEvent);
myIsCursorIn = true;
sf::Event Evt;
Evt.Type = sf::Event::MouseEntered;
eventHandler->addEvent(&Evt);
}
sf::Event Evt;
Evt.Type = sf::Event::MouseMoved;
Evt.MouseMove.X = LOWORD(LParam);
Evt.MouseMove.Y = HIWORD(LParam); // (shuffle2) Added this, check to see if it's good
eventHandler->addEvent(&Evt);
break;
}
// Mouse leave Event
case WM_MOUSELEAVE :
{
myIsCursorIn = false;
sf::Event Evt;
Evt.Type = sf::Event::MouseLeft;
eventHandler->addEvent(&Evt);
break;
}
}
}
///////////////////////////////////////////////////////////
/// Check the state of the shift keys on a key sf::Event,
/// and return the corresponding SF key code
////////////////////////////////////////////////////////////
sf::Key::Code Win32Window::GetShiftState(bool KeyDown)
{
static bool LShiftPrevDown = false;
static bool RShiftPrevDown = false;
bool LShiftDown = (HIWORD(GetAsyncKeyState(VK_LSHIFT)) != 0);
bool RShiftDown = (HIWORD(GetAsyncKeyState(VK_RSHIFT)) != 0);
sf::Key::Code Code = sf::Key::Code(0);
if (KeyDown)
{
if (!LShiftPrevDown && LShiftDown) Code = sf::Key::LShift;
else if (!RShiftPrevDown && RShiftDown) Code = sf::Key::RShift;
}
else
{
if (LShiftPrevDown && !LShiftDown) Code = sf::Key::LShift;
else if (RShiftPrevDown && !RShiftDown) Code = sf::Key::RShift;
}
LShiftPrevDown = LShiftDown;
RShiftPrevDown = RShiftDown;
return Code;
}
///////////////////////////////////////////////////////////
/// Convert a Win32 virtual key code to a SFML key code
////////////////////////////////////////////////////////////
sf::Key::Code Win32Window::VirtualKeyCodeToSF(WPARAM VirtualKey, LPARAM Flags)
{
switch (VirtualKey)
{
// VK_SHIFT is handled by the GetShiftState function
case VK_MENU : return (Flags & (1 << 24)) ? sf::Key::RAlt : sf::Key::LAlt;
case VK_CONTROL : return (Flags & (1 << 24)) ? sf::Key::RControl : sf::Key::LControl;
case VK_LWIN : return sf::Key::LSystem;
case VK_RWIN : return sf::Key::RSystem;
case VK_APPS : return sf::Key::Menu;
case VK_OEM_1 : return sf::Key::SemiColon;
case VK_OEM_2 : return sf::Key::Slash;
case VK_OEM_PLUS : return sf::Key::Equal;
case VK_OEM_MINUS : return sf::Key::Dash;
case VK_OEM_4 : return sf::Key::LBracket;
case VK_OEM_6 : return sf::Key::RBracket;
case VK_OEM_COMMA : return sf::Key::Comma;
case VK_OEM_PERIOD : return sf::Key::Period;
case VK_OEM_7 : return sf::Key::Quote;
case VK_OEM_5 : return sf::Key::BackSlash;
case VK_OEM_3 : return sf::Key::Tilde;
case VK_ESCAPE : return sf::Key::Escape;
case VK_SPACE : return sf::Key::Space;
case VK_RETURN : return sf::Key::Return;
case VK_BACK : return sf::Key::Back;
case VK_TAB : return sf::Key::Tab;
case VK_PRIOR : return sf::Key::PageUp;
case VK_NEXT : return sf::Key::PageDown;
case VK_END : return sf::Key::End;
case VK_HOME : return sf::Key::Home;
case VK_INSERT : return sf::Key::Insert;
case VK_DELETE : return sf::Key::Delete;
case VK_ADD : return sf::Key::Add;
case VK_SUBTRACT : return sf::Key::Subtract;
case VK_MULTIPLY : return sf::Key::Multiply;
case VK_DIVIDE : return sf::Key::Divide;
case VK_PAUSE : return sf::Key::Pause;
case VK_F1 : return sf::Key::F1;
case VK_F2 : return sf::Key::F2;
case VK_F3 : return sf::Key::F3;
case VK_F4 : return sf::Key::F4;
case VK_F5 : return sf::Key::F5;
case VK_F6 : return sf::Key::F6;
case VK_F7 : return sf::Key::F7;
case VK_F8 : return sf::Key::F8;
case VK_F9 : return sf::Key::F9;
case VK_F10 : return sf::Key::F10;
case VK_F11 : return sf::Key::F11;
case VK_F12 : return sf::Key::F12;
case VK_F13 : return sf::Key::F13;
case VK_F14 : return sf::Key::F14;
case VK_F15 : return sf::Key::F15;
case VK_LEFT : return sf::Key::Left;
case VK_RIGHT : return sf::Key::Right;
case VK_UP : return sf::Key::Up;
case VK_DOWN : return sf::Key::Down;
case VK_NUMPAD0 : return sf::Key::Numpad0;
case VK_NUMPAD1 : return sf::Key::Numpad1;
case VK_NUMPAD2 : return sf::Key::Numpad2;
case VK_NUMPAD3 : return sf::Key::Numpad3;
case VK_NUMPAD4 : return sf::Key::Numpad4;
case VK_NUMPAD5 : return sf::Key::Numpad5;
case VK_NUMPAD6 : return sf::Key::Numpad6;
case VK_NUMPAD7 : return sf::Key::Numpad7;
case VK_NUMPAD8 : return sf::Key::Numpad8;
case VK_NUMPAD9 : return sf::Key::Numpad9;
case 'A' : return sf::Key::A;
case 'Z' : return sf::Key::Z;
case 'E' : return sf::Key::E;
case 'R' : return sf::Key::R;
case 'T' : return sf::Key::T;
case 'Y' : return sf::Key::Y;
case 'U' : return sf::Key::U;
case 'I' : return sf::Key::I;
case 'O' : return sf::Key::O;
case 'P' : return sf::Key::P;
case 'Q' : return sf::Key::Q;
case 'S' : return sf::Key::S;
case 'D' : return sf::Key::D;
case 'F' : return sf::Key::F;
case 'G' : return sf::Key::G;
case 'H' : return sf::Key::H;
case 'J' : return sf::Key::J;
case 'K' : return sf::Key::K;
case 'L' : return sf::Key::L;
case 'M' : return sf::Key::M;
case 'W' : return sf::Key::W;
case 'X' : return sf::Key::X;
case 'C' : return sf::Key::C;
case 'V' : return sf::Key::V;
case 'B' : return sf::Key::B;
case 'N' : return sf::Key::N;
case '0' : return sf::Key::Num0;
case '1' : return sf::Key::Num1;
case '2' : return sf::Key::Num2;
case '3' : return sf::Key::Num3;
case '4' : return sf::Key::Num4;
case '5' : return sf::Key::Num5;
case '6' : return sf::Key::Num6;
case '7' : return sf::Key::Num7;
case '8' : return sf::Key::Num8;
case '9' : return sf::Key::Num9;
}
return sf::Key::Code(0);
}
///////////////////////////////////////////////////////////
/// Win32 Callback for the window class
////////////////////////////////////////////////////////////
LRESULT CALLBACK Win32Window::GlobalOnEvent(HWND Handle, UINT Message, WPARAM WParam, LPARAM LParam)
{
// Associate handle and Window instance when the creation message is received
if (Message == WM_CREATE)
{
// Get Win32Window instance (it was passed as the last argument of CreateWindow)
long This = reinterpret_cast<long>(reinterpret_cast<CREATESTRUCT*>(LParam)->lpCreateParams);
// Set as the "user data" parameter of the window
SetWindowLongPtr(Handle, GWLP_USERDATA, This);
}
// Get the GLWindow instance corresponding to the window handle
Win32Window* Window = reinterpret_cast<Win32Window*>(GetWindowLongPtr(Handle, GWLP_USERDATA));
// Forward the event to the appropriate function
if (Window)
{
Window->ProcessEvent(Message, WParam, LParam);
if (Window->myCallback)
return CallWindowProc(reinterpret_cast<WNDPROC>(Window->myCallback), Handle, Message, WParam, LParam);
}
// We don't forward the WM_CLOSE message to prevent the OS from automatically destroying the window
if (Message == WM_CLOSE)
return 0;
return DefWindowProc(Handle, Message, WParam, LParam);
}
Reference in New Issue View Git Blame Copy Permalink