This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_win32window.c
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
22
23
24
25
26
27
28
29
/* we need to define it, so that raw input is included */
#if (_WIN32_WINNT < 0x0501)
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
30
31
32
#include "SDL_config.h"
#include "../SDL_sysvideo.h"
33
#include "../SDL_pixels_c.h"
34
35
36
#include "../../events/SDL_keyboard_c.h"
#include "SDL_win32video.h"
37
#include "SDL_win32window.h"
38
39
40
/* This is included after SDL_win32video.h, which includes windows.h */
#include "SDL_syswm.h"
41
#include "SDL_gapirender.h"
43
44
45
/* Fake window to help with DirectInput events. */
HWND SDL_HelperWindow = NULL;
46
47
static WCHAR *SDL_HelperWindowClassName = TEXT("SDLHelperWindowInputCatcher");
static WCHAR *SDL_HelperWindowName = TEXT("SDLHelperWindowInputMsgWindow");
48
49
static ATOM SDL_HelperWindowClass = 0;
51
SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, SDL_bool created)
53
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
54
SDL_VideoDisplay *display = window->display;
55
56
57
58
59
60
61
62
SDL_WindowData *data;
/* Allocate the window data */
data = (SDL_WindowData *) SDL_malloc(sizeof(*data));
if (!data) {
SDL_OutOfMemory();
return -1;
}
63
data->window = window;
64
data->hwnd = hwnd;
65
data->hdc = GetDC(hwnd);
66
67
data->created = created;
data->mouse_pressed = SDL_FALSE;
68
data->videodata = videodata;
69
70
71
/* Associate the data with the window */
if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) {
72
ReleaseDC(hwnd, data->hdc);
73
74
75
76
77
78
79
SDL_free(data);
WIN_SetError("SetProp() failed");
return -1;
}
/* Set up the window proc function */
data->wndproc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC);
80
81
if (data->wndproc == DefWindowProc) {
data->wndproc = NULL;
83
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) WIN_WindowProc);
84
85
86
87
88
89
90
/* Fill in the SDL window with the window data */
{
POINT point;
point.x = 0;
point.y = 0;
if (ClientToScreen(hwnd, &point)) {
91
92
93
94
SDL_Rect bounds;
WIN_GetDisplayBounds(_this, display, &bounds);
window->x = point.x - bounds.x;
window->y = point.y - bounds.y;
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
}
}
{
RECT rect;
if (GetClientRect(hwnd, &rect)) {
window->w = rect.right;
window->h = rect.bottom;
}
}
{
DWORD style = GetWindowLong(hwnd, GWL_STYLE);
if (style & WS_VISIBLE) {
window->flags |= SDL_WINDOW_SHOWN;
} else {
window->flags &= ~SDL_WINDOW_SHOWN;
}
if (style & (WS_BORDER | WS_THICKFRAME)) {
window->flags &= ~SDL_WINDOW_BORDERLESS;
} else {
window->flags |= SDL_WINDOW_BORDERLESS;
}
if (style & WS_THICKFRAME) {
window->flags |= SDL_WINDOW_RESIZABLE;
} else {
window->flags &= ~SDL_WINDOW_RESIZABLE;
}
if (style & WS_MAXIMIZE) {
window->flags |= SDL_WINDOW_MAXIMIZED;
} else {
window->flags &= ~SDL_WINDOW_MAXIMIZED;
}
if (style & WS_MINIMIZE) {
window->flags |= SDL_WINDOW_MINIMIZED;
} else {
window->flags &= ~SDL_WINDOW_MINIMIZED;
}
}
if (GetFocus() == hwnd) {
window->flags |= SDL_WINDOW_INPUT_FOCUS;
134
SDL_SetKeyboardFocus(data->window);
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
RECT rect;
GetClientRect(hwnd, &rect);
ClientToScreen(hwnd, (LPPOINT) & rect);
ClientToScreen(hwnd, (LPPOINT) & rect + 1);
ClipCursor(&rect);
}
}
/* All done! */
window->driverdata = data;
return 0;
}
int
WIN_CreateWindow(_THIS, SDL_Window * window)
{
153
SDL_VideoDisplay *display = window->display;
154
155
HWND hwnd;
RECT rect;
156
SDL_Rect bounds;
157
DWORD style = (WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
158
159
160
int x, y;
int w, h;
161
if (window->flags & (SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN)) {
162
163
164
165
style |= WS_POPUP;
} else {
style |= (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
}
166
167
if ((window->flags & SDL_WINDOW_RESIZABLE)
&& !(window->flags & SDL_WINDOW_FULLSCREEN)) {
168
169
170
171
172
173
174
175
176
177
178
179
style |= (WS_THICKFRAME | WS_MAXIMIZEBOX);
}
/* Figure out what the window area will be */
rect.left = 0;
rect.top = 0;
rect.right = window->w;
rect.bottom = window->h;
AdjustWindowRectEx(&rect, style, FALSE, 0);
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
180
WIN_GetDisplayBounds(_this, display, &bounds);
181
182
183
184
185
186
187
188
if (window->flags & SDL_WINDOW_FULLSCREEN) {
/* The bounds when this window is visible is the fullscreen mode */
SDL_DisplayMode fullscreen_mode;
if (SDL_GetWindowDisplayMode(window, &fullscreen_mode) == 0) {
bounds.w = fullscreen_mode.w;
bounds.h = fullscreen_mode.h;
}
}
189
190
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->x == SDL_WINDOWPOS_CENTERED) {
191
x = bounds.x + (bounds.w - w) / 2;
192
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
193
194
195
196
197
if (bounds.x == 0) {
x = CW_USEDEFAULT;
} else {
x = bounds.x;
}
199
x = bounds.x + window->x + rect.left;
201
202
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->y == SDL_WINDOWPOS_CENTERED) {
203
y = bounds.y + (bounds.h - h) / 2;
204
205
206
207
208
209
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
if (bounds.x == 0) {
y = CW_USEDEFAULT;
} else {
y = bounds.y;
}
211
y = bounds.y + window->y + rect.top;
214
215
216
hwnd =
CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL,
SDL_Instance, NULL);
217
218
219
220
if (!hwnd) {
WIN_SetError("Couldn't create window");
return -1;
}
221
//RegisterTouchWindow(hwnd, 0);
222
223
224
WIN_PumpEvents(_this);
225
if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) {
226
227
228
DestroyWindow(hwnd);
return -1;
}
229
#ifdef SDL_VIDEO_OPENGL_WGL
230
231
232
233
234
235
236
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
}
#endif
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
return 0;
}
int
WIN_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
{
HWND hwnd = (HWND) data;
LPTSTR title;
int titleLen;
/* Query the title from the existing window */
titleLen = GetWindowTextLength(hwnd);
title = SDL_stack_alloc(TCHAR, titleLen + 1);
if (title) {
titleLen = GetWindowText(hwnd, title, titleLen);
} else {
titleLen = 0;
}
if (titleLen > 0) {
window->title = WIN_StringToUTF8(title);
}
if (title) {
SDL_stack_free(title);
}
262
if (SetupWindowData(_this, window, hwnd, SDL_FALSE) < 0) {
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
return -1;
}
return 0;
}
void
WIN_SetWindowTitle(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
LPTSTR title;
if (window->title) {
title = WIN_UTF8ToString(window->title);
} else {
title = NULL;
}
SetWindowText(hwnd, title ? title : TEXT(""));
if (title) {
SDL_free(title);
}
}
285
286
287
288
289
290
void
WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
HICON hicon = NULL;
291
if (icon) {
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
BYTE *icon_bmp;
int icon_len;
SDL_RWops *dst;
SDL_PixelFormat format;
SDL_Surface *surface;
/* Create temporary bitmap buffer */
icon_len = 40 + icon->h * icon->w * 4;
icon_bmp = SDL_stack_alloc(BYTE, icon_len);
dst = SDL_RWFromMem(icon_bmp, icon_len);
if (!dst) {
SDL_stack_free(icon_bmp);
return;
}
/* Write the BITMAPINFO header */
SDL_WriteLE32(dst, 40);
SDL_WriteLE32(dst, icon->w);
310
SDL_WriteLE32(dst, icon->h * 2);
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
SDL_WriteLE16(dst, 1);
SDL_WriteLE16(dst, 32);
SDL_WriteLE32(dst, BI_RGB);
SDL_WriteLE32(dst, icon->h * icon->w * 4);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
SDL_WriteLE32(dst, 0);
/* Convert the icon to a 32-bit surface with alpha channel */
SDL_InitFormat(&format, 32,
0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
surface = SDL_ConvertSurface(icon, &format, 0);
if (surface) {
/* Write the pixels upside down into the bitmap buffer */
int y = surface->h;
while (y--) {
328
Uint8 *src = (Uint8 *) surface->pixels + y * surface->pitch;
329
330
331
332
SDL_RWwrite(dst, src, surface->pitch, 1);
}
SDL_FreeSurface(surface);
333
334
/* TODO: create the icon in WinCE (CreateIconFromResource isn't available) */
#ifndef _WIN32_WCE
335
336
hicon =
CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
338
339
340
341
342
}
SDL_RWclose(dst);
SDL_stack_free(icon_bmp);
}
343
/* Set the icon for the window */
344
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM) hicon);
345
346
/* Set the icon in the task manager (should we do this?) */
347
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM) hicon);
350
351
352
void
WIN_SetWindowPosition(_THIS, SDL_Window * window)
{
353
SDL_VideoDisplay *display = window->display;
354
355
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
RECT rect;
356
SDL_Rect bounds;
357
358
DWORD style;
HWND top;
359
BOOL menu;
361
int w, h;
362
363
364
365
366
367
368
369
370
371
372
373
/* Figure out what the window area will be */
if (window->flags & SDL_WINDOW_FULLSCREEN) {
top = HWND_TOPMOST;
} else {
top = HWND_NOTOPMOST;
}
style = GetWindowLong(hwnd, GWL_STYLE);
rect.left = 0;
rect.top = 0;
rect.right = window->w;
rect.bottom = window->h;
374
375
376
377
378
379
#ifdef _WIN32_WCE
menu = FALSE;
#else
menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);
#endif
AdjustWindowRectEx(&rect, style, menu, 0);
380
381
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
383
WIN_GetDisplayBounds(_this, display, &bounds);
384
385
386
387
388
389
390
391
if (window->flags & SDL_WINDOW_FULLSCREEN) {
/* The bounds when this window is visible is the fullscreen mode */
SDL_DisplayMode fullscreen_mode;
if (SDL_GetWindowDisplayMode(window, &fullscreen_mode) == 0) {
bounds.w = fullscreen_mode.w;
bounds.h = fullscreen_mode.h;
}
}
392
393
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->x == SDL_WINDOWPOS_CENTERED) {
394
x = bounds.x + (bounds.w - w) / 2;
395
} else {
396
x = bounds.x + window->x + rect.left;
398
399
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->y == SDL_WINDOWPOS_CENTERED) {
400
y = bounds.y + (bounds.h - h) / 2;
401
} else {
402
y = bounds.y + window->y + rect.top;
405
SetWindowPos(hwnd, top, x, y, 0, 0, (SWP_NOCOPYBITS | SWP_NOSIZE));
406
407
408
409
410
411
412
413
414
}
void
WIN_SetWindowSize(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
RECT rect;
DWORD style;
HWND top;
415
BOOL menu;
416
417
418
419
420
421
422
423
424
425
426
427
428
int w, h;
/* Figure out what the window area will be */
if (window->flags & SDL_WINDOW_FULLSCREEN) {
top = HWND_TOPMOST;
} else {
top = HWND_NOTOPMOST;
}
style = GetWindowLong(hwnd, GWL_STYLE);
rect.left = 0;
rect.top = 0;
rect.right = window->w;
rect.bottom = window->h;
429
430
431
432
433
434
#ifdef _WIN32_WCE
menu = FALSE;
#else
menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);
#endif
AdjustWindowRectEx(&rect, style, menu, 0);
435
436
437
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
438
SetWindowPos(hwnd, top, 0, 0, w, h, (SWP_NOCOPYBITS | SWP_NOMOVE));
439
440
441
442
443
}
void
WIN_ShowWindow(_THIS, SDL_Window * window)
{
444
445
446
#ifdef _WIN32_WCE
WINCE_ShowWindow(_this, window, 1);
#else
447
448
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
ShowWindow(hwnd, SW_SHOW);
449
#endif
450
451
452
453
454
}
void
WIN_HideWindow(_THIS, SDL_Window * window)
{
455
456
457
#ifdef _WIN32_WCE
WINCE_ShowWindow(_this, window, 0);
#else
458
459
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
ShowWindow(hwnd, SW_HIDE);
460
#endif
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
}
void
WIN_RaiseWindow(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
HWND top;
if (window->flags & SDL_WINDOW_FULLSCREEN) {
top = HWND_TOPMOST;
} else {
top = HWND_NOTOPMOST;
}
SetWindowPos(hwnd, top, 0, 0, 0, 0, (SWP_NOMOVE | SWP_NOSIZE));
}
void
WIN_MaximizeWindow(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
481
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
482
483
#ifdef _WIN32_WCE
484
485
if((window->flags & SDL_WINDOW_FULLSCREEN) && videodata->SHFullScreen)
videodata->SHFullScreen(hwnd, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON);
486
#endif
487
488
ShowWindow(hwnd, SW_MAXIMIZE);
489
490
491
492
493
494
}
void
WIN_MinimizeWindow(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
495
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
496
497
ShowWindow(hwnd, SW_MINIMIZE);
498
499
#ifdef _WIN32_WCE
500
501
if((window->flags & SDL_WINDOW_FULLSCREEN) && videodata->SHFullScreen)
videodata->SHFullScreen(hwnd, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON);
502
#endif
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
}
void
WIN_RestoreWindow(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
ShowWindow(hwnd, SW_RESTORE);
}
void
WIN_SetWindowGrab(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
518
519
if ((window->flags & (SDL_WINDOW_INPUT_GRABBED | SDL_WINDOW_FULLSCREEN))
&& (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
RECT rect;
GetClientRect(hwnd, &rect);
ClientToScreen(hwnd, (LPPOINT) & rect);
ClientToScreen(hwnd, (LPPOINT) & rect + 1);
ClipCursor(&rect);
} else {
ClipCursor(NULL);
}
}
void
WIN_DestroyWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
if (data) {
536
537
538
#ifdef _WIN32_WCE
WINCE_ShowWindow(_this, window, 0);
#endif
539
ReleaseDC(data->hwnd, data->hdc);
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
if (data->created) {
DestroyWindow(data->hwnd);
}
SDL_free(data);
}
}
SDL_bool
WIN_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
if (info->version.major <= SDL_MAJOR_VERSION) {
info->window = hwnd;
return SDL_TRUE;
} else {
SDL_SetError("Application not compiled with SDL %d.%d\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
return SDL_FALSE;
}
}
561
562
563
564
565
566
567
/*
* Creates a HelperWindow used for DirectInput events.
*/
int
SDL_HelperWindowCreate(void)
{
568
569
HINSTANCE hInstance = GetModuleHandle(NULL);
WNDCLASS wce;
570
HWND hWndParent = NULL;
572
573
574
575
576
/* Make sure window isn't created twice. */
if (SDL_HelperWindow != NULL) {
return 0;
}
577
/* Create the class. */
578
SDL_zero(wce);
579
wce.lpfnWndProc = DefWindowProc;
580
581
582
583
wce.lpszClassName = (LPCWSTR) SDL_HelperWindowClassName;
wce.hInstance = hInstance;
/* Register the class. */
584
SDL_HelperWindowClass = RegisterClass(&wce);
585
if (SDL_HelperWindowClass == 0) {
586
WIN_SetError("Unable to create Helper Window Class");
587
588
589
return -1;
}
590
591
592
593
594
#ifndef _WIN32_WCE
/* WinCE doesn't have HWND_MESSAGE */
hWndParent = HWND_MESSAGE;
#endif
595
/* Create the window. */
596
597
SDL_HelperWindow = CreateWindowEx(0, SDL_HelperWindowClassName,
SDL_HelperWindowName,
598
WS_OVERLAPPED, CW_USEDEFAULT,
599
CW_USEDEFAULT, CW_USEDEFAULT,
600
CW_USEDEFAULT, hWndParent, NULL,
601
hInstance, NULL);
602
if (SDL_HelperWindow == NULL) {
603
UnregisterClass(SDL_HelperWindowClassName, hInstance);
604
WIN_SetError("Unable to create Helper Window");
605
606
607
608
609
610
611
612
613
614
615
616
617
return -1;
}
return 0;
}
/*
* Destroys the HelperWindow previously created with SDL_HelperWindowCreate.
*/
void
SDL_HelperWindowDestroy(void)
{
618
HINSTANCE hInstance = GetModuleHandle(NULL);
620
/* Destroy the window. */
621
622
if (SDL_HelperWindow != NULL) {
if (DestroyWindow(SDL_HelperWindow) == 0) {
623
WIN_SetError("Unable to destroy Helper Window");
624
return;
626
627
628
629
SDL_HelperWindow = NULL;
}
/* Unregister the class. */
630
631
if (SDL_HelperWindowClass != 0) {
if ((UnregisterClass(SDL_HelperWindowClassName, hInstance)) == 0) {
632
WIN_SetError("Unable to destroy Helper Window Class");
633
return;
635
636
637
638
639
SDL_HelperWindowClass = 0;
}
}
640
/* vi: set ts=4 sw=4 expandtab: */