/
SDL_syswm.c
321 lines (297 loc) · 8.78 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
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
13
Lesser General Public License for more details.
14
15
16
17
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
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
26
27
28
#include "SDL_version.h"
#include "SDL_video.h"
29
#include "SDL_loadso.h"
30
#include "SDL_syswm.h"
31
32
#include "../SDL_pixels_c.h"
#include "../SDL_cursor_c.h"
33
#include "SDL_syswm_c.h"
34
#include "SDL_wingl_c.h"
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#ifdef _WIN32_WCE
#define DISABLE_ICON_SUPPORT
#endif
/* The screen icon -- needs to be freed on SDL_VideoQuit() */
HICON screen_icn = NULL;
/* Win32 icon mask semantics are different from those of SDL:
SDL applies the mask to the icon and copies result to desktop.
Win32 applies the mask to the desktop and XORs the icon on.
This means that the SDL mask needs to be applied to the icon and
then inverted and passed to Win32.
*/
void WIN_SetWMIcon(_THIS, SDL_Surface *icon, Uint8 *mask)
{
#ifdef DISABLE_ICON_SUPPORT
return;
#else
SDL_Palette *pal_256;
SDL_Surface *icon_256;
Uint8 *pdata, *pwin32;
Uint8 *mdata, *mwin32, m = 0;
int icon_len;
int icon_plen;
int icon_mlen;
int icon_pitch;
int mask_pitch;
SDL_Rect bounds;
int i, skip;
int row, col;
struct /* quasi-BMP format */ Win32Icon {
Uint32 biSize;
Sint32 biWidth;
Sint32 biHeight;
Uint16 biPlanes;
Uint16 biBitCount;
Uint32 biCompression;
Uint32 biSizeImage;
Sint32 biXPelsPerMeter;
Sint32 biYPelsPerMeter;
Uint32 biClrUsed;
Uint32 biClrImportant;
struct /* RGBQUAD -- note it's BGR ordered */ {
Uint8 rgbBlue;
Uint8 rgbGreen;
Uint8 rgbRed;
Uint8 rgbReserved;
} biColors[256];
/* Pixels:
Uint8 pixels[]
*/
/* Mask:
Uint8 mask[]
*/
} *icon_win32;
/* Allocate the win32 bmp icon and set everything to zero */
icon_pitch = ((icon->w+3)&~3);
mask_pitch = ((icon->w+7)/8);
icon_plen = icon->h*icon_pitch;
icon_mlen = icon->h*mask_pitch;
icon_len = sizeof(*icon_win32)+icon_plen+icon_mlen;
99
icon_win32 = (struct Win32Icon *)SDL_stack_alloc(Uint8, icon_len);
100
101
102
if ( icon_win32 == NULL ) {
return;
}
103
SDL_memset(icon_win32, 0, icon_len);
104
105
106
107
108
109
110
111
112
113
114
115
116
/* Set the basic BMP parameters */
icon_win32->biSize = sizeof(*icon_win32)-sizeof(icon_win32->biColors);
icon_win32->biWidth = icon->w;
icon_win32->biHeight = icon->h*2;
icon_win32->biPlanes = 1;
icon_win32->biBitCount = 8;
icon_win32->biSizeImage = icon_plen+icon_mlen;
/* Allocate a standard 256 color icon surface */
icon_256 = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
icon_win32->biBitCount, 0, 0, 0, 0);
if ( icon_256 == NULL ) {
117
SDL_stack_free(icon_win32);
118
119
120
121
122
123
return;
}
pal_256 = icon_256->format->palette;
if (icon->format->palette &&
(icon->format->BitsPerPixel == icon_256->format->BitsPerPixel)){
Uint8 black;
124
SDL_memcpy(pal_256->colors, icon->format->palette->colors,
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
pal_256->ncolors*sizeof(SDL_Color));
/* Make sure that 0 is black! */
black = SDL_FindColor(pal_256, 0x00, 0x00, 0x00);
pal_256->colors[black] = pal_256->colors[0];
pal_256->colors[0].r = 0x00;
pal_256->colors[0].g = 0x00;
pal_256->colors[0].b = 0x00;
} else {
SDL_DitherColors(pal_256->colors,
icon_256->format->BitsPerPixel);
}
/* Now copy color data to the icon BMP */
for ( i=0; i<(1<<icon_win32->biBitCount); ++i ) {
icon_win32->biColors[i].rgbRed = pal_256->colors[i].r;
icon_win32->biColors[i].rgbGreen = pal_256->colors[i].g;
icon_win32->biColors[i].rgbBlue = pal_256->colors[i].b;
}
/* Convert icon to a standard surface format. This may not always
be necessary, as Windows supports a variety of BMP formats, but
it greatly simplifies our code.
*/
148
149
150
151
152
153
bounds.x = 0;
bounds.y = 0;
bounds.w = icon->w;
bounds.h = icon->h;
if ( SDL_LowerBlit(icon, &bounds, icon_256, &bounds) < 0 ) {
SDL_stack_free(icon_win32);
154
SDL_FreeSurface(icon_256);
155
return;
156
157
158
159
}
/* Copy pixels upside-down to icon BMP, masked with the icon mask */
if ( SDL_MUSTLOCK(icon_256) || (icon_256->pitch != icon_pitch) ) {
160
SDL_stack_free(icon_win32);
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
SDL_FreeSurface(icon_256);
SDL_SetError("Warning: Unexpected icon_256 characteristics");
return;
}
pdata = (Uint8 *)icon_256->pixels;
mdata = mask;
pwin32 = (Uint8 *)icon_win32+sizeof(*icon_win32)+icon_plen-icon_pitch;
skip = icon_pitch - icon->w;
for ( row=0; row<icon->h; ++row ) {
for ( col=0; col<icon->w; ++col ) {
if ( (col%8) == 0 ) {
m = *mdata++;
}
if ( (m&0x80) != 0x00 ) {
*pwin32 = *pdata;
}
m <<= 1;
++pdata;
++pwin32;
}
pdata += skip;
pwin32 += skip;
pwin32 -= 2*icon_pitch;
}
SDL_FreeSurface(icon_256);
/* Copy mask inverted and upside-down to icon BMP */
mdata = mask;
mwin32 = (Uint8 *)icon_win32
+sizeof(*icon_win32)+icon_plen+icon_mlen-mask_pitch;
for ( row=0; row<icon->h; ++row ) {
for ( col=0; col<mask_pitch; ++col ) {
*mwin32++ = ~*mdata++;
}
mwin32 -= 2*mask_pitch;
}
/* Finally, create the icon handle and set the window icon */
screen_icn = CreateIconFromResourceEx((Uint8 *)icon_win32, icon_len,
TRUE, 0x00030000, icon->w, icon->h, LR_DEFAULTCOLOR);
if ( screen_icn == NULL ) {
SDL_SetError("Couldn't create Win32 icon handle");
} else {
204
SetClassLongPtr(SDL_Window, GCLP_HICON, (LONG_PTR)screen_icn);
205
}
206
SDL_stack_free(icon_win32);
207
208
209
#endif /* DISABLE_ICON_SUPPORT */
}
210
211
typedef BOOL (WINAPI *PtrSetWindowTextW)(HWND hWnd, LPCWSTR lpString);
212
213
214
215
void WIN_SetWMCaption(_THIS, const char *title, const char *icon)
{
#ifdef _WIN32_WCE
/* WinCE uses the UNICODE version */
216
LPWSTR lpszW = SDL_iconv_utf8_ucs2((char *)title);
217
SetWindowText(SDL_Window, lpszW);
218
SDL_free(lpszW);
219
#else
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
/*
* Try loading SetWindowTextW from kernel32.dll first, and if it exists,
* pass the UCS-2 string to it. If it doesn't, use
* WideCharToMultiByte(CP_ACP) and hope that the codepage can support the
* string data in question. This lets us keep binary compatibility with
* Win95/98/ME but still use saner Unicode on NT-based Windows.
*/
static int tried_loading = 0;
static PtrSetWindowTextW swtw = NULL;
Uint16 *lpsz = SDL_iconv_utf8_ucs2(title);
if (!tried_loading) {
HMODULE dll = LoadLibrary("user32.dll");
if (dll != NULL) {
swtw = (PtrSetWindowTextW) GetProcAddress(dll, "SetWindowTextW");
if (swtw == NULL) {
FreeLibrary(dll);
}
}
tried_loading = 1;
}
if (swtw != NULL) {
swtw(SDL_Window, lpsz);
} else {
size_t len = WideCharToMultiByte(CP_ACP, 0, lpsz, -1, NULL, 0, NULL, NULL);
char *cvt = SDL_malloc(len + 1);
WideCharToMultiByte(CP_ACP, 0, lpsz, -1, cvt, len, NULL, NULL);
SetWindowText(SDL_Window, cvt);
SDL_free(cvt);
}
250
SDL_free(lpsz);
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
#endif
}
int WIN_IconifyWindow(_THIS)
{
ShowWindow(SDL_Window, SW_MINIMIZE);
return(1);
}
SDL_GrabMode WIN_GrabInput(_THIS, SDL_GrabMode mode)
{
if ( mode == SDL_GRAB_OFF ) {
ClipCursor(NULL);
if ( !(SDL_cursorstate & CURSOR_VISIBLE) ) {
/* RJR: March 28, 2000
must be leaving relative mode, move mouse from
center of window to where it belongs ... */
POINT pt;
int x, y;
SDL_GetMouseState(&x,&y);
pt.x = x;
pt.y = y;
ClientToScreen(SDL_Window, &pt);
SetCursorPos(pt.x,pt.y);
}
276
#ifdef _WIN32_WCE
277
AllKeys(0);
278
#endif
279
280
281
282
283
284
285
286
287
288
289
290
} else {
ClipCursor(&SDL_bounds);
if ( !(SDL_cursorstate & CURSOR_VISIBLE) ) {
/* RJR: March 28, 2000
must be entering relative mode, get ready by
moving mouse to center of window ... */
POINT pt;
pt.x = (SDL_VideoSurface->w/2);
pt.y = (SDL_VideoSurface->h/2);
ClientToScreen(SDL_Window, &pt);
SetCursorPos(pt.x, pt.y);
}
291
#ifdef _WIN32_WCE
292
AllKeys(1);
293
#endif
294
295
296
297
298
299
300
301
302
303
304
}
return(mode);
}
/* If 'info' is the right version, this function fills it and returns 1.
Otherwise, in case of a version mismatch, it returns -1.
*/
int WIN_GetWMInfo(_THIS, SDL_SysWMinfo *info)
{
if ( info->version.major <= SDL_MAJOR_VERSION ) {
info->window = SDL_Window;
305
306
307
if ( SDL_VERSIONNUM(info->version.major,
info->version.minor,
info->version.patch) >=
308
SDL_VERSIONNUM(1, 2, 5) ) {
309
#if SDL_VIDEO_OPENGL
310
311
312
313
314
info->hglrc = GL_hrc;
#else
info->hglrc = NULL;
#endif
}
315
316
317
318
319
320
321
return(1);
} else {
SDL_SetError("Application not compiled with SDL %d.%d\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
return(-1);
}
}