typedef HGLRC(APIENTRY *PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC, HGLRC, const int *);

void ContextGL_Windows::release_current() {

wglMakeCurrent(hDC, nullptr);

}

void ContextGL_Windows::make_current() {

wglMakeCurrent(hDC, hRC);

}

int ContextGL_Windows::get_window_width() {

return OS::get_singleton()->get_video_mode().width;

}

int ContextGL_Windows::get_window_height() {

return OS::get_singleton()->get_video_mode().height;

}

bool ContextGL_Windows::should_vsync_via_compositor() {

if (OS::get_singleton()->is_window_fullscreen() || !OS::get_singleton()->is_vsync_via_compositor_enabled()) {

return false;

}

}

void ContextGL_Windows::swap_buffers() {

SwapBuffers(hDC);

if (use_vsync) {

}

void ContextGL_Windows::set_use_vsync(bool p_use) {

vsync_via_compositor = p_use && should_vsync_via_compositor();

if (wglSwapIntervalEXT) {

}

bool ContextGL_Windows::is_using_vsync() const {

return use_vsync;

}

#define _WGL_CONTEXT_DEBUG_BIT_ARB 0x0001

Error ContextGL_Windows::initialize() {

static PIXELFORMATDESCRIPTOR pfd = {

sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor

1,

wglMakeCurrent(hDC, hRC);

if (opengl_3_context) {

int attribs[] = {

WGL_CONTEXT_MAJOR_VERSION_ARB, 3, //we want a 3.3 context

WGL_CONTEXT_MINOR_VERSION_ARB, 3,

}

ContextGL_Windows::ContextGL_Windows(HWND hwnd, bool p_opengl_3_context) {

opengl_3_context = p_opengl_3_context;

hWnd = hwnd;

use_vsync = false;

typedef int(APIENTRY *PFNWGLGETSWAPINTERVALEXTPROC)(void);

class ContextGL_Windows {

HDC hDC;

HGLRC hRC;

unsigned int pixel_format;

// Backtrace code code based on: https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app

#include <algorithm>

#include <iterator>

#include <vector>

#pragma comment(lib, "psapi.lib")

#pragma comment(lib, "dbghelp.lib")

#endif

class CrashHandler {

bool disabled;

public:

#include <avrt.h>

#ifdef DEBUG_ENABLED

static String format_error_message(DWORD id) {

LPWSTR messageBuffer = nullptr;

size_t size = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,

nullptr, id, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&messageBuffer, 0, nullptr);

}

void DisplayServerWindows::_set_mouse_mode_impl(MouseMode p_mode) {

if (p_mode == MOUSE_MODE_CAPTURED || p_mode == MOUSE_MODE_CONFINED) {

WindowData &wd = windows[MAIN_WINDOW_ID];

ClientToScreen(wd.hWnd, (POINT *)&clipRect.right);

ClipCursor(&clipRect);

if (p_mode == MOUSE_MODE_CAPTURED) {

center = window_get_size() / 2;

POINT pos = { (int)center.x, (int)center.y };

ClientToScreen(wd.hWnd, &pos);

cursor_set_shape(c);

}

}

_THREAD_SAFE_METHOD_

if (mouse_mode == p_mode)

mouse_mode = p_mode;

}

DisplayServer::MouseMode DisplayServerWindows::mouse_get_mode() const {

return mouse_mode;

}

void DisplayServerWindows::mouse_warp_to_position(const Point2i &p_to) {

_THREAD_SAFE_METHOD_

if (!windows.has(last_focused_window)) {

}

if (mouse_mode == MOUSE_MODE_CAPTURED) {

old_x = p_to.x;

old_y = p_to.y;

} else {

POINT p;

p.x = p_to.x;

p.y = p_to.y;

SetCursorPos(p.x, p.y);

}

}

Point2i DisplayServerWindows::mouse_get_position() const {

POINT p;

GetCursorPos(&p);

return Point2i(p.x, p.y);

//return Point2(old_x, old_y);

}

int DisplayServerWindows::mouse_get_button_state() const {

return last_button_state;

}

void DisplayServerWindows::clipboard_set(const String &p_text) {

_THREAD_SAFE_METHOD_

if (!windows.has(last_focused_window)) {

CloseClipboard();

}

_THREAD_SAFE_METHOD_

if (!windows.has(last_focused_window)) {

};

if (IsClipboardFormatAvailable(CF_UNICODETEXT)) {

HGLOBAL mem = GetClipboardData(CF_UNICODETEXT);

if (mem != nullptr) {

LPWSTR ptr = (LPWSTR)GlobalLock(mem);

if (ptr != nullptr) {

ret = String((CharType *)ptr);

GlobalUnlock(mem);

};

};

} else if (IsClipboardFormatAvailable(CF_TEXT)) {

HGLOBAL mem = GetClipboardData(CF_UNICODETEXT);

if (mem != nullptr) {

LPTSTR ptr = (LPTSTR)GlobalLock(mem);

if (ptr != nullptr) {

ret.parse_utf8((const char *)ptr);

GlobalUnlock(mem);

};

} EnumScreenData;

static BOOL CALLBACK _MonitorEnumProcScreen(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {

EnumScreenData *data = (EnumScreenData *)dwData;

if (data->monitor == hMonitor) {

data->screen = data->count;

}

static BOOL CALLBACK _MonitorEnumProcCount(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {

int *data = (int *)dwData;

(*data)++;

return TRUE;

} EnumPosData;

static BOOL CALLBACK _MonitorEnumProcPos(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {

EnumPosData *data = (EnumPosData *)dwData;

if (data->count == data->screen) {

data->pos.x = lprcMonitor->left;

data->count++;

return TRUE;

}

_THREAD_SAFE_METHOD_

EnumPosData data = { 0, p_screen == SCREEN_OF_MAIN_WINDOW ? window_get_current_screen() : p_screen, Point2() };

} EnumRectData;

static BOOL CALLBACK _MonitorEnumProcSize(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {

EnumSizeData *data = (EnumSizeData *)dwData;

if (data->count == data->screen) {

data->size.x = lprcMonitor->right - lprcMonitor->left;

}

Size2i DisplayServerWindows::screen_get_size(int p_screen) const {

_THREAD_SAFE_METHOD_

EnumSizeData data = { 0, p_screen == SCREEN_OF_MAIN_WINDOW ? window_get_current_screen() : p_screen, Size2() };

}

static BOOL CALLBACK _MonitorEnumProcUsableSize(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {

EnumRectData *data = (EnumRectData *)dwData;

if (data->count == data->screen) {

MONITORINFO minfo;

}

Rect2i DisplayServerWindows::screen_get_usable_rect(int p_screen) const {

_THREAD_SAFE_METHOD_

EnumRectData data = { 0, p_screen == SCREEN_OF_MAIN_WINDOW ? window_get_current_screen() : p_screen, Rect2i() };

};

static int QueryDpiForMonitor(HMONITOR hmon, _MonitorDpiType dpiType = MDT_Default) {

int dpiX = 96, dpiY = 96;

static HMODULE Shcore = nullptr;

if (hmon && (Shcore != (HMODULE)INVALID_HANDLE_VALUE)) {

hr = getDPIForMonitor(hmon, dpiType /*MDT_Effective_DPI*/, &x, &y);

if (SUCCEEDED(hr) && (x > 0) && (y > 0)) {

dpiX = (int)x;

dpiY = (int)y;

}

}

static BOOL CALLBACK _MonitorEnumProcDpi(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {

EnumDpiData *data = (EnumDpiData *)dwData;

if (data->count == data->screen) {

data->dpi = QueryDpiForMonitor(hMonitor);

EnumDisplayMonitors(nullptr, nullptr, _MonitorEnumProcDpi, (LPARAM)&data);

return data.dpi;

}

bool DisplayServerWindows::screen_is_touchscreen(int p_screen) const {

#ifndef _MSC_VER

#warning touchscreen not working

void DisplayServerWindows::screen_set_orientation(ScreenOrientation p_orientation, int p_screen) {

}

DisplayServer::ScreenOrientation DisplayServerWindows::screen_get_orientation(int p_screen) const {

return SCREEN_LANDSCAPE;

}

void DisplayServerWindows::screen_set_keep_on(bool p_enable) {

}

bool DisplayServerWindows::screen_is_kept_on() const {

return false;

}

Vector<DisplayServer::WindowID> DisplayServerWindows::get_window_list() const {

_THREAD_SAFE_METHOD_

Vector<DisplayServer::WindowID> ret;

}

DisplayServer::WindowID DisplayServerWindows::get_window_at_screen_position(const Point2i &p_position) const {

POINT p;

p.x = p_position.x;

p.y = p_position.y;

}

DisplayServer::WindowID DisplayServerWindows::create_sub_window(WindowMode p_mode, uint32_t p_flags, const Rect2i &p_rect) {

_THREAD_SAFE_METHOD_

WindowID window_id = _create_window(p_mode, p_flags, p_rect);

return window_id;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

#endif

DestroyWindow(windows[p_window].hWnd);

windows.erase(p_window);

}

void DisplayServerWindows::window_attach_instance_id(ObjectID p_instance, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

ObjectID DisplayServerWindows::window_get_attached_instance_id(WindowID p_window) const {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), ObjectID());

}

void DisplayServerWindows::window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

void DisplayServerWindows::window_set_window_event_callback(const Callable &p_callable, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

windows[p_window].event_callback = p_callable;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

windows[p_window].input_event_callback = p_callable;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

void DisplayServerWindows::window_set_drop_files_callback(const Callable &p_callable, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

void DisplayServerWindows::window_set_title(const String &p_title, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

int DisplayServerWindows::window_get_current_screen(WindowID p_window) const {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), -1);

EnumDisplayMonitors(nullptr, nullptr, _MonitorEnumProcScreen, (LPARAM)&data);

return data.screen;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

Point2i DisplayServerWindows::window_get_position(WindowID p_window) const {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), Point2i());

return Point2(r.left, r.top);

#endif

}

POINT mouse_pos;

if (GetCursorPos(&mouse_pos) && ScreenToClient(windows[p_window].hWnd, &mouse_pos)) {

if (mouse_pos.x > 0 && mouse_pos.y > 0 && mouse_pos.x <= windows[p_window].width && mouse_pos.y <= windows[p_window].height) {

old_x = mouse_pos.x;

old_y = mouse_pos.y;

old_invalid = false;

}

}

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

WindowData &wd = windows[p_window];

#if 0

//wrong needs to account properly for decorations

RECT r;

}

void DisplayServerWindows::window_set_transient(WindowID p_window, WindowID p_parent) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(p_window == p_parent);

}

void DisplayServerWindows::window_set_max_size(const Size2i p_size, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

wd.max_size = p_size;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), Size2i());

}

void DisplayServerWindows::window_set_min_size(const Size2i p_size, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

wd.min_size = p_size;

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), Size2i());

}

void DisplayServerWindows::window_set_size(const Size2i p_size, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

ClipCursor(&crect);

}

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), Size2i());

}

return Size2();

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), Size2i());

}

void DisplayServerWindows::_get_window_style(bool p_main_window, bool p_fullscreen, bool p_borderless, bool p_resizable, bool p_maximized, bool p_no_activate_focus, DWORD &r_style, DWORD &r_style_ex) {

r_style = 0;

r_style_ex = WS_EX_WINDOWEDGE;

if (p_main_window) {

// r_style_ex |= WS_EX_TOOLWINDOW;

//}

} else {

if (p_resizable) {

if (p_maximized) {

r_style = WS_OVERLAPPEDWINDOW | WS_MAXIMIZE;

}

void DisplayServerWindows::_update_window_style(WindowID p_window, bool p_repaint, bool p_maximized) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

void DisplayServerWindows::window_set_mode(WindowMode p_mode, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

WindowData &wd = windows[p_window];

if (wd.fullscreen && p_mode != WINDOW_MODE_FULLSCREEN) {

RECT rect;

wd.fullscreen = false;

}

if (p_mode == WINDOW_MODE_MAXIMIZED) {

ShowWindow(wd.hWnd, SW_MAXIMIZE);

wd.maximized = true;

wd.minimized = false;

}

if (p_mode == WINDOW_MODE_WINDOWED) {

ShowWindow(wd.hWnd, SW_RESTORE);

wd.maximized = false;

wd.minimized = false;

}

if (p_mode == WINDOW_MODE_MINIMIZED) {

ShowWindow(wd.hWnd, SW_MINIMIZE);

wd.maximized = false;

wd.minimized = true;

MoveWindow(wd.hWnd, pos.x, pos.y, size.width, size.height, TRUE);

}

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), WINDOW_MODE_WINDOWED);

}

bool DisplayServerWindows::window_is_maximize_allowed(WindowID p_window) const {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), false);

}

void DisplayServerWindows::window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

WindowData &wd = windows[p_window];

switch (p_flag) {

case WINDOW_FLAG_RESIZE_DISABLED: {

wd.resizable = !p_enabled;

_update_window_style(p_window);

} break;

case WINDOW_FLAG_BORDERLESS: {

wd.borderless = p_enabled;

_update_window_style(p_window);

} break;

case WINDOW_FLAG_ALWAYS_ON_TOP: {

ERR_FAIL_COND_MSG(wd.transient_parent != INVALID_WINDOW_ID && p_enabled, "Transient windows can't become on top");

wd.always_on_top = p_enabled;

_update_window_style(p_window);

} break;

case WINDOW_FLAG_TRANSPARENT: {

// FIXME: Implement.

} break;

case WINDOW_FLAG_NO_FOCUS: {

wd.no_focus = p_enabled;

_update_window_style(p_window);

} break;

}

}

bool DisplayServerWindows::window_get_flag(WindowFlags p_flag, WindowID p_window) const {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), false);

const WindowData &wd = windows[p_window];

switch (p_flag) {

case WINDOW_FLAG_RESIZE_DISABLED: {

return !wd.resizable;

} break;

case WINDOW_FLAG_BORDERLESS: {

return wd.borderless;

} break;

case WINDOW_FLAG_ALWAYS_ON_TOP: {

return wd.always_on_top;

} break;

case WINDOW_FLAG_TRANSPARENT: {

// FIXME: Implement.

} break;

case WINDOW_FLAG_NO_FOCUS: {

return wd.no_focus;

} break;

}

return false;

}

void DisplayServerWindows::window_request_attention(WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

info.uCount = 2;

FlashWindowEx(&info);

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

bool DisplayServerWindows::window_can_draw(WindowID p_window) const {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND_V(!windows.has(p_window), false);

}

bool DisplayServerWindows::can_any_window_draw() const {

_THREAD_SAFE_METHOD_

for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {

}

void DisplayServerWindows::window_set_ime_active(const bool p_active, WindowID p_window) {

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

ImmAssociateContext(wd.hWnd, (HIMC)0);

}

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!windows.has(p_window));

}

void DisplayServerWindows::console_set_visible(bool p_enabled) {

_THREAD_SAFE_METHOD_

if (console_visible == p_enabled)

ShowWindow(GetConsoleWindow(), p_enabled ? SW_SHOW : SW_HIDE);

console_visible = p_enabled;

}

bool DisplayServerWindows::is_console_visible() const {

return console_visible;

}

void DisplayServerWindows::cursor_set_shape(CursorShape p_shape) {

_THREAD_SAFE_METHOD_

ERR_FAIL_INDEX(p_shape, CURSOR_MAX);

cursor_shape = p_shape;

}

DisplayServer::CursorShape DisplayServerWindows::cursor_get_shape() const {

return cursor_shape;

}

void DisplayServerWindows::GetMaskBitmaps(HBITMAP hSourceBitmap, COLORREF clrTransparent, OUT HBITMAP &hAndMaskBitmap, OUT HBITMAP &hXorMaskBitmap) {

// Get the system display DC

HDC hDC = GetDC(nullptr);

}

void DisplayServerWindows::cursor_set_custom_image(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {

_THREAD_SAFE_METHOD_

if (p_cursor.is_valid()) {

Map<CursorShape, Vector<Variant>>::Element *cursor_c = cursors_cache.find(p_shape);

if (cursor_c) {

}

DisplayServer::LatinKeyboardVariant DisplayServerWindows::get_latin_keyboard_variant() const {

_THREAD_SAFE_METHOD_

unsigned long azerty[] = {

int i = 0;

while (azerty[i] != 0) {

i++;

}

i = 0;

while (qwertz[i] != 0) {

i++;

}

i = 0;

while (dvorak[i] != 0) {

i++;

}

}

void DisplayServerWindows::process_events() {

_THREAD_SAFE_METHOD_

MSG msg;

}

while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) {

TranslateMessage(&msg);

DispatchMessageW(&msg);

}

if (!drop_events) {

_process_key_events();

}

}

void DisplayServerWindows::force_process_and_drop_events() {

_THREAD_SAFE_METHOD_

drop_events = true;

void DisplayServerWindows::release_rendering_thread() {

}

void DisplayServerWindows::make_rendering_thread() {

}

void DisplayServerWindows::swap_buffers() {

}

void DisplayServerWindows::set_native_icon(const String &p_filename) {

_THREAD_SAFE_METHOD_

FileAccess *f = FileAccess::open(p_filename, FileAccess::READ);

memdelete(f);

memdelete(icon_dir);

}

_THREAD_SAFE_METHOD_

ERR_FAIL_COND(!p_icon.is_valid());

const uint8_t *r = icon->get_data().ptr();

for (int i = 0; i < h; i++) {

for (int j = 0; j < w; j++) {

const uint8_t *rpx = &r[((h - i - 1) * w + j) * 4];

uint8_t *wpx = &wr[(i * w + j) * 4];

wpx[0] = rpx[2];

void DisplayServerWindows::vsync_set_use_via_compositor(bool p_enable) {

}

bool DisplayServerWindows::vsync_is_using_via_compositor() const {

return false;

}

#define IsTouchEvent(dw) (IsPenEvent(dw) && ((dw)&0x80))

void DisplayServerWindows::_touch_event(WindowID p_window, bool p_pressed, float p_x, float p_y, int idx) {

// Defensive

if (touch_state.has(idx) == p_pressed)

return;

event->set_pressed(p_pressed);

event->set_position(Vector2(p_x, p_y));

}

void DisplayServerWindows::_drag_event(WindowID p_window, float p_x, float p_y, int idx) {

Map<int, Vector2>::Element *curr = touch_state.find(idx);

// Defensive

if (!curr)

event->set_position(Vector2(p_x, p_y));

event->set_relative(Vector2(p_x, p_y) - curr->get());

curr->get() = Vector2(p_x, p_y);

}

void DisplayServerWindows::_send_window_event(const WindowData &wd, WindowEvent p_event) {

if (!wd.event_callback.is_null()) {

Variant event = int(p_event);

Variant *eventp = &event;

}

void DisplayServerWindows::_dispatch_input_event(const Ref<InputEvent> &p_event) {

Variant ev = p_event;

Variant *evp = &ev;

Variant ret;

ERR_FAIL_COND(!windows.has(event_from_window->get_window_id()));

Callable callable = windows[event_from_window->get_window_id()].input_event_callback;

if (callable.is_null()) {

return;

}

callable.call((const Variant **)&evp, 1, ret, ce);

callable.call((const Variant **)&evp, 1, ret, ce);

}

}

}

LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

if (drop_events) {

if (user_proc) {

return CallWindowProcW(user_proc, hWnd, uMsg, wParam, lParam);

} else {

return DefWindowProcW(hWnd, uMsg, wParam, lParam);

switch (uMsg) // Check For Windows Messages

{

case WM_SETFOCUS: {

windows[window_id].window_has_focus = true;

last_focused_window = window_id;

windows[window_id].minimized = HIWORD(wParam) != 0;

if (LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE) {

_send_window_event(windows[window_id], WINDOW_EVENT_FOCUS_IN);

windows[window_id].window_focused = true;

alt_mem = false;

control_mem = false;

shift_mem = false;

} else { // WM_INACTIVE

_send_window_event(windows[window_id], WINDOW_EVENT_FOCUS_OUT);

windows[window_id].window_focused = false;

alt_mem = false;

};

}

case WM_GETMINMAXINFO: {

if (windows[window_id].resizable && !windows[window_id].fullscreen) {

case WM_CLOSE: // Did We Receive A Close Message?

{

_send_window_event(windows[window_id], WINDOW_EVENT_CLOSE_REQUEST);

return 0; // Jump Back

}

case WM_MOUSELEAVE: {

old_invalid = true;

outside = true;

mm->set_shift(shift_mem);

mm->set_alt(alt_mem);

mm->set_button_mask(last_button_state);

Point2i c(windows[window_id].width / 2, windows[window_id].height / 2);

mm->set_position(c);

mm->set_global_position(c);

mm->set_speed(Vector2(0, 0));

if (raw->data.mouse.usFlags == MOUSE_MOVE_RELATIVE) {

mm->set_relative(Vector2(raw->data.mouse.lLastX, raw->data.mouse.lLastY));

} else if (raw->data.mouse.usFlags == MOUSE_MOVE_ABSOLUTE) {

int nScreenWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);

int nScreenHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);

int nScreenLeft = GetSystemMetrics(SM_XVIRTUALSCREEN);

}

if (windows[window_id].window_has_focus && mm->get_relative() != Vector2())

}

delete[] lpb;

} break;

case WM_POINTERUPDATE: {

if (mouse_mode == MOUSE_MODE_CAPTURED && use_raw_input) {

break;

break;

}

// Universal translation enabled; ignore OS translation

LPARAM extra = GetMessageExtraInfo();

if (IsTouchEvent(extra)) {

mm.instance();

mm->set_window_id(window_id);

mm->set_control((wParam & MK_CONTROL) != 0);

mm->set_shift((wParam & MK_SHIFT) != 0);

mm->set_global_position(Vector2(coords.x, coords.y));

if (mouse_mode == MOUSE_MODE_CAPTURED) {

Point2i c(windows[window_id].width / 2, windows[window_id].height / 2);

old_x = c.x;

old_y = c.y;

SetCursorPos(pos.x, pos.y);

}

if (old_invalid) {

old_x = mm->get_position().x;

old_y = mm->get_position().y;

old_invalid = false;

old_x = mm->get_position().x;

old_y = mm->get_position().y;

if (windows[window_id].window_has_focus) {

}

return 0; //Pointer event handled return 0 to avoid duplicate WM_MOUSEMOVE event

break;

}

// Universal translation enabled; ignore OS translation

LPARAM extra = GetMessageExtraInfo();

if (IsTouchEvent(extra)) {

mm->set_shift((wParam & MK_SHIFT) != 0);

mm->set_alt(alt_mem);

mm->set_button_mask(last_button_state);

mm->set_position(Vector2(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));

mm->set_global_position(Vector2(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));

if (mouse_mode == MOUSE_MODE_CAPTURED) {

Point2i c(windows[window_id].width / 2, windows[window_id].height / 2);

old_x = c.x;

old_y = c.y;

SetCursorPos(pos.x, pos.y);

}

if (old_invalid) {

old_x = mm->get_position().x;

old_y = mm->get_position().y;

old_invalid = false;

old_x = mm->get_position().x;

old_y = mm->get_position().y;

if (windows[window_id].window_has_focus)

} break;

case WM_LBUTTONDOWN:

case WM_LBUTTONUP:

// Universal translation enabled; ignore OS translations for left button

LPARAM extra = GetMessageExtraInfo();

if (IsTouchEvent(extra)) {

case WM_XBUTTONDBLCLK:

case WM_XBUTTONDOWN:

case WM_XBUTTONUP: {

Ref<InputEventMouseButton> mb;

mb.instance();

mb->set_window_id(window_id);

mb->set_doubleclick(true);

} break;

case WM_MOUSEWHEEL: {

mb->set_pressed(true);

int motion = (short)HIWORD(wParam);

if (!motion)

} break;

case WM_MOUSEHWHEEL: {

mb->set_pressed(true);

int motion = (short)HIWORD(wParam);

if (!motion)

}

} break;

case WM_XBUTTONDOWN: {

mb->set_pressed(true);

if (HIWORD(wParam) == XBUTTON1)

mb->set_button_index(BUTTON_XBUTTON1);

mb->set_button_index(BUTTON_XBUTTON2);

} break;

case WM_XBUTTONUP: {

mb->set_pressed(false);

if (HIWORD(wParam) == XBUTTON1)

mb->set_button_index(BUTTON_XBUTTON1);

mb->set_button_index(BUTTON_XBUTTON2);

} break;

case WM_XBUTTONDBLCLK: {

mb->set_pressed(true);

if (HIWORD(wParam) == XBUTTON1)

mb->set_button_index(BUTTON_XBUTTON1);

mb->set_position(Vector2(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));

if (mouse_mode == MOUSE_MODE_CAPTURED && !use_raw_input) {

mb->set_position(Vector2(old_x, old_y));

}

if (uMsg != WM_MOUSEWHEEL && uMsg != WM_MOUSEHWHEEL) {

if (mb->is_pressed()) {

if (++pressrc > 0 && mouse_mode != MOUSE_MODE_CAPTURED)

SetCapture(hWnd);

} else {

if (--pressrc <= 0) {

if (mouse_mode != MOUSE_MODE_CAPTURED) {

ReleaseCapture();

mb->set_global_position(mb->get_position());

if (mb->is_pressed() && mb->get_button_index() > 3 && mb->get_button_index() < 8) {

//send release for mouse wheel

Ref<InputEventMouseButton> mbd = mb->duplicate();

last_button_state &= ~(1 << (mbd->get_button_index() - 1));

mbd->set_button_mask(last_button_state);

mbd->set_pressed(false);

}

} break;

windows[window_id].last_pos = Point2(x, y);

if (!windows[window_id].rect_changed_callback.is_null()) {

Variant size = Rect2i(windows[window_id].last_pos.x, windows[window_id].last_pos.y, windows[window_id].width, windows[window_id].height);

Variant *sizep = &size;

Variant ret;

}

if (!windows[window_id].rect_changed_callback.is_null()) {

Variant size = Rect2i(windows[window_id].last_pos.x, windows[window_id].last_pos.y, windows[window_id].width, windows[window_id].height);

Variant *sizep = &size;

Variant ret;

} break;

case WM_ENTERSIZEMOVE: {

move_timer_id = SetTimer(windows[window_id].hWnd, 1, USER_TIMER_MINIMUM, (TIMERPROC) nullptr);

} break;

case WM_EXITSIZEMOVE: {

case WM_SYSKEYUP:

case WM_KEYUP:

case WM_KEYDOWN: {

if (wParam == VK_SHIFT)

shift_mem = uMsg == WM_KEYDOWN;

if (wParam == VK_CONTROL)

[[fallthrough]];

}

case WM_CHAR: {

ERR_BREAK(key_event_pos >= KEY_EVENT_BUFFER_SIZE);

// Make sure we don't include modifiers for the modifier key itself.

} break;

case WM_INPUTLANGCHANGEREQUEST: {

// FIXME: Do something?

} break;

case WM_TOUCH: {

BOOL bHandled = FALSE;

UINT cInputs = LOWORD(wParam);

PTOUCHINPUT pInputs = memnew_arr(TOUCHINPUT, cInputs);

ScreenToClient(hWnd, &touch_pos);

//do something with each touch input entry

if (ti.dwFlags & TOUCHEVENTF_MOVE) {

_drag_event(window_id, touch_pos.x, touch_pos.y, ti.dwID);

} else if (ti.dwFlags & (TOUCHEVENTF_UP | TOUCHEVENTF_DOWN)) {

_touch_event(window_id, ti.dwFlags & TOUCHEVENTF_DOWN, touch_pos.x, touch_pos.y, ti.dwID);

};

}

} break;

case WM_DEVICECHANGE: {

joypad->probe_joypads();

} break;

case WM_SETCURSOR: {

} break;

case WM_DROPFILES: {

HDROP hDropInfo = (HDROP)wParam;

const int buffsize = 4096;

wchar_t buf[buffsize];

Vector<String> files;

for (int i = 0; i < fcount; i++) {

DragQueryFileW(hDropInfo, i, buf, buffsize);

String file = buf;

files.push_back(file);

} break;

default: {

if (user_proc) {

return CallWindowProcW(user_proc, hWnd, uMsg, wParam, lParam);

};

};

}

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

DisplayServerWindows *ds_win = static_cast<DisplayServerWindows *>(DisplayServer::get_singleton());

if (ds_win)

return ds_win->WndProc(hWnd, uMsg, wParam, lParam);

}

void DisplayServerWindows::_process_key_events() {

for (int i = 0; i < key_event_pos; i++) {

KeyEvent &ke = key_event_buffer[i];

switch (ke.uMsg) {

case WM_CHAR: {

Ref<InputEventKey> k;

k.instance();

if (k->get_unicode() < 32)

k->set_unicode(0);

}

//do nothing

} break;

case WM_KEYUP:

case WM_KEYDOWN: {

Ref<InputEventKey> k;

k.instance();

k->set_echo((ke.uMsg == WM_KEYDOWN && (ke.lParam & (1 << 30))));

} break;

}

}

DisplayServer::WindowID DisplayServerWindows::_create_window(WindowMode p_mode, uint32_t p_flags, const Rect2i &p_rect) {

DWORD dwExStyle;

DWORD dwStyle;

DragAcceptFiles(wd.hWnd, true);

// IME

wd.im_himc = ImmGetContext(wd.hWnd);

ImmReleaseContext(wd.hWnd, wd.im_himc);

return id;

}

GetPointerTypePtr DisplayServerWindows::win8p_GetPointerType = nullptr;

GetPointerPenInfoPtr DisplayServerWindows::win8p_GetPointerPenInfo = nullptr;

} SHC_PROCESS_DPI_AWARENESS;

DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {

HMODULE user32_lib = LoadLibraryW(L"user32.dll");

if (user32_lib) {

win8p_GetPointerType = (GetPointerTypePtr)GetProcAddress(user32_lib, "GetPointerType");

#if defined(VULKAN_ENABLED)

if (rendering_driver == "vulkan") {

context_vulkan = memnew(VulkanContextWindows);

if (context_vulkan->initialize() != OK) {

memdelete(context_vulkan);

#endif

#if defined(OPENGL_ENABLED)

if (rendering_driver_index == VIDEO_DRIVER_GLES2) {

context_gles2 = memnew(ContextGL_Windows(hWnd, false));

if (context_gles2->initialize() != OK) {

}

}

#endif

for (int i = 0; i < WINDOW_FLAG_MAX; i++) {

if (p_flags & (1 << i)) {

window_set_flag(WindowFlags(i), true, main_window);

#if defined(VULKAN_ENABLED)

if (rendering_driver == "vulkan") {

rendering_device_vulkan = memnew(RenderingDeviceVulkan);

rendering_device_vulkan->initialize(context_vulkan);

r_error = OK;

((OS_Windows *)OS::get_singleton())->set_main_window(windows[MAIN_WINDOW_ID].hWnd);

}

Vector<String> DisplayServerWindows::get_rendering_drivers_func() {

}

DisplayServer *DisplayServerWindows::create_func(const String &p_rendering_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {

return memnew(DisplayServerWindows(p_rendering_driver, p_mode, p_flags, p_resolution, r_error));

}

void DisplayServerWindows::register_windows_driver() {

register_create_function("windows", create_func, get_rendering_drivers_func);

}

DisplayServerWindows::~DisplayServerWindows() {

delete joypad;

touch_state.clear();

#if defined(VULKAN_ENABLED)

if (rendering_driver == "vulkan") {

if (rendering_device_vulkan) {

rendering_device_vulkan->finalize();

memdelete(rendering_device_vulkan);

context_vulkan->window_destroy(MAIN_WINDOW_ID);

}

#endif

DestroyWindow(windows[MAIN_WINDOW_ID].hWnd);

}

}

#include "servers/display_server.h"

#include "core/os/os.h"

#include "core/project_settings.h"

#include "crash_handler_windows.h"

#include <windows.h>

#include <windowsx.h>

#ifndef POINTER_STRUCTURES

#define POINTER_STRUCTURES

typedef UINT32 PEN_FLAGS;

typedef UINT32 PEN_MASK;

enum tagPOINTER_INPUT_TYPE {

PT_POINTER = 0x00000001,

PT_TOUCH = 0x00000002,

#endif //POINTER_STRUCTURES

typedef BOOL(WINAPI *GetPointerTypePtr)(uint32_t p_id, POINTER_INPUT_TYPE *p_type);

typedef BOOL(WINAPI *GetPointerPenInfoPtr)(uint32_t p_id, POINTER_PEN_INFO *p_pen_info);

_THREAD_SAFE_CLASS_

static GetPointerTypePtr win8p_GetPointerType;

static GetPointerPenInfoPtr win8p_GetPointerPenInfo;

};

struct KeyEvent {

WindowID window_id;

bool alt, shift, control, meta;

UINT uMsg;

bool no_focus = false;

bool window_has_focus = false;

HBITMAP hBitmap; //DIB section for layered window

uint8_t *dib_data = nullptr;

Size2 dib_size;

uint32_t last_button_state = 0;

bool use_raw_input = false;

bool drop_events = false;

bool console_visible = false;

WNDCLASSEXW wc;

static Error fixup_embedded_pck(const String &p_path, int64_t p_embedded_start, int64_t p_embedded_size);

class EditorExportPlatformWindows : public EditorExportPlatformPC {

void _rcedit_add_data(const Ref<EditorExportPreset> &p_preset, const String &p_path);

Error _code_sign(const Ref<EditorExportPreset> &p_preset, const String &p_path);

}

void register_windows_exporter() {

EDITOR_DEF("export/windows/rcedit", "");

EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/windows/rcedit", PROPERTY_HINT_GLOBAL_FILE, "*.exe"));

#ifdef WINDOWS_ENABLED

}

static Error fixup_embedded_pck(const String &p_path, int64_t p_embedded_start, int64_t p_embedded_size) {

// Patch the header of the "pck" section in the PE file so that it corresponds to the embedded data

FileAccess *f = FileAccess::open(p_path, FileAccess::READ_WRITE);

bool found = false;

for (int i = 0; i < num_sections; ++i) {

int64_t section_header_pos = section_table_pos + i * 40;

f->seek(section_header_pos);

}

int widechar_main(int argc, wchar_t **argv) {

OS_Windows os(nullptr);

setlocale(LC_CTYPE, "");

DWORD WINAPI _xinput_get_state(DWORD dwUserIndex, XINPUT_STATE *pState) {

return ERROR_DEVICE_NOT_CONNECTED;

}

DWORD WINAPI _xinput_set_state(DWORD dwUserIndex, XINPUT_VIBRATION *pVibration) {

return ERROR_DEVICE_NOT_CONNECTED;

}

}

JoypadWindows::JoypadWindows(HWND *hwnd) {

hWnd = hwnd;

joypad_count = 0;

dinput = nullptr;

}

JoypadWindows::~JoypadWindows() {

close_joypad();

dinput->Release();

unload_xinput();

}

bool JoypadWindows::have_device(const GUID &p_guid) {

for (int i = 0; i < JOYPADS_MAX; i++) {

if (d_joypads[i].guid == p_guid) {

d_joypads[i].confirmed = true;

return true;

}

// adapted from SDL2, works a lot better than the MSDN version

bool JoypadWindows::is_xinput_device(const GUID *p_guid) {

static GUID IID_ValveStreamingGamepad = { MAKELONG(0x28DE, 0x11FF), 0x0000, 0x0000, { 0x00, 0x00, 0x50, 0x49, 0x44, 0x56, 0x49, 0x44 } };

static GUID IID_X360WiredGamepad = { MAKELONG(0x045E, 0x02A1), 0x0000, 0x0000, { 0x00, 0x00, 0x50, 0x49, 0x44, 0x56, 0x49, 0x44 } };

static GUID IID_X360WirelessGamepad = { MAKELONG(0x045E, 0x028E), 0x0000, 0x0000, { 0x00, 0x00, 0x50, 0x49, 0x44, 0x56, 0x49, 0x44 } };

return false;

}

dev_list = (PRAWINPUTDEVICELIST)malloc(sizeof(RAWINPUTDEVICELIST) * dev_list_count);

if (GetRawInputDeviceList(dev_list, &dev_list_count, sizeof(RAWINPUTDEVICELIST)) == (UINT)-1) {

free(dev_list);

return false;

}

for (unsigned int i = 0; i < dev_list_count; i++) {

RID_DEVICE_INFO rdi;

char dev_name[128];

UINT rdiSize = sizeof(rdi);

(MAKELONG(rdi.hid.dwVendorId, rdi.hid.dwProductId) == (LONG)p_guid->Data1) &&

(GetRawInputDeviceInfoA(dev_list[i].hDevice, RIDI_DEVICENAME, &dev_name, &nameSize) != (UINT)-1) &&

(strstr(dev_name, "IG_") != nullptr)) {

free(dev_list);

return true;

}

}

bool JoypadWindows::setup_dinput_joypad(const DIDEVICEINSTANCE *instance) {

HRESULT hr;

int num = input->get_unused_joy_id();

}

void JoypadWindows::setup_joypad_object(const DIDEVICEOBJECTINSTANCE *ob, int p_joy_id) {

if (ob->dwType & DIDFT_AXIS) {

HRESULT res;

DIPROPRANGE prop_range;

DIPROPDWORD dilong;

}

BOOL CALLBACK JoypadWindows::enumCallback(const DIDEVICEINSTANCE *p_instance, void *p_context) {

JoypadWindows *self = (JoypadWindows *)p_context;

if (self->is_xinput_device(&p_instance->guidProduct)) {

return DIENUM_CONTINUE;

}

BOOL CALLBACK JoypadWindows::objectsCallback(const DIDEVICEOBJECTINSTANCE *instance, void *context) {

JoypadWindows *self = (JoypadWindows *)context;

self->setup_joypad_object(instance, self->id_to_change);

}

void JoypadWindows::close_joypad(int id) {

if (id == -1) {

for (int i = 0; i < JOYPADS_MAX; i++) {

close_joypad(i);

}

return;

}

d_joypads[id].di_joy->Unacquire();

d_joypads[id].di_joy->Release();

}

void JoypadWindows::probe_joypads() {

DWORD dwResult;

for (DWORD i = 0; i < XUSER_MAX_COUNT; i++) {

ZeroMemory(&x_joypads[i].state, sizeof(XINPUT_STATE));

dwResult = xinput_get_state(i, &x_joypads[i].state);

if (dwResult == ERROR_SUCCESS) {

int id = input->get_unused_joy_id();

if (id != -1 && !x_joypads[i].attached) {

x_joypads[i].attached = true;

x_joypads[i].id = id;

x_joypads[i].ff_timestamp = 0;

input->joy_connection_changed(id, true, "XInput Gamepad", "__XINPUT_DEVICE__");

}

} else if (x_joypads[i].attached) {

x_joypads[i].attached = false;

attached_joypads[x_joypads[i].id] = false;

input->joy_connection_changed(x_joypads[i].id, false, "");

}

for (int i = 0; i < joypad_count; i++) {

d_joypads[i].confirmed = false;

}

dinput->EnumDevices(DI8DEVCLASS_GAMECTRL, enumCallback, this, DIEDFL_ATTACHEDONLY);

for (int i = 0; i < joypad_count; i++) {

if (!d_joypads[i].confirmed) {

close_joypad(i);

}

}

}

void JoypadWindows::process_joypads() {

HRESULT hr;

for (int i = 0; i < XUSER_MAX_COUNT; i++) {

xinput_gamepad &joy = x_joypads[i];

if (!joy.attached) {

continue;

xinput_get_state(i, &joy.state);

if (joy.state.dwPacketNumber != joy.last_packet) {

int button_mask = XINPUT_GAMEPAD_DPAD_UP;

for (int j = 0; j <= 16; j++) {

input->joy_button(joy.id, j, joy.state.Gamepad.wButtons & button_mask);

button_mask = button_mask * 2;

}

joy.last_packet = joy.state.dwPacketNumber;

}

uint64_t timestamp = input->get_joy_vibration_timestamp(joy.id);

}

for (int i = 0; i < JOYPADS_MAX; i++) {

dinput_gamepad *joy = &d_joypads[i];

if (!joy->attached)

post_hat(joy->id, js.rgdwPOV[0]);

for (int j = 0; j < 128; j++) {

if (js.rgbButtons[j] & 0x80) {

if (!joy->last_buttons[j]) {

input->joy_button(joy->id, j, true);

joy->last_buttons[j] = true;

}

} else {

if (joy->last_buttons[j]) {

input->joy_button(joy->id, j, false);

joy->last_buttons[j] = false;

}

int values[] = { js.lX, js.lY, js.lZ, js.lRx, js.lRy, js.lRz };

for (int j = 0; j < joy->joy_axis.size(); j++) {

for (int k = 0; k < count; k++) {

if (joy->joy_axis[j] == axes[k]) {

input->joy_axis(joy->id, j, axis_correct(values[k]));

}

void JoypadWindows::post_hat(int p_device, DWORD p_dpad) {

int dpad_val = 0;

// Should be -1 when centered, but according to docs:

// BOOL POVCentered = (LOWORD(dwPOV) == 0xFFFF);"

// https://docs.microsoft.com/en-us/previous-versions/windows/desktop/ee416628(v%3Dvs.85)#remarks

if (LOWORD(p_dpad) == 0xFFFF) {

}

if (p_dpad == 0) {

} else if (p_dpad == 4500) {

} else if (p_dpad == 9000) {

} else if (p_dpad == 13500) {

} else if (p_dpad == 18000) {

} else if (p_dpad == 22500) {

} else if (p_dpad == 27000) {

} else if (p_dpad == 31500) {

}

input->joy_hat(p_device, dpad_val);

};

if (Math::abs(p_val) < MIN_JOY_AXIS) {

jx.min = p_trigger ? 0 : -1;

jx.value = 0.0f;

return jx;

}

if (p_xinput) {

if (p_trigger) {

jx.min = 0;

jx.value = (float)p_val / MAX_TRIGGER;

}

void JoypadWindows::load_xinput() {

xinput_get_state = &_xinput_get_state;

xinput_set_state = &_xinput_set_state;

xinput_dll = LoadLibrary("XInput1_4.dll");

}

void JoypadWindows::unload_xinput() {

if (xinput_dll) {

FreeLibrary((HMODULE)xinput_dll);

}

}

};

struct dinput_gamepad {

int id;

bool attached;

bool confirmed;

};

struct xinput_gamepad {

int id;

bool attached;

bool vibrating;

HWND *hWnd;

HANDLE xinput_dll;

LPDIRECTINPUT8 dinput;

int id_to_change;

int joypad_count;

void joypad_vibration_start_xinput(int p_device, float p_weak_magnitude, float p_strong_magnitude, float p_duration, uint64_t p_timestamp);

void joypad_vibration_stop_xinput(int p_device, uint64_t p_timestamp);

XInputGetState_t xinput_get_state;

XInputSetState_t xinput_set_state;

};

#include <stdio.h>

struct _WinTranslatePair {

unsigned int keysym;

unsigned int keycode;

};

{ KEY_MASK_META, VK_LWIN }, //(0x5B)

{ KEY_MASK_META, VK_RWIN }, //(0x5C)

{ KEY_STANDBY, VK_SLEEP }, //(0x5F)

{ KEY_KP_0, VK_NUMPAD0 }, //(0x60)

{ KEY_KP_1, VK_NUMPAD1 }, //(0x61)

};

unsigned int KeyMappingWindows::get_keysym(unsigned int p_code) {

for (int i = 0; _vk_to_keycode[i].keysym != KEY_UNKNOWN; i++) {

if (_vk_to_keycode[i].keycode == p_code) {

//printf("outcode: %x\n",_vk_to_keycode[i].keysym);

unsigned int KeyMappingWindows::get_scansym(unsigned int p_code, bool p_extended) {

unsigned int keycode = KEY_UNKNOWN;

for (int i = 0; _scancode_to_keycode[i].keysym != KEY_UNKNOWN; i++) {

if (_scancode_to_keycode[i].keycode == p_code) {

keycode = _scancode_to_keycode[i].keysym;

break;

return keycode;

}

#include <winuser.h>

class KeyMappingWindows {

public:

static unsigned int get_keysym(unsigned int p_code);

static unsigned int get_scansym(unsigned int p_code, bool p_extended);

};

#endif // KEY_MAPPING_WINDOWS_H

#ifdef DEBUG_ENABLED

static String format_error_message(DWORD id) {

LPWSTR messageBuffer = nullptr;

size_t size = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,

nullptr, id, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&messageBuffer, 0, nullptr);

#endif // DEBUG_ENABLED

void RedirectIOToConsole() {

int hConHandle;

intptr_t lStdHandle;

}

void OS_Windows::initialize_debugging() {

SetConsoleCtrlHandler(HandlerRoutine, TRUE);

}

void OS_Windows::initialize() {

crash_handler.initialize();

//RedirectIOToConsole();

}

void OS_Windows::delete_main_loop() {

if (main_loop)

memdelete(main_loop);

main_loop = nullptr;

}

void OS_Windows::set_main_loop(MainLoop *p_main_loop) {

main_loop = p_main_loop;

}

void OS_Windows::finalize() {

#ifdef WINMIDI_ENABLED

driver_midi.close();

#endif

}

void OS_Windows::finalize_core() {

timeEndPeriod(1);

memdelete(process_map);

}

Error OS_Windows::open_dynamic_library(const String p_path, void *&p_library_handle, bool p_also_set_library_path) {

String path = p_path;

if (!FileAccess::exists(path)) {

}

String OS_Windows::get_name() const {

return "Windows";

}

OS::Date OS_Windows::get_date(bool utc) const {

SYSTEMTIME systemtime;

if (utc)

GetSystemTime(&systemtime);

date.dst = false;

return date;

}

SYSTEMTIME systemtime;

if (utc)

GetSystemTime(&systemtime);

}

uint64_t OS_Windows::get_unix_time() const {

FILETIME ft;

SYSTEMTIME st;

GetSystemTime(&st);

};

uint64_t OS_Windows::get_system_time_secs() const {

return get_system_time_msecs() / 1000;

}

uint64_t OS_Windows::get_system_time_msecs() const {

const uint64_t WINDOWS_TICK = 10000;

const uint64_t MSEC_TO_UNIX_EPOCH = 11644473600000LL;

}

void OS_Windows::delay_usec(uint32_t p_usec) const {

if (p_usec < 1000)

Sleep(1);

else

Sleep(p_usec / 1000);

}

uint64_t ticks;

uint64_t time;

// This is the number of clock ticks since start

}

Error OS_Windows::execute(const String &p_path, const List<String> &p_arguments, bool p_blocking, ProcessID *r_child_id, String *r_pipe, int *r_exitcode, bool read_stderr, Mutex *p_pipe_mutex) {

if (p_blocking && r_pipe) {

String argss;

argss = "\"\"" + p_path + "\"";

for (const List<String>::Element *E = p_arguments.front(); E; E = E->next()) {

argss += " \"" + E->get() + "\"";

}

char buf[65535];

while (fgets(buf, 65535, f)) {

if (p_pipe_mutex) {

p_pipe_mutex->lock();

}

String cmdline = "\"" + p_path + "\"";

const List<String>::Element *I = p_arguments.front();

while (I) {

cmdline += " \"" + I->get() + "\"";

I = I->next();

ERR_FAIL_COND_V(ret == 0, ERR_CANT_FORK);

if (p_blocking) {

DWORD ret2 = WaitForSingleObject(pi.pi.hProcess, INFINITE);

if (r_exitcode)

*r_exitcode = ret2;

CloseHandle(pi.pi.hProcess);

CloseHandle(pi.pi.hThread);

} else {

ProcessID pid = pi.pi.dwProcessId;

if (r_child_id) {

*r_child_id = pid;

};

Error OS_Windows::kill(const ProcessID &p_pid) {

ERR_FAIL_COND_V(!process_map->has(p_pid), FAILED);

const PROCESS_INFORMATION pi = (*process_map)[p_pid].pi;

}

Error OS_Windows::set_cwd(const String &p_cwd) {

if (_wchdir(p_cwd.c_str()) != 0)

return ERR_CANT_OPEN;

}

String OS_Windows::get_executable_path() const {

wchar_t bufname[4096];

GetModuleFileNameW(nullptr, bufname, 4096);

String s = bufname;

}

bool OS_Windows::has_environment(const String &p_var) const {

#ifdef MINGW_ENABLED

return _wgetenv(p_var.c_str()) != nullptr;

#else

};

String OS_Windows::get_environment(const String &p_var) const {

wchar_t wval[0x7Fff]; // MSDN says 32767 char is the maximum

int wlen = GetEnvironmentVariableW(p_var.c_str(), wval, 0x7Fff);

if (wlen > 0) {

}

bool OS_Windows::set_environment(const String &p_var, const String &p_value) const {

return (bool)SetEnvironmentVariableW(p_var.c_str(), p_value.c_str());

}

String OS_Windows::get_stdin_string(bool p_block) {

if (p_block) {

char buff[1024];

return fgets(buff, 1024, stdin);

}

Error OS_Windows::shell_open(String p_uri) {

ShellExecuteW(nullptr, nullptr, p_uri.c_str(), nullptr, nullptr, SW_SHOWNORMAL);

return OK;

}

String OS_Windows::get_locale() const {

const _WinLocale *wl = &_win_locales[0];

LANGID langid = GetUserDefaultUILanguage();

int sublang = langid & ~((1 << 9) - 1);

while (wl->locale) {

if (wl->main_lang == lang && wl->sublang == SUBLANG_NEUTRAL)

neutral = wl->locale;

}

void OS_Windows::run() {

if (!main_loop)

return;

main_loop->init();

while (!force_quit) {

DisplayServer::get_singleton()->process_events(); // get rid of pending events

if (Main::iteration())

break;

}

MainLoop *OS_Windows::get_main_loop() const {

return main_loop;

}

String OS_Windows::get_config_path() const {

if (has_environment("XDG_CONFIG_HOME")) { // unlikely, but after all why not?

return get_environment("XDG_CONFIG_HOME");

} else if (has_environment("APPDATA")) {

}

String OS_Windows::get_data_path() const {

if (has_environment("XDG_DATA_HOME")) {

return get_environment("XDG_DATA_HOME");

} else {

}

String OS_Windows::get_cache_path() const {

if (has_environment("XDG_CACHE_HOME")) {

return get_environment("XDG_CACHE_HOME");

} else if (has_environment("TEMP")) {

// Get properly capitalized engine name for system paths

String OS_Windows::get_godot_dir_name() const {

return String(VERSION_SHORT_NAME).capitalize();

}

String OS_Windows::get_system_dir(SystemDir p_dir) const {

KNOWNFOLDERID id;

switch (p_dir) {

}

String OS_Windows::get_user_data_dir() const {

String appname = get_safe_dir_name(ProjectSettings::get_singleton()->get("application/config/name"));

if (appname != "") {

bool use_custom_dir = ProjectSettings::get_singleton()->get("application/config/use_custom_user_dir");

}

String OS_Windows::get_unique_id() const {

HW_PROFILE_INFO HwProfInfo;

ERR_FAIL_COND_V(!GetCurrentHwProfile(&HwProfInfo), "");

return String(HwProfInfo.szHwProfileGuid);

}

bool OS_Windows::_check_internal_feature_support(const String &p_feature) {

return p_feature == "pc";

}

}

OS_Windows::OS_Windows(HINSTANCE _hInstance) {

force_quit = false;

hInstance = _hInstance;

#ifndef OS_WINDOWS_H

#define OS_WINDOWS_H

#include "core/os/os.h"

#include "core/project_settings.h"

#include "crash_handler_windows.h"

class JoypadWindows;

class OS_Windows : public OS {

#ifdef STDOUT_FILE

FILE *stdo;

#endif

virtual String get_stdin_string(bool p_block);

struct ProcessInfo {

STARTUPINFO si;

PROCESS_INFORMATION pi;

};

}

int VulkanContextWindows::window_create(DisplayServer::WindowID p_window_id, HWND p_window, HINSTANCE p_instance, int p_width, int p_height) {

VkWin32SurfaceCreateInfoKHR createInfo;

createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;

createInfo.pNext = nullptr;

#include <windows.h>

class VulkanContextWindows : public VulkanContext {

virtual const char *_get_platform_surface_extension() const;

public:

StdLogger::log_error(p_function, p_file, p_line, p_code, p_rationale, p_type);

#ifndef UWP_ENABLED

} else {

CONSOLE_SCREEN_BUFFER_INFO sbi; //original

GetConsoleScreenBufferInfo(hCon, &sbi);

uint32_t basecol = 0;

switch (p_type) {

}

basecol |= current_bg;

SetConsoleTextAttribute(hCon, basecol | FOREGROUND_INTENSITY);

switch (p_type) {

}

SetConsoleTextAttribute(hCon, basecol);

// `FOREGROUND_INTENSITY` alone results in gray text.

SetConsoleTextAttribute(hCon, FOREGROUND_INTENSITY);

switch (p_type) {

}

if (p_rationale && p_rationale[0]) {