Mercurial > sdl-ios-xcode
comparison src/video/x11/SDL_x11video.c @ 1168:045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
This allows you to run an SDL program on a system without Xlib, since it'll
just report the x11 target unavailable at runtime.
author | Ryan C. Gordon <icculus@icculus.org> |
---|---|
date | Sat, 05 Nov 2005 19:53:37 +0000 |
parents | 5c7859610bc4 |
children | 9867f3d86e44 |
comparison
equal
deleted
inserted
replaced
1167:435c2e481299 | 1168:045f186426e1 |
---|---|
83 static int X11_SetColors(_THIS, int firstcolor, int ncolors, | 83 static int X11_SetColors(_THIS, int firstcolor, int ncolors, |
84 SDL_Color *colors); | 84 SDL_Color *colors); |
85 static int X11_SetGammaRamp(_THIS, Uint16 *ramp); | 85 static int X11_SetGammaRamp(_THIS, Uint16 *ramp); |
86 static void X11_VideoQuit(_THIS); | 86 static void X11_VideoQuit(_THIS); |
87 | 87 |
88 | |
88 /* X11 driver bootstrap functions */ | 89 /* X11 driver bootstrap functions */ |
89 | 90 |
90 static int X11_Available(void) | 91 static int X11_Available(void) |
91 { | 92 { |
92 Display *display; | 93 Display *display = NULL; |
93 | 94 if ( SDL_X11_LoadSymbols() ) { |
94 display = XOpenDisplay(NULL); | 95 display = pXOpenDisplay(NULL); |
95 if ( display != NULL ) { | 96 if ( display != NULL ) { |
96 XCloseDisplay(display); | 97 pXCloseDisplay(display); |
98 } | |
99 SDL_X11_UnloadSymbols(); | |
97 } | 100 } |
98 return(display != NULL); | 101 return(display != NULL); |
99 } | 102 } |
100 | 103 |
101 static void X11_DeleteDevice(SDL_VideoDevice *device) | 104 static void X11_DeleteDevice(SDL_VideoDevice *device) |
106 } | 109 } |
107 if ( device->gl_data ) { | 110 if ( device->gl_data ) { |
108 free(device->gl_data); | 111 free(device->gl_data); |
109 } | 112 } |
110 free(device); | 113 free(device); |
114 SDL_X11_UnloadSymbols(); | |
111 } | 115 } |
112 } | 116 } |
113 | 117 |
114 static SDL_VideoDevice *X11_CreateDevice(int devindex) | 118 static SDL_VideoDevice *X11_CreateDevice(int devindex) |
115 { | 119 { |
116 SDL_VideoDevice *device; | 120 SDL_VideoDevice *device = NULL; |
117 | 121 |
118 /* Initialize all variables that we clean on shutdown */ | 122 if ( SDL_X11_LoadSymbols() ) { |
119 device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); | 123 /* Initialize all variables that we clean on shutdown */ |
120 if ( device ) { | 124 device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); |
121 memset(device, 0, (sizeof *device)); | 125 if ( device ) { |
122 device->hidden = (struct SDL_PrivateVideoData *) | 126 memset(device, 0, (sizeof *device)); |
123 malloc((sizeof *device->hidden)); | 127 device->hidden = (struct SDL_PrivateVideoData *) |
124 device->gl_data = (struct SDL_PrivateGLData *) | 128 malloc((sizeof *device->hidden)); |
125 malloc((sizeof *device->gl_data)); | 129 device->gl_data = (struct SDL_PrivateGLData *) |
126 } | 130 malloc((sizeof *device->gl_data)); |
127 if ( (device == NULL) || (device->hidden == NULL) || | 131 } |
128 (device->gl_data == NULL) ) { | 132 if ( (device == NULL) || (device->hidden == NULL) || |
129 SDL_OutOfMemory(); | 133 (device->gl_data == NULL) ) { |
130 X11_DeleteDevice(device); | 134 SDL_OutOfMemory(); |
131 return(0); | 135 X11_DeleteDevice(device); /* calls SDL_X11_UnloadSymbols(). */ |
132 } | 136 return(0); |
133 memset(device->hidden, 0, (sizeof *device->hidden)); | 137 } |
134 memset(device->gl_data, 0, (sizeof *device->gl_data)); | 138 memset(device->hidden, 0, (sizeof *device->hidden)); |
135 | 139 memset(device->gl_data, 0, (sizeof *device->gl_data)); |
136 /* Set the driver flags */ | 140 |
137 device->handles_any_size = 1; | 141 /* Set the driver flags */ |
138 | 142 device->handles_any_size = 1; |
139 /* Set the function pointers */ | 143 |
140 device->VideoInit = X11_VideoInit; | 144 /* Set the function pointers */ |
141 device->ListModes = X11_ListModes; | 145 device->VideoInit = X11_VideoInit; |
142 device->SetVideoMode = X11_SetVideoMode; | 146 device->ListModes = X11_ListModes; |
143 device->ToggleFullScreen = X11_ToggleFullScreen; | 147 device->SetVideoMode = X11_SetVideoMode; |
144 device->UpdateMouse = X11_UpdateMouse; | 148 device->ToggleFullScreen = X11_ToggleFullScreen; |
149 device->UpdateMouse = X11_UpdateMouse; | |
145 #ifdef XFREE86_XV | 150 #ifdef XFREE86_XV |
146 device->CreateYUVOverlay = X11_CreateYUVOverlay; | 151 device->CreateYUVOverlay = X11_CreateYUVOverlay; |
147 #endif | 152 #endif |
148 device->SetColors = X11_SetColors; | 153 device->SetColors = X11_SetColors; |
149 device->UpdateRects = NULL; | 154 device->UpdateRects = NULL; |
150 device->VideoQuit = X11_VideoQuit; | 155 device->VideoQuit = X11_VideoQuit; |
151 device->AllocHWSurface = X11_AllocHWSurface; | 156 device->AllocHWSurface = X11_AllocHWSurface; |
152 device->CheckHWBlit = NULL; | 157 device->CheckHWBlit = NULL; |
153 device->FillHWRect = NULL; | 158 device->FillHWRect = NULL; |
154 device->SetHWColorKey = NULL; | 159 device->SetHWColorKey = NULL; |
155 device->SetHWAlpha = NULL; | 160 device->SetHWAlpha = NULL; |
156 device->LockHWSurface = X11_LockHWSurface; | 161 device->LockHWSurface = X11_LockHWSurface; |
157 device->UnlockHWSurface = X11_UnlockHWSurface; | 162 device->UnlockHWSurface = X11_UnlockHWSurface; |
158 device->FlipHWSurface = X11_FlipHWSurface; | 163 device->FlipHWSurface = X11_FlipHWSurface; |
159 device->FreeHWSurface = X11_FreeHWSurface; | 164 device->FreeHWSurface = X11_FreeHWSurface; |
160 device->SetGamma = X11_SetVidModeGamma; | 165 device->SetGamma = X11_SetVidModeGamma; |
161 device->GetGamma = X11_GetVidModeGamma; | 166 device->GetGamma = X11_GetVidModeGamma; |
162 device->SetGammaRamp = X11_SetGammaRamp; | 167 device->SetGammaRamp = X11_SetGammaRamp; |
163 device->GetGammaRamp = NULL; | 168 device->GetGammaRamp = NULL; |
164 #ifdef HAVE_OPENGL | 169 #ifdef HAVE_OPENGL |
165 device->GL_LoadLibrary = X11_GL_LoadLibrary; | 170 device->GL_LoadLibrary = X11_GL_LoadLibrary; |
166 device->GL_GetProcAddress = X11_GL_GetProcAddress; | 171 device->GL_GetProcAddress = X11_GL_GetProcAddress; |
167 device->GL_GetAttribute = X11_GL_GetAttribute; | 172 device->GL_GetAttribute = X11_GL_GetAttribute; |
168 device->GL_MakeCurrent = X11_GL_MakeCurrent; | 173 device->GL_MakeCurrent = X11_GL_MakeCurrent; |
169 device->GL_SwapBuffers = X11_GL_SwapBuffers; | 174 device->GL_SwapBuffers = X11_GL_SwapBuffers; |
170 #endif | 175 #endif |
171 device->SetCaption = X11_SetCaption; | 176 device->SetCaption = X11_SetCaption; |
172 device->SetIcon = X11_SetIcon; | 177 device->SetIcon = X11_SetIcon; |
173 device->IconifyWindow = X11_IconifyWindow; | 178 device->IconifyWindow = X11_IconifyWindow; |
174 device->GrabInput = X11_GrabInput; | 179 device->GrabInput = X11_GrabInput; |
175 device->GetWMInfo = X11_GetWMInfo; | 180 device->GetWMInfo = X11_GetWMInfo; |
176 device->FreeWMCursor = X11_FreeWMCursor; | 181 device->FreeWMCursor = X11_FreeWMCursor; |
177 device->CreateWMCursor = X11_CreateWMCursor; | 182 device->CreateWMCursor = X11_CreateWMCursor; |
178 device->ShowWMCursor = X11_ShowWMCursor; | 183 device->ShowWMCursor = X11_ShowWMCursor; |
179 device->WarpWMCursor = X11_WarpWMCursor; | 184 device->WarpWMCursor = X11_WarpWMCursor; |
180 device->CheckMouseMode = X11_CheckMouseMode; | 185 device->CheckMouseMode = X11_CheckMouseMode; |
181 device->InitOSKeymap = X11_InitOSKeymap; | 186 device->InitOSKeymap = X11_InitOSKeymap; |
182 device->PumpEvents = X11_PumpEvents; | 187 device->PumpEvents = X11_PumpEvents; |
183 | 188 |
184 device->free = X11_DeleteDevice; | 189 device->free = X11_DeleteDevice; |
190 } | |
185 | 191 |
186 return device; | 192 return device; |
187 } | 193 } |
188 | 194 |
189 VideoBootStrap X11_bootstrap = { | 195 VideoBootStrap X11_bootstrap = { |
190 "x11", "X Window System", | 196 "x11", "X Window System", |
191 X11_Available, X11_CreateDevice | 197 X11_Available, X11_CreateDevice |
192 }; | 198 }; |
193 | |
194 /* Shared memory information */ | |
195 extern int XShmQueryExtension(Display *dpy); /* Not in X11 headers */ | |
196 | 199 |
197 /* Normal X11 error handler routine */ | 200 /* Normal X11 error handler routine */ |
198 static int (*X_handler)(Display *, XErrorEvent *) = NULL; | 201 static int (*X_handler)(Display *, XErrorEvent *) = NULL; |
199 static int x_errhandler(Display *d, XErrorEvent *e) | 202 static int x_errhandler(Display *d, XErrorEvent *e) |
200 { | 203 { |
273 WMwindow = strtol(SDL_windowid, NULL, 0); | 276 WMwindow = strtol(SDL_windowid, NULL, 0); |
274 return; | 277 return; |
275 } | 278 } |
276 | 279 |
277 if(FSwindow) | 280 if(FSwindow) |
278 XDestroyWindow(SDL_Display, FSwindow); | 281 pXDestroyWindow(SDL_Display, FSwindow); |
279 | 282 |
280 xattr.override_redirect = True; | 283 xattr.override_redirect = True; |
281 xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0; | 284 xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0; |
282 xattr.border_pixel = 0; | 285 xattr.border_pixel = 0; |
283 xattr.colormap = SDL_XColorMap; | 286 xattr.colormap = SDL_XColorMap; |
284 | 287 |
285 FSwindow = XCreateWindow(SDL_Display, SDL_Root, | 288 FSwindow = pXCreateWindow(SDL_Display, SDL_Root, |
286 xinerama_x, xinerama_y, 32, 32, 0, | 289 xinerama_x, xinerama_y, 32, 32, 0, |
287 this->hidden->depth, InputOutput, SDL_Visual, | 290 this->hidden->depth, InputOutput, SDL_Visual, |
288 CWOverrideRedirect | CWBackPixel | CWBorderPixel | 291 CWOverrideRedirect | CWBackPixel | CWBorderPixel |
289 | CWColormap, | 292 | CWColormap, |
290 &xattr); | 293 &xattr); |
291 | 294 |
292 XSelectInput(SDL_Display, FSwindow, StructureNotifyMask); | 295 pXSelectInput(SDL_Display, FSwindow, StructureNotifyMask); |
293 | 296 |
294 /* Tell KDE to keep the fullscreen window on top */ | 297 /* Tell KDE to keep the fullscreen window on top */ |
295 { | 298 { |
296 XEvent ev; | 299 XEvent ev; |
297 long mask; | 300 long mask; |
298 | 301 |
299 memset(&ev, 0, sizeof(ev)); | 302 memset(&ev, 0, sizeof(ev)); |
300 ev.xclient.type = ClientMessage; | 303 ev.xclient.type = ClientMessage; |
301 ev.xclient.window = SDL_Root; | 304 ev.xclient.window = SDL_Root; |
302 ev.xclient.message_type = XInternAtom(SDL_Display, | 305 ev.xclient.message_type = pXInternAtom(SDL_Display, |
303 "KWM_KEEP_ON_TOP", False); | 306 "KWM_KEEP_ON_TOP", False); |
304 ev.xclient.format = 32; | 307 ev.xclient.format = 32; |
305 ev.xclient.data.l[0] = FSwindow; | 308 ev.xclient.data.l[0] = FSwindow; |
306 ev.xclient.data.l[1] = CurrentTime; | 309 ev.xclient.data.l[1] = CurrentTime; |
307 mask = SubstructureRedirectMask; | 310 mask = SubstructureRedirectMask; |
308 XSendEvent(SDL_Display, SDL_Root, False, mask, &ev); | 311 pXSendEvent(SDL_Display, SDL_Root, False, mask, &ev); |
309 } | 312 } |
310 | 313 |
311 hints = NULL; | 314 hints = NULL; |
312 titleprop.value = iconprop.value = NULL; | 315 titleprop.value = iconprop.value = NULL; |
313 if(WMwindow) { | 316 if(WMwindow) { |
314 /* All window attributes must survive the recreation */ | 317 /* All window attributes must survive the recreation */ |
315 hints = XGetWMHints(SDL_Display, WMwindow); | 318 hints = pXGetWMHints(SDL_Display, WMwindow); |
316 XGetWMName(SDL_Display, WMwindow, &titleprop); | 319 pXGetWMName(SDL_Display, WMwindow, &titleprop); |
317 XGetWMIconName(SDL_Display, WMwindow, &iconprop); | 320 pXGetWMIconName(SDL_Display, WMwindow, &iconprop); |
318 XDestroyWindow(SDL_Display, WMwindow); | 321 pXDestroyWindow(SDL_Display, WMwindow); |
319 } | 322 } |
320 | 323 |
321 /* Create the window for windowed management */ | 324 /* Create the window for windowed management */ |
322 /* (reusing the xattr structure above) */ | 325 /* (reusing the xattr structure above) */ |
323 WMwindow = XCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0, | 326 WMwindow = pXCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0, |
324 this->hidden->depth, InputOutput, SDL_Visual, | 327 this->hidden->depth, InputOutput, SDL_Visual, |
325 CWBackPixel | CWBorderPixel | CWColormap, | 328 CWBackPixel | CWBorderPixel | CWColormap, |
326 &xattr); | 329 &xattr); |
327 | 330 |
328 /* Set the input hints so we get keyboard input */ | 331 /* Set the input hints so we get keyboard input */ |
329 if(!hints) { | 332 if(!hints) { |
330 hints = XAllocWMHints(); | 333 hints = pXAllocWMHints(); |
331 hints->input = True; | 334 hints->input = True; |
332 hints->flags = InputHint; | 335 hints->flags = InputHint; |
333 } | 336 } |
334 XSetWMHints(SDL_Display, WMwindow, hints); | 337 pXSetWMHints(SDL_Display, WMwindow, hints); |
335 XFree(hints); | 338 pXFree(hints); |
336 if(titleprop.value) { | 339 if(titleprop.value) { |
337 XSetWMName(SDL_Display, WMwindow, &titleprop); | 340 pXSetWMName(SDL_Display, WMwindow, &titleprop); |
338 XFree(titleprop.value); | 341 pXFree(titleprop.value); |
339 } | 342 } |
340 if(iconprop.value) { | 343 if(iconprop.value) { |
341 XSetWMIconName(SDL_Display, WMwindow, &iconprop); | 344 pXSetWMIconName(SDL_Display, WMwindow, &iconprop); |
342 XFree(iconprop.value); | 345 pXFree(iconprop.value); |
343 } | 346 } |
344 | 347 |
345 XSelectInput(SDL_Display, WMwindow, | 348 pXSelectInput(SDL_Display, WMwindow, |
346 FocusChangeMask | KeyPressMask | KeyReleaseMask | 349 FocusChangeMask | KeyPressMask | KeyReleaseMask |
347 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask); | 350 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask); |
348 | 351 |
349 /* Set the class hints so we can get an icon (AfterStep) */ | 352 /* Set the class hints so we can get an icon (AfterStep) */ |
350 { | 353 { |
351 XClassHint *classhints; | 354 XClassHint *classhints; |
352 classhints = XAllocClassHint(); | 355 classhints = pXAllocClassHint(); |
353 if(classhints != NULL) { | 356 if(classhints != NULL) { |
354 char *classname = getenv("SDL_VIDEO_X11_WMCLASS"); | 357 char *classname = getenv("SDL_VIDEO_X11_WMCLASS"); |
355 if ( ! classname ) { | 358 if ( ! classname ) { |
356 classname = "SDL_App"; | 359 classname = "SDL_App"; |
357 } | 360 } |
358 classhints->res_name = classname; | 361 classhints->res_name = classname; |
359 classhints->res_class = classname; | 362 classhints->res_class = classname; |
360 XSetClassHint(SDL_Display, WMwindow, classhints); | 363 pXSetClassHint(SDL_Display, WMwindow, classhints); |
361 XFree(classhints); | 364 pXFree(classhints); |
362 } | 365 } |
363 } | 366 } |
364 | 367 |
365 /* Allow the window to be deleted by the window manager */ | 368 /* Allow the window to be deleted by the window manager */ |
366 WM_DELETE_WINDOW = XInternAtom(SDL_Display, "WM_DELETE_WINDOW", False); | 369 WM_DELETE_WINDOW = pXInternAtom(SDL_Display, "WM_DELETE_WINDOW", False); |
367 XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1); | 370 pXSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1); |
368 } | 371 } |
369 | 372 |
370 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat) | 373 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat) |
371 { | 374 { |
372 char *display; | 375 char *display; |
373 int i; | 376 int i; |
374 | 377 |
375 /* Open the X11 display */ | 378 /* Open the X11 display */ |
376 display = NULL; /* Get it from DISPLAY environment variable */ | 379 display = NULL; /* Get it from DISPLAY environment variable */ |
377 | 380 |
378 if ( (strncmp(XDisplayName(display), ":", 1) == 0) || | 381 if ( (strncmp(pXDisplayName(display), ":", 1) == 0) || |
379 (strncmp(XDisplayName(display), "unix:", 5) == 0) ) { | 382 (strncmp(pXDisplayName(display), "unix:", 5) == 0) ) { |
380 local_X11 = 1; | 383 local_X11 = 1; |
381 } else { | 384 } else { |
382 local_X11 = 0; | 385 local_X11 = 0; |
383 } | 386 } |
384 SDL_Display = XOpenDisplay(display); | 387 SDL_Display = pXOpenDisplay(display); |
385 if ( SDL_Display == NULL ) { | 388 if ( SDL_Display == NULL ) { |
386 SDL_SetError("Couldn't open X11 display"); | 389 SDL_SetError("Couldn't open X11 display"); |
387 return(-1); | 390 return(-1); |
388 } | 391 } |
389 #ifdef X11_DEBUG | 392 #ifdef X11_DEBUG |
390 XSynchronize(SDL_Display, True); | 393 pXSynchronize(SDL_Display, True); |
391 #endif | 394 #endif |
392 | 395 |
393 /* Create an alternate X display for graphics updates -- allows us | 396 /* Create an alternate X display for graphics updates -- allows us |
394 to do graphics updates in a separate thread from event handling. | 397 to do graphics updates in a separate thread from event handling. |
395 Thread-safe X11 doesn't seem to exist. | 398 Thread-safe X11 doesn't seem to exist. |
396 */ | 399 */ |
397 GFX_Display = XOpenDisplay(display); | 400 GFX_Display = pXOpenDisplay(display); |
398 if ( GFX_Display == NULL ) { | 401 if ( GFX_Display == NULL ) { |
399 SDL_SetError("Couldn't open X11 display"); | 402 SDL_SetError("Couldn't open X11 display"); |
400 return(-1); | 403 return(-1); |
401 } | 404 } |
402 | 405 |
403 /* Set the normal X error handler */ | 406 /* Set the normal X error handler */ |
404 X_handler = XSetErrorHandler(x_errhandler); | 407 X_handler = pXSetErrorHandler(x_errhandler); |
405 | 408 |
406 /* Set the error handler if we lose the X display */ | 409 /* Set the error handler if we lose the X display */ |
407 XIO_handler = XSetIOErrorHandler(xio_errhandler); | 410 XIO_handler = pXSetIOErrorHandler(xio_errhandler); |
408 | 411 |
409 /* use default screen (from $DISPLAY) */ | 412 /* use default screen (from $DISPLAY) */ |
410 SDL_Screen = DefaultScreen(SDL_Display); | 413 SDL_Screen = DefaultScreen(SDL_Display); |
411 | 414 |
412 #ifndef NO_SHARED_MEMORY | 415 #ifndef NO_SHARED_MEMORY |
413 /* Check for MIT shared memory extension */ | 416 /* Check for MIT shared memory extension */ |
414 use_mitshm = 0; | 417 use_mitshm = 0; |
415 if ( local_X11 ) { | 418 if ( local_X11 ) { |
416 use_mitshm = XShmQueryExtension(SDL_Display); | 419 use_mitshm = pXShmQueryExtension(SDL_Display); |
417 } | 420 } |
418 #endif /* NO_SHARED_MEMORY */ | 421 #endif /* NO_SHARED_MEMORY */ |
419 | 422 |
420 /* Get the available video modes */ | 423 /* Get the available video modes */ |
421 if(X11_GetVideoModes(this) < 0) | 424 if(X11_GetVideoModes(this) < 0) |
434 } | 437 } |
435 SDL_Visual = this->hidden->visuals[i].visual; | 438 SDL_Visual = this->hidden->visuals[i].visual; |
436 if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) { | 439 if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) { |
437 SDL_XColorMap = SDL_DisplayColormap; | 440 SDL_XColorMap = SDL_DisplayColormap; |
438 } else { | 441 } else { |
439 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, | 442 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
440 SDL_Visual, AllocNone); | 443 SDL_Visual, AllocNone); |
441 } | 444 } |
442 this->hidden->depth = this->hidden->visuals[i].depth; | 445 this->hidden->depth = this->hidden->visuals[i].depth; |
443 vformat->BitsPerPixel = this->hidden->visuals[i].bpp; | 446 vformat->BitsPerPixel = this->hidden->visuals[i].bpp; |
444 if ( vformat->BitsPerPixel > 8 ) { | 447 if ( vformat->BitsPerPixel > 8 ) { |
461 | 464 |
462 /* Fill in some window manager capabilities */ | 465 /* Fill in some window manager capabilities */ |
463 this->info.wm_available = 1; | 466 this->info.wm_available = 1; |
464 | 467 |
465 /* We're done! */ | 468 /* We're done! */ |
466 XFlush(SDL_Display); | 469 pXFlush(SDL_Display); |
467 return(0); | 470 return(0); |
468 } | 471 } |
469 | 472 |
470 static void X11_DestroyWindow(_THIS, SDL_Surface *screen) | 473 static void X11_DestroyWindow(_THIS, SDL_Surface *screen) |
471 { | 474 { |
476 X11_GL_Shutdown(this); | 479 X11_GL_Shutdown(this); |
477 | 480 |
478 if ( ! SDL_windowid ) { | 481 if ( ! SDL_windowid ) { |
479 /* Hide the managed window */ | 482 /* Hide the managed window */ |
480 if ( WMwindow ) { | 483 if ( WMwindow ) { |
481 XUnmapWindow(SDL_Display, WMwindow); | 484 pXUnmapWindow(SDL_Display, WMwindow); |
482 } | 485 } |
483 if ( screen && (screen->flags & SDL_FULLSCREEN) ) { | 486 if ( screen && (screen->flags & SDL_FULLSCREEN) ) { |
484 screen->flags &= ~SDL_FULLSCREEN; | 487 screen->flags &= ~SDL_FULLSCREEN; |
485 X11_LeaveFullScreen(this); | 488 X11_LeaveFullScreen(this); |
486 } | 489 } |
487 | 490 |
488 /* Destroy the output window */ | 491 /* Destroy the output window */ |
489 if ( SDL_Window ) { | 492 if ( SDL_Window ) { |
490 XDestroyWindow(SDL_Display, SDL_Window); | 493 pXDestroyWindow(SDL_Display, SDL_Window); |
491 } | 494 } |
492 | 495 |
493 /* Free the colormap entries */ | 496 /* Free the colormap entries */ |
494 if ( SDL_XPixels ) { | 497 if ( SDL_XPixels ) { |
495 int numcolors; | 498 int numcolors; |
496 unsigned long pixel; | 499 unsigned long pixel; |
497 numcolors = SDL_Visual->map_entries; | 500 numcolors = SDL_Visual->map_entries; |
498 for ( pixel=0; pixel<numcolors; ++pixel ) { | 501 for ( pixel=0; pixel<numcolors; ++pixel ) { |
499 while ( SDL_XPixels[pixel] > 0 ) { | 502 while ( SDL_XPixels[pixel] > 0 ) { |
500 XFreeColors(GFX_Display, | 503 pXFreeColors(GFX_Display, |
501 SDL_DisplayColormap,&pixel,1,0); | 504 SDL_DisplayColormap,&pixel,1,0); |
502 --SDL_XPixels[pixel]; | 505 --SDL_XPixels[pixel]; |
503 } | 506 } |
504 } | 507 } |
505 free(SDL_XPixels); | 508 free(SDL_XPixels); |
506 SDL_XPixels = NULL; | 509 SDL_XPixels = NULL; |
507 } | 510 } |
508 | 511 |
509 /* Free the graphics context */ | 512 /* Free the graphics context */ |
510 if ( SDL_GC ) { | 513 if ( SDL_GC ) { |
511 XFreeGC(SDL_Display, SDL_GC); | 514 pXFreeGC(SDL_Display, SDL_GC); |
512 SDL_GC = 0; | 515 SDL_GC = 0; |
513 } | 516 } |
514 } | 517 } |
515 } | 518 } |
516 | 519 |
536 | 539 |
537 static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags) | 540 static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags) |
538 { | 541 { |
539 XSizeHints *hints; | 542 XSizeHints *hints; |
540 | 543 |
541 hints = XAllocSizeHints(); | 544 hints = pXAllocSizeHints(); |
542 if ( hints ) { | 545 if ( hints ) { |
543 if ( flags & SDL_RESIZABLE ) { | 546 if ( flags & SDL_RESIZABLE ) { |
544 hints->min_width = 32; | 547 hints->min_width = 32; |
545 hints->min_height = 32; | 548 hints->min_height = 32; |
546 hints->max_height = 4096; | 549 hints->max_height = 4096; |
556 hints->flags |= USPosition; | 559 hints->flags |= USPosition; |
557 } else | 560 } else |
558 /* Center it, if desired */ | 561 /* Center it, if desired */ |
559 if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) { | 562 if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) { |
560 hints->flags |= USPosition; | 563 hints->flags |= USPosition; |
561 XMoveWindow(SDL_Display, WMwindow, hints->x, hints->y); | 564 pXMoveWindow(SDL_Display, WMwindow, hints->x, hints->y); |
562 | 565 |
563 /* Flush the resize event so we don't catch it later */ | 566 /* Flush the resize event so we don't catch it later */ |
564 XSync(SDL_Display, True); | 567 pXSync(SDL_Display, True); |
565 } | 568 } |
566 XSetWMNormalHints(SDL_Display, WMwindow, hints); | 569 pXSetWMNormalHints(SDL_Display, WMwindow, hints); |
567 XFree(hints); | 570 pXFree(hints); |
568 } | 571 } |
569 | 572 |
570 /* Respect the window caption style */ | 573 /* Respect the window caption style */ |
571 if ( flags & SDL_NOFRAME ) { | 574 if ( flags & SDL_NOFRAME ) { |
572 SDL_bool set; | 575 SDL_bool set; |
574 | 577 |
575 /* We haven't modified the window manager hints yet */ | 578 /* We haven't modified the window manager hints yet */ |
576 set = SDL_FALSE; | 579 set = SDL_FALSE; |
577 | 580 |
578 /* First try to set MWM hints */ | 581 /* First try to set MWM hints */ |
579 WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); | 582 WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
580 if ( WM_HINTS != None ) { | 583 if ( WM_HINTS != None ) { |
581 /* Hints used by Motif compliant window managers */ | 584 /* Hints used by Motif compliant window managers */ |
582 struct { | 585 struct { |
583 unsigned long flags; | 586 unsigned long flags; |
584 unsigned long functions; | 587 unsigned long functions; |
585 unsigned long decorations; | 588 unsigned long decorations; |
586 long input_mode; | 589 long input_mode; |
587 unsigned long status; | 590 unsigned long status; |
588 } MWMHints = { (1L << 1), 0, 0, 0, 0 }; | 591 } MWMHints = { (1L << 1), 0, 0, 0, 0 }; |
589 | 592 |
590 XChangeProperty(SDL_Display, WMwindow, | 593 pXChangeProperty(SDL_Display, WMwindow, |
591 WM_HINTS, WM_HINTS, 32, | 594 WM_HINTS, WM_HINTS, 32, |
592 PropModeReplace, | 595 PropModeReplace, |
593 (unsigned char *)&MWMHints, | 596 (unsigned char *)&MWMHints, |
594 sizeof(MWMHints)/sizeof(long)); | 597 sizeof(MWMHints)/sizeof(long)); |
595 set = SDL_TRUE; | 598 set = SDL_TRUE; |
596 } | 599 } |
597 /* Now try to set KWM hints */ | 600 /* Now try to set KWM hints */ |
598 WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); | 601 WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
599 if ( WM_HINTS != None ) { | 602 if ( WM_HINTS != None ) { |
600 long KWMHints = 0; | 603 long KWMHints = 0; |
601 | 604 |
602 XChangeProperty(SDL_Display, WMwindow, | 605 pXChangeProperty(SDL_Display, WMwindow, |
603 WM_HINTS, WM_HINTS, 32, | 606 WM_HINTS, WM_HINTS, 32, |
604 PropModeReplace, | 607 PropModeReplace, |
605 (unsigned char *)&KWMHints, | 608 (unsigned char *)&KWMHints, |
606 sizeof(KWMHints)/sizeof(long)); | 609 sizeof(KWMHints)/sizeof(long)); |
607 set = SDL_TRUE; | 610 set = SDL_TRUE; |
608 } | 611 } |
609 /* Now try to set GNOME hints */ | 612 /* Now try to set GNOME hints */ |
610 WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True); | 613 WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True); |
611 if ( WM_HINTS != None ) { | 614 if ( WM_HINTS != None ) { |
612 long GNOMEHints = 0; | 615 long GNOMEHints = 0; |
613 | 616 |
614 XChangeProperty(SDL_Display, WMwindow, | 617 pXChangeProperty(SDL_Display, WMwindow, |
615 WM_HINTS, WM_HINTS, 32, | 618 WM_HINTS, WM_HINTS, 32, |
616 PropModeReplace, | 619 PropModeReplace, |
617 (unsigned char *)&GNOMEHints, | 620 (unsigned char *)&GNOMEHints, |
618 sizeof(GNOMEHints)/sizeof(long)); | 621 sizeof(GNOMEHints)/sizeof(long)); |
619 set = SDL_TRUE; | 622 set = SDL_TRUE; |
620 } | 623 } |
621 /* Finally set the transient hints if necessary */ | 624 /* Finally set the transient hints if necessary */ |
622 if ( ! set ) { | 625 if ( ! set ) { |
623 XSetTransientForHint(SDL_Display, WMwindow, SDL_Root); | 626 pXSetTransientForHint(SDL_Display, WMwindow, SDL_Root); |
624 } | 627 } |
625 } else { | 628 } else { |
626 SDL_bool set; | 629 SDL_bool set; |
627 Atom WM_HINTS; | 630 Atom WM_HINTS; |
628 | 631 |
629 /* We haven't modified the window manager hints yet */ | 632 /* We haven't modified the window manager hints yet */ |
630 set = SDL_FALSE; | 633 set = SDL_FALSE; |
631 | 634 |
632 /* First try to unset MWM hints */ | 635 /* First try to unset MWM hints */ |
633 WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); | 636 WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
634 if ( WM_HINTS != None ) { | 637 if ( WM_HINTS != None ) { |
635 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); | 638 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
636 set = SDL_TRUE; | 639 set = SDL_TRUE; |
637 } | 640 } |
638 /* Now try to unset KWM hints */ | 641 /* Now try to unset KWM hints */ |
639 WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); | 642 WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
640 if ( WM_HINTS != None ) { | 643 if ( WM_HINTS != None ) { |
641 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); | 644 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
642 set = SDL_TRUE; | 645 set = SDL_TRUE; |
643 } | 646 } |
644 /* Now try to unset GNOME hints */ | 647 /* Now try to unset GNOME hints */ |
645 WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True); | 648 WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True); |
646 if ( WM_HINTS != None ) { | 649 if ( WM_HINTS != None ) { |
647 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); | 650 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
648 set = SDL_TRUE; | 651 set = SDL_TRUE; |
649 } | 652 } |
650 /* Finally unset the transient hints if necessary */ | 653 /* Finally unset the transient hints if necessary */ |
651 if ( ! set ) { | 654 if ( ! set ) { |
652 /* NOTE: Does this work? */ | 655 /* NOTE: Does this work? */ |
653 XSetTransientForHint(SDL_Display, WMwindow, None); | 656 pXSetTransientForHint(SDL_Display, WMwindow, None); |
654 } | 657 } |
655 } | 658 } |
656 } | 659 } |
657 | 660 |
658 static int X11_CreateWindow(_THIS, SDL_Surface *screen, | 661 static int X11_CreateWindow(_THIS, SDL_Surface *screen, |
686 vis = vi->visual; | 689 vis = vi->visual; |
687 depth = vi->depth; | 690 depth = vi->depth; |
688 } else if ( SDL_windowid ) { | 691 } else if ( SDL_windowid ) { |
689 XWindowAttributes a; | 692 XWindowAttributes a; |
690 | 693 |
691 XGetWindowAttributes(SDL_Display, SDL_Window, &a); | 694 pXGetWindowAttributes(SDL_Display, SDL_Window, &a); |
692 vis = a.visual; | 695 vis = a.visual; |
693 depth = a.depth; | 696 depth = a.depth; |
694 } else { | 697 } else { |
695 for ( i = 0; i < this->hidden->nvisuals; i++ ) { | 698 for ( i = 0; i < this->hidden->nvisuals; i++ ) { |
696 if ( this->hidden->visuals[i].bpp == bpp ) | 699 if ( this->hidden->visuals[i].bpp == bpp ) |
715 vis->red_mask, vis->green_mask, vis->blue_mask, 0) ) | 718 vis->red_mask, vis->green_mask, vis->blue_mask, 0) ) |
716 return -1; | 719 return -1; |
717 | 720 |
718 /* Create the appropriate colormap */ | 721 /* Create the appropriate colormap */ |
719 if ( SDL_XColorMap != SDL_DisplayColormap ) { | 722 if ( SDL_XColorMap != SDL_DisplayColormap ) { |
720 XFreeColormap(SDL_Display, SDL_XColorMap); | 723 pXFreeColormap(SDL_Display, SDL_XColorMap); |
721 } | 724 } |
722 if ( SDL_Visual->class == PseudoColor ) { | 725 if ( SDL_Visual->class == PseudoColor ) { |
723 int ncolors; | 726 int ncolors; |
724 | 727 |
725 /* Allocate the pixel flags */ | 728 /* Allocate the pixel flags */ |
735 if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) { | 738 if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) { |
736 flags |= SDL_HWPALETTE; | 739 flags |= SDL_HWPALETTE; |
737 } | 740 } |
738 if ( flags & SDL_HWPALETTE ) { | 741 if ( flags & SDL_HWPALETTE ) { |
739 screen->flags |= SDL_HWPALETTE; | 742 screen->flags |= SDL_HWPALETTE; |
740 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, | 743 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
741 SDL_Visual, AllocAll); | 744 SDL_Visual, AllocAll); |
742 } else { | 745 } else { |
743 SDL_XColorMap = SDL_DisplayColormap; | 746 SDL_XColorMap = SDL_DisplayColormap; |
744 } | 747 } |
745 } else if ( SDL_Visual->class == DirectColor ) { | 748 } else if ( SDL_Visual->class == DirectColor ) { |
746 | 749 |
747 /* Create a colormap which we can manipulate for gamma */ | 750 /* Create a colormap which we can manipulate for gamma */ |
748 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, | 751 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
749 SDL_Visual, AllocAll); | 752 SDL_Visual, AllocAll); |
750 XSync(SDL_Display, False); | 753 pXSync(SDL_Display, False); |
751 | 754 |
752 /* Initialize the colormap to the identity mapping */ | 755 /* Initialize the colormap to the identity mapping */ |
753 SDL_GetGammaRamp(0, 0, 0); | 756 SDL_GetGammaRamp(0, 0, 0); |
754 this->screen = screen; | 757 this->screen = screen; |
755 X11_SetGammaRamp(this, this->gamma); | 758 X11_SetGammaRamp(this, this->gamma); |
756 this->screen = NULL; | 759 this->screen = NULL; |
757 } else { | 760 } else { |
758 /* Create a read-only colormap for our window */ | 761 /* Create a read-only colormap for our window */ |
759 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, | 762 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
760 SDL_Visual, AllocNone); | 763 SDL_Visual, AllocNone); |
761 } | 764 } |
762 | 765 |
763 /* Recreate the auxiliary windows, if needed (required for GL) */ | 766 /* Recreate the auxiliary windows, if needed (required for GL) */ |
764 if ( vis_change ) | 767 if ( vis_change ) |
767 if(screen->flags & SDL_HWPALETTE) { | 770 if(screen->flags & SDL_HWPALETTE) { |
768 /* Since the full-screen window might have got a nonzero background | 771 /* Since the full-screen window might have got a nonzero background |
769 colour (0 is white on some displays), we should reset the | 772 colour (0 is white on some displays), we should reset the |
770 background to 0 here since that is what the user expects | 773 background to 0 here since that is what the user expects |
771 with a private colormap */ | 774 with a private colormap */ |
772 XSetWindowBackground(SDL_Display, FSwindow, 0); | 775 pXSetWindowBackground(SDL_Display, FSwindow, 0); |
773 XClearWindow(SDL_Display, FSwindow); | 776 pXClearWindow(SDL_Display, FSwindow); |
774 } | 777 } |
775 | 778 |
776 /* resize the (possibly new) window manager window */ | 779 /* resize the (possibly new) window manager window */ |
777 if( !SDL_windowid ) { | 780 if( !SDL_windowid ) { |
778 X11_SetSizeHints(this, w, h, flags); | 781 X11_SetSizeHints(this, w, h, flags); |
779 current_w = w; | 782 current_w = w; |
780 current_h = h; | 783 current_h = h; |
781 XResizeWindow(SDL_Display, WMwindow, w, h); | 784 pXResizeWindow(SDL_Display, WMwindow, w, h); |
782 } | 785 } |
783 | 786 |
784 /* Create (or use) the X11 display window */ | 787 /* Create (or use) the X11 display window */ |
785 if ( !SDL_windowid ) { | 788 if ( !SDL_windowid ) { |
786 if ( flags & SDL_OPENGL ) { | 789 if ( flags & SDL_OPENGL ) { |
791 XSetWindowAttributes swa; | 794 XSetWindowAttributes swa; |
792 | 795 |
793 swa.background_pixel = 0; | 796 swa.background_pixel = 0; |
794 swa.border_pixel = 0; | 797 swa.border_pixel = 0; |
795 swa.colormap = SDL_XColorMap; | 798 swa.colormap = SDL_XColorMap; |
796 SDL_Window = XCreateWindow(SDL_Display, WMwindow, | 799 SDL_Window = pXCreateWindow(SDL_Display, WMwindow, |
797 0, 0, w, h, 0, depth, | 800 0, 0, w, h, 0, depth, |
798 InputOutput, SDL_Visual, | 801 InputOutput, SDL_Visual, |
799 CWBackPixel | CWBorderPixel | 802 CWBackPixel | CWBorderPixel |
800 | CWColormap, &swa); | 803 | CWColormap, &swa); |
801 } | 804 } |
802 /* Only manage our input if we own the window */ | 805 /* Only manage our input if we own the window */ |
803 XSelectInput(SDL_Display, SDL_Window, | 806 pXSelectInput(SDL_Display, SDL_Window, |
804 ( EnterWindowMask | LeaveWindowMask | 807 ( EnterWindowMask | LeaveWindowMask |
805 | ButtonPressMask | ButtonReleaseMask | 808 | ButtonPressMask | ButtonReleaseMask |
806 | PointerMotionMask | ExposureMask )); | 809 | PointerMotionMask | ExposureMask )); |
807 } | 810 } |
808 | 811 |
815 } | 818 } |
816 } else { | 819 } else { |
817 XGCValues gcv; | 820 XGCValues gcv; |
818 | 821 |
819 gcv.graphics_exposures = False; | 822 gcv.graphics_exposures = False; |
820 SDL_GC = XCreateGC(SDL_Display, SDL_Window, | 823 SDL_GC = pXCreateGC(SDL_Display, SDL_Window, |
821 GCGraphicsExposures, &gcv); | 824 GCGraphicsExposures, &gcv); |
822 if ( ! SDL_GC ) { | 825 if ( ! SDL_GC ) { |
823 SDL_SetError("Couldn't create graphics context"); | 826 SDL_SetError("Couldn't create graphics context"); |
824 return(-1); | 827 return(-1); |
825 } | 828 } |
826 } | 829 } |
827 | 830 |
828 /* Set our colormaps when not setting a GL mode */ | 831 /* Set our colormaps when not setting a GL mode */ |
829 if ( ! (flags & SDL_OPENGL) ) { | 832 if ( ! (flags & SDL_OPENGL) ) { |
830 XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); | 833 pXSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); |
831 if( !SDL_windowid ) { | 834 if( !SDL_windowid ) { |
832 XSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap); | 835 pXSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap); |
833 XSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap); | 836 pXSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap); |
834 } | 837 } |
835 } | 838 } |
836 | 839 |
837 #if 0 /* This is an experiment - are the graphics faster now? - nope. */ | 840 #if 0 /* This is an experiment - are the graphics faster now? - nope. */ |
838 if ( getenv("SDL_VIDEO_X11_BACKINGSTORE") ) | 841 if ( getenv("SDL_VIDEO_X11_BACKINGSTORE") ) |
843 XSetWindowAttributes a; | 846 XSetWindowAttributes a; |
844 | 847 |
845 xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen); | 848 xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen); |
846 a.backing_store = DoesBackingStore(xscreen); | 849 a.backing_store = DoesBackingStore(xscreen); |
847 if ( a.backing_store != NotUseful ) { | 850 if ( a.backing_store != NotUseful ) { |
848 XChangeWindowAttributes(SDL_Display, SDL_Window, | 851 pXChangeWindowAttributes(SDL_Display, SDL_Window, |
849 CWBackingStore, &a); | 852 CWBackingStore, &a); |
850 } | 853 } |
851 } | 854 } |
852 | 855 |
853 /* Update the internal keyboard state */ | 856 /* Update the internal keyboard state */ |
877 } | 880 } |
878 } | 881 } |
879 | 882 |
880 /* Map them both and go fullscreen, if requested */ | 883 /* Map them both and go fullscreen, if requested */ |
881 if ( ! SDL_windowid ) { | 884 if ( ! SDL_windowid ) { |
882 XMapWindow(SDL_Display, SDL_Window); | 885 pXMapWindow(SDL_Display, SDL_Window); |
883 XMapWindow(SDL_Display, WMwindow); | 886 pXMapWindow(SDL_Display, WMwindow); |
884 X11_WaitMapped(this, WMwindow); | 887 X11_WaitMapped(this, WMwindow); |
885 if ( flags & SDL_FULLSCREEN ) { | 888 if ( flags & SDL_FULLSCREEN ) { |
886 screen->flags |= SDL_FULLSCREEN; | 889 screen->flags |= SDL_FULLSCREEN; |
887 X11_EnterFullScreen(this); | 890 X11_EnterFullScreen(this); |
888 } else { | 891 } else { |
898 if ( ! SDL_windowid ) { | 901 if ( ! SDL_windowid ) { |
899 /* Resize the window manager window */ | 902 /* Resize the window manager window */ |
900 X11_SetSizeHints(this, w, h, flags); | 903 X11_SetSizeHints(this, w, h, flags); |
901 current_w = w; | 904 current_w = w; |
902 current_h = h; | 905 current_h = h; |
903 XResizeWindow(SDL_Display, WMwindow, w, h); | 906 pXResizeWindow(SDL_Display, WMwindow, w, h); |
904 | 907 |
905 /* Resize the fullscreen and display windows */ | 908 /* Resize the fullscreen and display windows */ |
906 if ( flags & SDL_FULLSCREEN ) { | 909 if ( flags & SDL_FULLSCREEN ) { |
907 if ( screen->flags & SDL_FULLSCREEN ) { | 910 if ( screen->flags & SDL_FULLSCREEN ) { |
908 X11_ResizeFullScreen(this); | 911 X11_ResizeFullScreen(this); |
914 if ( screen->flags & SDL_FULLSCREEN ) { | 917 if ( screen->flags & SDL_FULLSCREEN ) { |
915 screen->flags &= ~SDL_FULLSCREEN; | 918 screen->flags &= ~SDL_FULLSCREEN; |
916 X11_LeaveFullScreen(this); | 919 X11_LeaveFullScreen(this); |
917 } | 920 } |
918 } | 921 } |
919 XResizeWindow(SDL_Display, SDL_Window, w, h); | 922 pXResizeWindow(SDL_Display, SDL_Window, w, h); |
920 } | 923 } |
921 return(0); | 924 return(0); |
922 } | 925 } |
923 | 926 |
924 SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, | 927 SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, |
936 flags &= ~SDL_FULLSCREEN; | 939 flags &= ~SDL_FULLSCREEN; |
937 } | 940 } |
938 } | 941 } |
939 | 942 |
940 /* Flush any delayed updates */ | 943 /* Flush any delayed updates */ |
941 XSync(GFX_Display, False); | 944 pXSync(GFX_Display, False); |
942 | 945 |
943 /* Set up the X11 window */ | 946 /* Set up the X11 window */ |
944 saved_flags = current->flags; | 947 saved_flags = current->flags; |
945 if ( (SDL_Window) && ((saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL)) | 948 if ( (SDL_Window) && ((saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL)) |
946 && (bpp == current->format->BitsPerPixel) | 949 && (bpp == current->format->BitsPerPixel) |
966 } | 969 } |
967 current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME)); | 970 current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME)); |
968 | 971 |
969 done: | 972 done: |
970 /* Release the event thread */ | 973 /* Release the event thread */ |
971 XSync(SDL_Display, False); | 974 pXSync(SDL_Display, False); |
972 SDL_Unlock_EventThread(); | 975 SDL_Unlock_EventThread(); |
973 | 976 |
974 /* We're done! */ | 977 /* We're done! */ |
975 return(current); | 978 return(current); |
976 } | 979 } |
1015 int x, y; | 1018 int x, y; |
1016 unsigned int mask; | 1019 unsigned int mask; |
1017 | 1020 |
1018 /* Lock the event thread, in multi-threading environments */ | 1021 /* Lock the event thread, in multi-threading environments */ |
1019 SDL_Lock_EventThread(); | 1022 SDL_Lock_EventThread(); |
1020 if ( XQueryPointer(SDL_Display, SDL_Window, &u1, ¤t_win, | 1023 if ( pXQueryPointer(SDL_Display, SDL_Window, &u1, ¤t_win, |
1021 &u2, &u2, &x, &y, &mask) ) { | 1024 &u2, &u2, &x, &y, &mask) ) { |
1022 if ( (x >= 0) && (x < SDL_VideoSurface->w) && | 1025 if ( (x >= 0) && (x < SDL_VideoSurface->w) && |
1023 (y >= 0) && (y < SDL_VideoSurface->h) ) { | 1026 (y >= 0) && (y < SDL_VideoSurface->h) ) { |
1024 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); | 1027 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); |
1025 SDL_PrivateMouseMotion(0, 0, x, y); | 1028 SDL_PrivateMouseMotion(0, 0, x, y); |
1052 all[i].pixel = i; | 1055 all[i].pixel = i; |
1053 /* | 1056 /* |
1054 * XQueryColors sets the flags in the XColor struct, so we use | 1057 * XQueryColors sets the flags in the XColor struct, so we use |
1055 * that to keep track of which colours are available | 1058 * that to keep track of which colours are available |
1056 */ | 1059 */ |
1057 XQueryColors(GFX_Display, SDL_XColorMap, all, 256); | 1060 pXQueryColors(GFX_Display, SDL_XColorMap, all, 256); |
1058 | 1061 |
1059 for(i = 0; i < nwant; i++) { | 1062 for(i = 0; i < nwant; i++) { |
1060 XColor *c; | 1063 XColor *c; |
1061 int j; | 1064 int j; |
1062 int best = 0; | 1065 int best = 0; |
1078 } | 1081 } |
1079 } | 1082 } |
1080 if(SDL_XPixels[best]) | 1083 if(SDL_XPixels[best]) |
1081 continue; /* already allocated, waste no more time */ | 1084 continue; /* already allocated, waste no more time */ |
1082 c = all + best; | 1085 c = all + best; |
1083 if(XAllocColor(GFX_Display, SDL_XColorMap, c)) { | 1086 if(pXAllocColor(GFX_Display, SDL_XColorMap, c)) { |
1084 /* got it */ | 1087 /* got it */ |
1085 colors[c->pixel].r = c->red >> 8; | 1088 colors[c->pixel].r = c->red >> 8; |
1086 colors[c->pixel].g = c->green >> 8; | 1089 colors[c->pixel].g = c->green >> 8; |
1087 colors[c->pixel].b = c->blue >> 8; | 1090 colors[c->pixel].b = c->blue >> 8; |
1088 ++SDL_XPixels[c->pixel]; | 1091 ++SDL_XPixels[c->pixel]; |
1120 xcmap[i].red = (colors[i].r<<8)|colors[i].r; | 1123 xcmap[i].red = (colors[i].r<<8)|colors[i].r; |
1121 xcmap[i].green = (colors[i].g<<8)|colors[i].g; | 1124 xcmap[i].green = (colors[i].g<<8)|colors[i].g; |
1122 xcmap[i].blue = (colors[i].b<<8)|colors[i].b; | 1125 xcmap[i].blue = (colors[i].b<<8)|colors[i].b; |
1123 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | 1126 xcmap[i].flags = (DoRed|DoGreen|DoBlue); |
1124 } | 1127 } |
1125 XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); | 1128 pXStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); |
1126 XSync(GFX_Display, False); | 1129 pXSync(GFX_Display, False); |
1127 FREEA(xcmap); | 1130 FREEA(xcmap); |
1128 } else { | 1131 } else { |
1129 /* | 1132 /* |
1130 * Shared colormap: We only allocate read-only cells, which | 1133 * Shared colormap: We only allocate read-only cells, which |
1131 * increases the likelyhood of colour sharing with other | 1134 * increases the likelyhood of colour sharing with other |
1149 while(SDL_XPixels[pixel]) { | 1152 while(SDL_XPixels[pixel]) { |
1150 freelist[nfree++] = pixel; | 1153 freelist[nfree++] = pixel; |
1151 --SDL_XPixels[pixel]; | 1154 --SDL_XPixels[pixel]; |
1152 } | 1155 } |
1153 } | 1156 } |
1154 XFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0); | 1157 pXFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0); |
1155 FREEA(freelist); | 1158 FREEA(freelist); |
1156 | 1159 |
1157 want = ALLOCA(ncolors * sizeof(SDL_Color)); | 1160 want = ALLOCA(ncolors * sizeof(SDL_Color)); |
1158 reject = ALLOCA(ncolors * sizeof(SDL_Color)); | 1161 reject = ALLOCA(ncolors * sizeof(SDL_Color)); |
1159 memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color)); | 1162 memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color)); |
1166 XColor col; | 1169 XColor col; |
1167 col.red = want[i].r << 8; | 1170 col.red = want[i].r << 8; |
1168 col.green = want[i].g << 8; | 1171 col.green = want[i].g << 8; |
1169 col.blue = want[i].b << 8; | 1172 col.blue = want[i].b << 8; |
1170 col.flags = DoRed | DoGreen | DoBlue; | 1173 col.flags = DoRed | DoGreen | DoBlue; |
1171 if(XAllocColor(GFX_Display, SDL_XColorMap, &col)) { | 1174 if(pXAllocColor(GFX_Display, SDL_XColorMap, &col)) { |
1172 /* We got the colour, or at least the nearest | 1175 /* We got the colour, or at least the nearest |
1173 the hardware could get. */ | 1176 the hardware could get. */ |
1174 colors[col.pixel].r = col.red >> 8; | 1177 colors[col.pixel].r = col.red >> 8; |
1175 colors[col.pixel].g = col.green >> 8; | 1178 colors[col.pixel].g = col.green >> 8; |
1176 colors[col.pixel].b = col.blue >> 8; | 1179 colors[col.pixel].b = col.blue >> 8; |
1210 xcmap[i].red = ramp[0*256+c]; | 1213 xcmap[i].red = ramp[0*256+c]; |
1211 xcmap[i].green = ramp[1*256+c]; | 1214 xcmap[i].green = ramp[1*256+c]; |
1212 xcmap[i].blue = ramp[2*256+c]; | 1215 xcmap[i].blue = ramp[2*256+c]; |
1213 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | 1216 xcmap[i].flags = (DoRed|DoGreen|DoBlue); |
1214 } | 1217 } |
1215 XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); | 1218 pXStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); |
1216 XSync(GFX_Display, False); | 1219 pXSync(GFX_Display, False); |
1217 return(0); | 1220 return(0); |
1218 } | 1221 } |
1219 | 1222 |
1220 /* Note: If we are terminated, this could be called in the middle of | 1223 /* Note: If we are terminated, this could be called in the middle of |
1221 another SDL video routine -- notably UpdateRects. | 1224 another SDL video routine -- notably UpdateRects. |
1224 { | 1227 { |
1225 /* Shutdown everything that's still up */ | 1228 /* Shutdown everything that's still up */ |
1226 /* The event thread should be done, so we can touch SDL_Display */ | 1229 /* The event thread should be done, so we can touch SDL_Display */ |
1227 if ( SDL_Display != NULL ) { | 1230 if ( SDL_Display != NULL ) { |
1228 /* Flush any delayed updates */ | 1231 /* Flush any delayed updates */ |
1229 XSync(GFX_Display, False); | 1232 pXSync(GFX_Display, False); |
1230 | 1233 |
1231 /* Start shutting down the windows */ | 1234 /* Start shutting down the windows */ |
1232 X11_DestroyImage(this, this->screen); | 1235 X11_DestroyImage(this, this->screen); |
1233 X11_DestroyWindow(this, this->screen); | 1236 X11_DestroyWindow(this, this->screen); |
1234 X11_FreeVideoModes(this); | 1237 X11_FreeVideoModes(this); |
1235 if ( SDL_XColorMap != SDL_DisplayColormap ) { | 1238 if ( SDL_XColorMap != SDL_DisplayColormap ) { |
1236 XFreeColormap(SDL_Display, SDL_XColorMap); | 1239 pXFreeColormap(SDL_Display, SDL_XColorMap); |
1237 } | 1240 } |
1238 if ( SDL_iconcolors ) { | 1241 if ( SDL_iconcolors ) { |
1239 unsigned long pixel; | 1242 unsigned long pixel; |
1240 Colormap dcmap = DefaultColormap(SDL_Display, | 1243 Colormap dcmap = DefaultColormap(SDL_Display, |
1241 SDL_Screen); | 1244 SDL_Screen); |
1242 for(pixel = 0; pixel < 256; ++pixel) { | 1245 for(pixel = 0; pixel < 256; ++pixel) { |
1243 while(SDL_iconcolors[pixel] > 0) { | 1246 while(SDL_iconcolors[pixel] > 0) { |
1244 XFreeColors(GFX_Display, | 1247 pXFreeColors(GFX_Display, |
1245 dcmap, &pixel, 1, 0); | 1248 dcmap, &pixel, 1, 0); |
1246 --SDL_iconcolors[pixel]; | 1249 --SDL_iconcolors[pixel]; |
1247 } | 1250 } |
1248 } | 1251 } |
1249 free(SDL_iconcolors); | 1252 free(SDL_iconcolors); |
1260 SDL_BlankCursor = NULL; | 1263 SDL_BlankCursor = NULL; |
1261 } | 1264 } |
1262 | 1265 |
1263 /* Close the X11 graphics connection */ | 1266 /* Close the X11 graphics connection */ |
1264 if ( GFX_Display != NULL ) { | 1267 if ( GFX_Display != NULL ) { |
1265 XCloseDisplay(GFX_Display); | 1268 pXCloseDisplay(GFX_Display); |
1266 GFX_Display = NULL; | 1269 GFX_Display = NULL; |
1267 } | 1270 } |
1268 | 1271 |
1269 /* Close the X11 display connection */ | 1272 /* Close the X11 display connection */ |
1270 XCloseDisplay(SDL_Display); | 1273 pXCloseDisplay(SDL_Display); |
1271 SDL_Display = NULL; | 1274 SDL_Display = NULL; |
1272 | 1275 |
1273 /* Reset the X11 error handlers */ | 1276 /* Reset the X11 error handlers */ |
1274 if ( XIO_handler ) { | 1277 if ( XIO_handler ) { |
1275 XSetIOErrorHandler(XIO_handler); | 1278 pXSetIOErrorHandler(XIO_handler); |
1276 } | 1279 } |
1277 if ( X_handler ) { | 1280 if ( X_handler ) { |
1278 XSetErrorHandler(X_handler); | 1281 pXSetErrorHandler(X_handler); |
1279 } | 1282 } |
1280 | 1283 |
1281 /* Unload GL library after X11 shuts down */ | 1284 /* Unload GL library after X11 shuts down */ |
1282 X11_GL_UnloadLibrary(this); | 1285 X11_GL_UnloadLibrary(this); |
1283 } | 1286 } |