This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_windowswindow.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
22
23
24
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
*/
#include "SDL_config.h"
#include "../SDL_sysvideo.h"
25
#include "../SDL_pixels_c.h"
26
27
#include "../../events/SDL_keyboard_c.h"
28
29
#include "SDL_windowsvideo.h"
#include "SDL_windowswindow.h"
31
/* This is included after SDL_windowsvideo.h, which includes windows.h */
32
33
#include "SDL_syswm.h"
34
35
36
37
/* Windows CE compatibility */
#ifndef SWP_NOCOPYBITS
#define SWP_NOCOPYBITS 0
#endif
38
39
40
/* Fake window to help with DirectInput events. */
HWND SDL_HelperWindow = NULL;
41
42
static WCHAR *SDL_HelperWindowClassName = TEXT("SDLHelperWindowInputCatcher");
static WCHAR *SDL_HelperWindowName = TEXT("SDLHelperWindowInputMsgWindow");
43
44
static ATOM SDL_HelperWindowClass = 0;
46
SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, SDL_bool created)
48
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
49
SDL_VideoDisplay *display = window->display;
50
51
52
53
54
55
56
57
SDL_WindowData *data;
/* Allocate the window data */
data = (SDL_WindowData *) SDL_malloc(sizeof(*data));
if (!data) {
SDL_OutOfMemory();
return -1;
}
58
data->window = window;
59
data->hwnd = hwnd;
60
data->hdc = GetDC(hwnd);
61
62
data->created = created;
data->mouse_pressed = SDL_FALSE;
63
data->videodata = videodata;
64
65
66
/* Associate the data with the window */
if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) {
67
ReleaseDC(hwnd, data->hdc);
68
69
70
71
72
73
SDL_free(data);
WIN_SetError("SetProp() failed");
return -1;
}
/* Set up the window proc function */
74
#ifdef GWLP_WNDPROC
75
data->wndproc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC);
76
if (data->wndproc == WIN_WindowProc) {
77
data->wndproc = NULL;
79
80
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) WIN_WindowProc);
}
81
82
83
84
85
86
87
88
#else
data->wndproc = (WNDPROC) GetWindowLong(hwnd, GWL_WNDPROC);
if (data->wndproc == WIN_WindowProc) {
data->wndproc = NULL;
} else {
SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR) WIN_WindowProc);
}
#endif
89
90
91
92
93
94
95
/* Fill in the SDL window with the window data */
{
POINT point;
point.x = 0;
point.y = 0;
if (ClientToScreen(hwnd, &point)) {
96
97
98
99
SDL_Rect bounds;
WIN_GetDisplayBounds(_this, display, &bounds);
window->x = point.x - bounds.x;
window->y = point.y - bounds.y;
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
}
}
{
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;
}
126
#ifdef WS_MAXIMIZE
127
128
if (style & WS_MAXIMIZE) {
window->flags |= SDL_WINDOW_MAXIMIZED;
129
130
131
} else
#endif
{
132
133
window->flags &= ~SDL_WINDOW_MAXIMIZED;
}
134
#ifdef WS_MINIMIZE
135
136
if (style & WS_MINIMIZE) {
window->flags |= SDL_WINDOW_MINIMIZED;
137
138
139
} else
#endif
{
140
141
142
143
144
window->flags &= ~SDL_WINDOW_MINIMIZED;
}
}
if (GetFocus() == hwnd) {
window->flags |= SDL_WINDOW_INPUT_FOCUS;
145
SDL_SetKeyboardFocus(data->window);
146
147
148
149
150
151
152
153
154
155
if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
RECT rect;
GetClientRect(hwnd, &rect);
ClientToScreen(hwnd, (LPPOINT) & rect);
ClientToScreen(hwnd, (LPPOINT) & rect + 1);
ClipCursor(&rect);
}
}
156
/* Enable multi-touch */
157
158
159
if (videodata->RegisterTouchWindow) {
videodata->RegisterTouchWindow(hwnd, (TWF_FINETOUCH|TWF_WANTPALM));
}
161
162
163
164
165
166
167
168
/* All done! */
window->driverdata = data;
return 0;
}
int
WIN_CreateWindow(_THIS, SDL_Window * window)
{
169
SDL_VideoDisplay *display = window->display;
170
171
HWND hwnd;
RECT rect;
172
SDL_Rect bounds;
173
DWORD style = (WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
174
175
176
int x, y;
int w, h;
177
if (window->flags & (SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN)) {
178
179
180
181
style |= WS_POPUP;
} else {
style |= (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
}
182
183
if ((window->flags & SDL_WINDOW_RESIZABLE)
&& !(window->flags & SDL_WINDOW_FULLSCREEN)) {
184
185
186
187
188
189
190
191
192
193
194
195
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);
196
WIN_GetDisplayBounds(_this, display, &bounds);
197
198
199
200
201
202
203
204
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;
}
}
205
206
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->x == SDL_WINDOWPOS_CENTERED) {
207
x = bounds.x + (bounds.w - w) / 2;
208
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
209
210
211
212
213
if (bounds.x == 0) {
x = CW_USEDEFAULT;
} else {
x = bounds.x;
}
215
x = bounds.x + window->x + rect.left;
217
218
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->y == SDL_WINDOWPOS_CENTERED) {
219
y = bounds.y + (bounds.h - h) / 2;
220
221
222
223
224
225
} else if (window->x == SDL_WINDOWPOS_UNDEFINED) {
if (bounds.x == 0) {
y = CW_USEDEFAULT;
} else {
y = bounds.y;
}
227
y = bounds.y + window->y + rect.top;
230
231
232
hwnd =
CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL,
SDL_Instance, NULL);
233
234
235
236
if (!hwnd) {
WIN_SetError("Couldn't create window");
return -1;
}
237
//RegisterTouchWindow(hwnd, 0);
239
240
WIN_PumpEvents(_this);
241
if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) {
242
243
244
DestroyWindow(hwnd);
return -1;
}
245
#if SDL_VIDEO_OPENGL_WGL
246
247
248
249
250
251
252
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
}
#endif
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
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);
}
278
if (SetupWindowData(_this, window, hwnd, SDL_FALSE) < 0) {
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
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);
}
}
301
302
303
304
305
306
void
WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
HICON hicon = NULL;
307
if (icon) {
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
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);
326
SDL_WriteLE32(dst, icon->h * 2);
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
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--) {
344
Uint8 *src = (Uint8 *) surface->pixels + y * surface->pitch;
345
346
347
348
SDL_RWwrite(dst, src, surface->pitch, 1);
}
SDL_FreeSurface(surface);
349
350
/* TODO: create the icon in WinCE (CreateIconFromResource isn't available) */
#ifndef _WIN32_WCE
351
352
hicon =
CreateIconFromResource(icon_bmp, icon_len, TRUE, 0x00030000);
354
355
356
357
358
}
SDL_RWclose(dst);
SDL_stack_free(icon_bmp);
}
359
/* Set the icon for the window */
360
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM) hicon);
361
362
/* Set the icon in the task manager (should we do this?) */
363
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM) hicon);
366
367
368
void
WIN_SetWindowPosition(_THIS, SDL_Window * window)
{
369
SDL_VideoDisplay *display = window->display;
370
371
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
RECT rect;
372
SDL_Rect bounds;
373
374
DWORD style;
HWND top;
375
BOOL menu;
377
int w, h;
378
379
380
381
382
383
384
385
386
387
388
389
/* 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;
390
391
392
393
394
395
#ifdef _WIN32_WCE
menu = FALSE;
#else
menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);
#endif
AdjustWindowRectEx(&rect, style, menu, 0);
396
397
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
399
WIN_GetDisplayBounds(_this, display, &bounds);
400
401
402
403
404
405
406
407
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;
}
}
408
409
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->x == SDL_WINDOWPOS_CENTERED) {
410
x = bounds.x + (bounds.w - w) / 2;
411
} else {
412
x = bounds.x + window->x + rect.left;
414
415
if ((window->flags & SDL_WINDOW_FULLSCREEN)
|| window->y == SDL_WINDOWPOS_CENTERED) {
416
y = bounds.y + (bounds.h - h) / 2;
417
} else {
418
y = bounds.y + window->y + rect.top;
421
SetWindowPos(hwnd, top, x, y, 0, 0, (SWP_NOCOPYBITS | SWP_NOSIZE));
422
423
424
425
426
427
428
429
430
}
void
WIN_SetWindowSize(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
RECT rect;
DWORD style;
HWND top;
431
BOOL menu;
432
433
434
435
436
437
438
439
440
441
442
443
444
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;
445
446
447
448
449
450
#ifdef _WIN32_WCE
menu = FALSE;
#else
menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);
#endif
AdjustWindowRectEx(&rect, style, menu, 0);
451
452
453
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
454
SetWindowPos(hwnd, top, 0, 0, w, h, (SWP_NOCOPYBITS | SWP_NOMOVE));
455
456
457
458
459
}
void
WIN_ShowWindow(_THIS, SDL_Window * window)
{
460
461
462
#ifdef _WIN32_WCE
WINCE_ShowWindow(_this, window, 1);
#else
463
464
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
ShowWindow(hwnd, SW_SHOW);
465
#endif
466
467
468
469
470
}
void
WIN_HideWindow(_THIS, SDL_Window * window)
{
471
472
473
#ifdef _WIN32_WCE
WINCE_ShowWindow(_this, window, 0);
#else
474
475
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
ShowWindow(hwnd, SW_HIDE);
476
#endif
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
}
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;
497
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
498
499
#ifdef _WIN32_WCE
500
501
if((window->flags & SDL_WINDOW_FULLSCREEN) && videodata->SHFullScreen)
videodata->SHFullScreen(hwnd, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON);
502
#endif
503
504
ShowWindow(hwnd, SW_MAXIMIZE);
505
506
507
508
509
510
}
void
WIN_MinimizeWindow(_THIS, SDL_Window * window)
{
HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
511
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
512
513
ShowWindow(hwnd, SW_MINIMIZE);
514
515
#ifdef _WIN32_WCE
516
517
if((window->flags & SDL_WINDOW_FULLSCREEN) && videodata->SHFullScreen)
videodata->SHFullScreen(hwnd, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON);
518
#endif
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
}
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;
534
535
if ((window->flags & (SDL_WINDOW_INPUT_GRABBED | SDL_WINDOW_FULLSCREEN))
&& (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
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) {
552
553
554
#ifdef _WIN32_WCE
WINCE_ShowWindow(_this, window, 0);
#endif
555
ReleaseDC(data->hwnd, data->hdc);
556
557
558
559
560
561
562
563
564
565
566
567
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) {
568
info->subsystem = SDL_SYSWM_WINDOWS;
569
info->info.win.window = hwnd;
570
571
572
573
574
575
576
577
return SDL_TRUE;
} else {
SDL_SetError("Application not compiled with SDL %d.%d\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
return SDL_FALSE;
}
}
578
579
580
581
582
583
584
/*
* Creates a HelperWindow used for DirectInput events.
*/
int
SDL_HelperWindowCreate(void)
{
585
586
HINSTANCE hInstance = GetModuleHandle(NULL);
WNDCLASS wce;
587
HWND hWndParent = NULL;
589
590
591
592
593
/* Make sure window isn't created twice. */
if (SDL_HelperWindow != NULL) {
return 0;
}
594
/* Create the class. */
595
SDL_zero(wce);
596
wce.lpfnWndProc = DefWindowProc;
597
598
599
600
wce.lpszClassName = (LPCWSTR) SDL_HelperWindowClassName;
wce.hInstance = hInstance;
/* Register the class. */
601
SDL_HelperWindowClass = RegisterClass(&wce);
602
if (SDL_HelperWindowClass == 0) {
603
WIN_SetError("Unable to create Helper Window Class");
604
605
606
return -1;
}
607
608
609
610
611
#ifndef _WIN32_WCE
/* WinCE doesn't have HWND_MESSAGE */
hWndParent = HWND_MESSAGE;
#endif
612
/* Create the window. */
613
614
SDL_HelperWindow = CreateWindowEx(0, SDL_HelperWindowClassName,
SDL_HelperWindowName,
615
WS_OVERLAPPED, CW_USEDEFAULT,
616
CW_USEDEFAULT, CW_USEDEFAULT,
617
CW_USEDEFAULT, hWndParent, NULL,
618
hInstance, NULL);
619
if (SDL_HelperWindow == NULL) {
620
UnregisterClass(SDL_HelperWindowClassName, hInstance);
621
WIN_SetError("Unable to create Helper Window");
622
623
624
625
626
627
628
629
630
631
632
633
634
return -1;
}
return 0;
}
/*
* Destroys the HelperWindow previously created with SDL_HelperWindowCreate.
*/
void
SDL_HelperWindowDestroy(void)
{
635
HINSTANCE hInstance = GetModuleHandle(NULL);
637
/* Destroy the window. */
638
639
if (SDL_HelperWindow != NULL) {
if (DestroyWindow(SDL_HelperWindow) == 0) {
640
WIN_SetError("Unable to destroy Helper Window");
641
return;
643
644
645
646
SDL_HelperWindow = NULL;
}
/* Unregister the class. */
647
648
if (SDL_HelperWindowClass != 0) {
if ((UnregisterClass(SDL_HelperWindowClassName, hInstance)) == 0) {
649
WIN_SetError("Unable to destroy Helper Window Class");
650
return;
652
653
654
655
SDL_HelperWindowClass = 0;
}
}
656
/* vi: set ts=4 sw=4 expandtab: */