Mercurial > sdl-ios-xcode
annotate src/video/x11/SDL_x11video.c @ 1299:2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Fixes Bugzilla #87.
| author | Ryan C. Gordon <icculus@icculus.org> |
|---|---|
| date | Mon, 30 Jan 2006 18:21:44 +0000 |
| parents | d2c6881935be |
| children | c9b51268668f |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
769
b8d311d90021
Updated copyright information for 2004 (Happy New Year!)
Sam Lantinga <slouken@libsdl.org>
parents:
556
diff
changeset
|
3 Copyright (C) 1997-2004 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
| 6 modify it under the terms of the GNU Library General Public | |
| 7 License as published by the Free Software Foundation; either | |
| 8 version 2 of the License, or (at your option) any later version. | |
| 9 | |
| 10 This library is distributed in the hope that it will be useful, | |
| 11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 13 Library General Public License for more details. | |
| 14 | |
| 15 You should have received a copy of the GNU Library General Public | |
| 16 License along with this library; if not, write to the Free | |
| 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| 18 | |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
236
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
| 22 | |
| 23 #ifdef SAVE_RCSID | |
| 24 static char rcsid = | |
| 25 "@(#) $Id$"; | |
| 26 #endif | |
| 27 | |
| 28 /* X11 based SDL video driver implementation. | |
| 29 Note: This implementation does not currently need X11 thread locking, | |
| 30 since the event thread uses a separate X connection and any | |
| 31 additional locking necessary is handled internally. However, | |
| 32 if full locking is neccessary, take a look at XInitThreads(). | |
| 33 */ | |
| 34 | |
| 35 #include <stdlib.h> | |
| 36 #include <stdio.h> | |
| 37 #include <unistd.h> | |
| 38 #include <string.h> | |
| 39 #include <sys/ioctl.h> | |
| 40 #ifdef MTRR_SUPPORT | |
| 41 #include <asm/mtrr.h> | |
| 42 #include <sys/fcntl.h> | |
| 43 #endif | |
| 44 | |
| 45 #ifdef HAVE_ALLOCA_H | |
| 46 #include <alloca.h> | |
| 47 #endif | |
| 48 | |
| 49 #ifdef HAVE_ALLOCA | |
| 50 #define ALLOCA(n) ((void*)alloca(n)) | |
| 51 #define FREEA(p) | |
| 52 #else | |
| 53 #define ALLOCA(n) malloc(n) | |
| 54 #define FREEA(p) free(p) | |
| 55 #endif | |
| 56 | |
| 57 #include "SDL.h" | |
| 58 #include "SDL_error.h" | |
| 59 #include "SDL_timer.h" | |
| 60 #include "SDL_thread.h" | |
| 61 #include "SDL_video.h" | |
| 62 #include "SDL_mouse.h" | |
| 63 #include "SDL_endian.h" | |
| 64 #include "SDL_sysvideo.h" | |
| 65 #include "SDL_pixels_c.h" | |
| 66 #include "SDL_events_c.h" | |
| 67 #include "SDL_x11video.h" | |
| 68 #include "SDL_x11wm_c.h" | |
| 69 #include "SDL_x11mouse_c.h" | |
| 70 #include "SDL_x11events_c.h" | |
| 71 #include "SDL_x11modes_c.h" | |
| 72 #include "SDL_x11image_c.h" | |
| 73 #include "SDL_x11yuv_c.h" | |
| 74 #include "SDL_x11gl_c.h" | |
| 75 #include "SDL_x11gamma_c.h" | |
| 76 #include "blank_cursor.h" | |
| 77 | |
| 78 /* Initialization/Query functions */ | |
| 79 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat); | |
| 80 static SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | |
| 81 static int X11_ToggleFullScreen(_THIS, int on); | |
| 82 static void X11_UpdateMouse(_THIS); | |
| 83 static int X11_SetColors(_THIS, int firstcolor, int ncolors, | |
| 84 SDL_Color *colors); | |
| 85 static int X11_SetGammaRamp(_THIS, Uint16 *ramp); | |
| 86 static void X11_VideoQuit(_THIS); | |
| 87 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
88 |
| 0 | 89 /* X11 driver bootstrap functions */ |
| 90 | |
| 91 static int X11_Available(void) | |
| 92 { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
93 Display *display = NULL; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
94 if ( SDL_X11_LoadSymbols() ) { |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
95 display = pXOpenDisplay(NULL); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
96 if ( display != NULL ) { |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
97 pXCloseDisplay(display); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
98 } |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
99 SDL_X11_UnloadSymbols(); |
| 0 | 100 } |
| 101 return(display != NULL); | |
| 102 } | |
| 103 | |
| 104 static void X11_DeleteDevice(SDL_VideoDevice *device) | |
| 105 { | |
| 106 if ( device ) { | |
| 107 if ( device->hidden ) { | |
| 108 free(device->hidden); | |
| 109 } | |
| 110 if ( device->gl_data ) { | |
| 111 free(device->gl_data); | |
| 112 } | |
| 113 free(device); | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
114 SDL_X11_UnloadSymbols(); |
| 0 | 115 } |
| 116 } | |
| 117 | |
| 118 static SDL_VideoDevice *X11_CreateDevice(int devindex) | |
| 119 { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
120 SDL_VideoDevice *device = NULL; |
| 0 | 121 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
122 if ( SDL_X11_LoadSymbols() ) { |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
123 /* Initialize all variables that we clean on shutdown */ |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
124 device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
125 if ( device ) { |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
126 memset(device, 0, (sizeof *device)); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
127 device->hidden = (struct SDL_PrivateVideoData *) |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
128 malloc((sizeof *device->hidden)); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
129 device->gl_data = (struct SDL_PrivateGLData *) |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
130 malloc((sizeof *device->gl_data)); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
131 } |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
132 if ( (device == NULL) || (device->hidden == NULL) || |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
133 (device->gl_data == NULL) ) { |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
134 SDL_OutOfMemory(); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
135 X11_DeleteDevice(device); /* calls SDL_X11_UnloadSymbols(). */ |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
136 return(0); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
137 } |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
138 memset(device->hidden, 0, (sizeof *device->hidden)); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
139 memset(device->gl_data, 0, (sizeof *device->gl_data)); |
| 0 | 140 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
141 /* Set the driver flags */ |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
142 device->handles_any_size = 1; |
| 0 | 143 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
144 /* Set the function pointers */ |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
145 device->VideoInit = X11_VideoInit; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
146 device->ListModes = X11_ListModes; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
147 device->SetVideoMode = X11_SetVideoMode; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
148 device->ToggleFullScreen = X11_ToggleFullScreen; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
149 device->UpdateMouse = X11_UpdateMouse; |
| 0 | 150 #ifdef XFREE86_XV |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
151 device->CreateYUVOverlay = X11_CreateYUVOverlay; |
| 0 | 152 #endif |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
153 device->SetColors = X11_SetColors; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
154 device->UpdateRects = NULL; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
155 device->VideoQuit = X11_VideoQuit; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
156 device->AllocHWSurface = X11_AllocHWSurface; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
157 device->CheckHWBlit = NULL; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
158 device->FillHWRect = NULL; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
159 device->SetHWColorKey = NULL; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
160 device->SetHWAlpha = NULL; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
161 device->LockHWSurface = X11_LockHWSurface; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
162 device->UnlockHWSurface = X11_UnlockHWSurface; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
163 device->FlipHWSurface = X11_FlipHWSurface; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
164 device->FreeHWSurface = X11_FreeHWSurface; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
165 device->SetGamma = X11_SetVidModeGamma; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
166 device->GetGamma = X11_GetVidModeGamma; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
167 device->SetGammaRamp = X11_SetGammaRamp; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
168 device->GetGammaRamp = NULL; |
|
1191
2bd4cec0de63
Seperate glX from HAVE_OPENGL, for platforms that have both an X server and
Ryan C. Gordon <icculus@icculus.org>
parents:
1178
diff
changeset
|
169 #ifdef HAVE_OPENGL_X11 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
170 device->GL_LoadLibrary = X11_GL_LoadLibrary; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
171 device->GL_GetProcAddress = X11_GL_GetProcAddress; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
172 device->GL_GetAttribute = X11_GL_GetAttribute; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
173 device->GL_MakeCurrent = X11_GL_MakeCurrent; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
174 device->GL_SwapBuffers = X11_GL_SwapBuffers; |
| 0 | 175 #endif |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
176 device->SetCaption = X11_SetCaption; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
177 device->SetIcon = X11_SetIcon; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
178 device->IconifyWindow = X11_IconifyWindow; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
179 device->GrabInput = X11_GrabInput; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
180 device->GetWMInfo = X11_GetWMInfo; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
181 device->FreeWMCursor = X11_FreeWMCursor; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
182 device->CreateWMCursor = X11_CreateWMCursor; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
183 device->ShowWMCursor = X11_ShowWMCursor; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
184 device->WarpWMCursor = X11_WarpWMCursor; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
185 device->CheckMouseMode = X11_CheckMouseMode; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
186 device->InitOSKeymap = X11_InitOSKeymap; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
187 device->PumpEvents = X11_PumpEvents; |
| 0 | 188 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
189 device->free = X11_DeleteDevice; |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
190 } |
| 0 | 191 |
| 192 return device; | |
| 193 } | |
| 194 | |
| 195 VideoBootStrap X11_bootstrap = { | |
| 196 "x11", "X Window System", | |
| 197 X11_Available, X11_CreateDevice | |
| 198 }; | |
| 199 | |
| 200 /* Normal X11 error handler routine */ | |
| 201 static int (*X_handler)(Display *, XErrorEvent *) = NULL; | |
| 202 static int x_errhandler(Display *d, XErrorEvent *e) | |
| 203 { | |
| 204 #ifdef XFREE86_VM | |
| 205 extern int vm_error; | |
| 206 #endif | |
| 207 #ifdef XFREE86_DGAMOUSE | |
| 208 extern int dga_error; | |
| 209 #endif | |
| 210 | |
| 211 #ifdef XFREE86_VM | |
| 212 /* VidMode errors are non-fatal. :) */ | |
| 213 /* Are the errors offset by one from the error base? | |
| 214 e.g. the error base is 143, the code is 148, and the | |
| 215 actual error is XF86VidModeExtensionDisabled (4) ? | |
| 216 */ | |
| 217 if ( (vm_error >= 0) && | |
| 218 (((e->error_code == BadRequest)&&(e->request_code == vm_error)) || | |
| 219 ((e->error_code > vm_error) && | |
| 220 (e->error_code <= (vm_error+XF86VidModeNumberErrors)))) ) { | |
| 221 #ifdef XFREE86_DEBUG | |
| 222 { char errmsg[1024]; | |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
223 pXGetErrorText(d, e->error_code, errmsg, sizeof(errmsg)); |
| 0 | 224 printf("VidMode error: %s\n", errmsg); |
| 225 } | |
| 226 #endif | |
| 227 return(0); | |
| 228 } | |
| 229 #endif /* XFREE86_VM */ | |
| 230 | |
| 231 #ifdef XFREE86_DGAMOUSE | |
| 232 /* DGA errors can be non-fatal. :) */ | |
| 233 if ( (dga_error >= 0) && | |
| 234 ((e->error_code > dga_error) && | |
| 235 (e->error_code <= (dga_error+XF86DGANumberErrors))) ) { | |
| 236 #ifdef XFREE86_DEBUG | |
| 237 { char errmsg[1024]; | |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
238 pXGetErrorText(d, e->error_code, errmsg, sizeof(errmsg)); |
| 0 | 239 printf("DGA error: %s\n", errmsg); |
| 240 } | |
| 241 #endif | |
| 242 return(0); | |
| 243 } | |
| 244 #endif /* XFREE86_DGAMOUSE */ | |
| 245 | |
| 246 return(X_handler(d,e)); | |
| 247 } | |
| 248 | |
| 249 /* X11 I/O error handler routine */ | |
| 250 static int (*XIO_handler)(Display *) = NULL; | |
| 251 static int xio_errhandler(Display *d) | |
| 252 { | |
| 253 /* Ack! Lost X11 connection! */ | |
| 254 | |
| 255 /* We will crash if we try to clean up our display */ | |
| 256 if ( current_video->hidden->Ximage ) { | |
| 257 SDL_VideoSurface->pixels = NULL; | |
| 258 } | |
| 259 current_video->hidden->X11_Display = NULL; | |
| 260 | |
| 261 /* Continue with the standard X11 error handler */ | |
| 262 return(XIO_handler(d)); | |
| 263 } | |
| 264 | |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
265 static int (*Xext_handler)(Display *,char *,char *) = NULL; |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
266 static int xext_errhandler(Display *d, char *ext_name, char *reason) |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
267 { |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
268 #ifdef XFREE86_DEBUG |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
269 printf("Xext error inside SDL (may be harmless):\n"); |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
270 printf(" Extension \"%s\" %s on display \"%s\".\n", |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
271 ext_name, reason, pXDisplayString(d)); |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
272 #endif |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
273 |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
274 if (strcmp(reason, "missing") == 0) { |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
275 /* |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
276 * Since the query itself, elsewhere, can handle a missing extension |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
277 * and the default behaviour in Xlib is to write to stderr, which |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
278 * generates unnecessary bug reports, we just ignore these. |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
279 */ |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
280 return 0; |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
281 } |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
282 |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
283 /* Everything else goes to the default handler... */ |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
284 return Xext_handler(d, ext_name, reason); |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
285 } |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
286 |
| 0 | 287 /* Create auxiliary (toplevel) windows with the current visual */ |
| 288 static void create_aux_windows(_THIS) | |
| 289 { | |
|
1206
aac47040c6d7
Patched to compile on gcc 2.95.3.
Ryan C. Gordon <icculus@icculus.org>
parents:
1191
diff
changeset
|
290 char * savedclassname = NULL; |
| 0 | 291 XSetWindowAttributes xattr; |
| 292 XWMHints *hints; | |
| 293 XTextProperty titleprop, iconprop; | |
| 294 int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen)); | |
| 295 | |
| 296 /* Don't create any extra windows if we are being managed */ | |
| 297 if ( SDL_windowid ) { | |
| 298 FSwindow = 0; | |
| 299 WMwindow = strtol(SDL_windowid, NULL, 0); | |
| 300 return; | |
| 301 } | |
| 302 | |
| 303 if(FSwindow) | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
304 pXDestroyWindow(SDL_Display, FSwindow); |
| 0 | 305 |
| 306 xattr.override_redirect = True; | |
| 307 xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0; | |
| 308 xattr.border_pixel = 0; | |
| 309 xattr.colormap = SDL_XColorMap; | |
| 310 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
311 FSwindow = pXCreateWindow(SDL_Display, SDL_Root, |
|
499
f480ecd70499
Added an aborted try at making fullscreen work on Xinerama screen != 0
Sam Lantinga <slouken@libsdl.org>
parents:
497
diff
changeset
|
312 xinerama_x, xinerama_y, 32, 32, 0, |
| 0 | 313 this->hidden->depth, InputOutput, SDL_Visual, |
| 314 CWOverrideRedirect | CWBackPixel | CWBorderPixel | |
| 315 | CWColormap, | |
| 316 &xattr); | |
| 317 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
318 pXSelectInput(SDL_Display, FSwindow, StructureNotifyMask); |
| 0 | 319 |
| 320 /* Tell KDE to keep the fullscreen window on top */ | |
| 321 { | |
| 322 XEvent ev; | |
| 323 long mask; | |
| 324 | |
| 325 memset(&ev, 0, sizeof(ev)); | |
| 326 ev.xclient.type = ClientMessage; | |
| 327 ev.xclient.window = SDL_Root; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
328 ev.xclient.message_type = pXInternAtom(SDL_Display, |
| 0 | 329 "KWM_KEEP_ON_TOP", False); |
| 330 ev.xclient.format = 32; | |
| 331 ev.xclient.data.l[0] = FSwindow; | |
| 332 ev.xclient.data.l[1] = CurrentTime; | |
| 333 mask = SubstructureRedirectMask; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
334 pXSendEvent(SDL_Display, SDL_Root, False, mask, &ev); |
| 0 | 335 } |
| 336 | |
| 337 hints = NULL; | |
| 338 titleprop.value = iconprop.value = NULL; | |
| 339 if(WMwindow) { | |
| 340 /* All window attributes must survive the recreation */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
341 hints = pXGetWMHints(SDL_Display, WMwindow); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
342 pXGetWMName(SDL_Display, WMwindow, &titleprop); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
343 pXGetWMIconName(SDL_Display, WMwindow, &iconprop); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
344 pXDestroyWindow(SDL_Display, WMwindow); |
| 0 | 345 } |
| 346 | |
| 347 /* Create the window for windowed management */ | |
| 348 /* (reusing the xattr structure above) */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
349 WMwindow = pXCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0, |
| 0 | 350 this->hidden->depth, InputOutput, SDL_Visual, |
| 351 CWBackPixel | CWBorderPixel | CWColormap, | |
| 352 &xattr); | |
| 353 | |
| 354 /* Set the input hints so we get keyboard input */ | |
| 355 if(!hints) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
356 hints = pXAllocWMHints(); |
| 0 | 357 hints->input = True; |
| 358 hints->flags = InputHint; | |
| 359 } | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
360 pXSetWMHints(SDL_Display, WMwindow, hints); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
361 pXFree(hints); |
| 0 | 362 if(titleprop.value) { |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
363 pXSetWMName(SDL_Display, WMwindow, &titleprop); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
364 pXFree(titleprop.value); |
| 0 | 365 } |
| 366 if(iconprop.value) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
367 pXSetWMIconName(SDL_Display, WMwindow, &iconprop); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
368 pXFree(iconprop.value); |
| 0 | 369 } |
| 370 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
371 pXSelectInput(SDL_Display, WMwindow, |
| 0 | 372 FocusChangeMask | KeyPressMask | KeyReleaseMask |
| 373 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask); | |
| 374 | |
| 375 /* Set the class hints so we can get an icon (AfterStep) */ | |
| 376 { | |
| 377 XClassHint *classhints; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
378 classhints = pXAllocClassHint(); |
| 0 | 379 if(classhints != NULL) { |
|
449
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
380 char *classname = getenv("SDL_VIDEO_X11_WMCLASS"); |
|
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
381 if ( ! classname ) { |
|
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
382 classname = "SDL_App"; |
|
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
383 } |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
384 savedclassname = strdup(classname); |
|
449
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
385 classhints->res_name = classname; |
|
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
386 classhints->res_class = classname; |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
387 pXSetClassHint(SDL_Display, WMwindow, classhints); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
388 pXFree(classhints); |
| 0 | 389 } |
| 390 } | |
| 391 | |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
392 /* Setup the communication with the IM server */ |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
393 SDL_IM = NULL; |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
394 SDL_IC = NULL; |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
395 |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
396 #ifdef X_HAVE_UTF8_STRING |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
397 SDL_IM = pXOpenIM(SDL_Display, NULL, savedclassname, savedclassname); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
398 if (SDL_IM == NULL) { |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
399 SDL_SetError("no input method could be opened"); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
400 } else { |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
401 SDL_IC = pXCreateIC(SDL_IM, |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
402 XNClientWindow, WMwindow, |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
403 XNFocusWindow, WMwindow, |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
404 XNInputStyle, XIMPreeditNothing | XIMStatusNothing, |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
405 XNResourceName, savedclassname, |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
406 XNResourceClass, savedclassname, |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
407 NULL); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
408 if (SDL_IC == NULL) { |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
409 SDL_SetError("no input context could be created"); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
410 pXCloseIM(SDL_IM); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
411 SDL_IM = NULL; |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
412 } |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
413 } |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
414 #endif |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
415 |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
416 free(savedclassname); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
417 |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
418 |
| 0 | 419 /* Allow the window to be deleted by the window manager */ |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
420 WM_DELETE_WINDOW = pXInternAtom(SDL_Display, "WM_DELETE_WINDOW", False); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
421 pXSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1); |
| 0 | 422 } |
| 423 | |
| 424 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat) | |
| 425 { | |
| 426 char *display; | |
| 427 int i; | |
| 428 | |
| 429 /* Open the X11 display */ | |
| 430 display = NULL; /* Get it from DISPLAY environment variable */ | |
| 431 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
432 if ( (strncmp(pXDisplayName(display), ":", 1) == 0) || |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
433 (strncmp(pXDisplayName(display), "unix:", 5) == 0) ) { |
| 0 | 434 local_X11 = 1; |
| 435 } else { | |
| 436 local_X11 = 0; | |
| 437 } | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
438 SDL_Display = pXOpenDisplay(display); |
|
1299
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
439 #if defined(__osf__) && defined(X11_DYNAMIC) |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
440 /* On Tru64 if linking without -lX11, it fails and you get following message. |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
441 * Xlib: connection to ":0.0" refused by server |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
442 * Xlib: XDM authorization key matches an existing client! |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
443 * |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
444 * It succeeds if retrying 1 second later |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
445 * or if running xhost +localhost on shell. |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
446 * |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
447 */ |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
448 if ( SDL_Display == NULL ) { |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
449 SDL_Delay(1000); |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
450 SDL_Display = pXOpenDisplay(display); |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
451 } |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
452 #endif |
| 0 | 453 if ( SDL_Display == NULL ) { |
| 454 SDL_SetError("Couldn't open X11 display"); | |
| 455 return(-1); | |
| 456 } | |
| 457 #ifdef X11_DEBUG | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
458 pXSynchronize(SDL_Display, True); |
| 0 | 459 #endif |
| 460 | |
| 461 /* Create an alternate X display for graphics updates -- allows us | |
| 462 to do graphics updates in a separate thread from event handling. | |
| 463 Thread-safe X11 doesn't seem to exist. | |
| 464 */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
465 GFX_Display = pXOpenDisplay(display); |
| 0 | 466 if ( GFX_Display == NULL ) { |
| 467 SDL_SetError("Couldn't open X11 display"); | |
| 468 return(-1); | |
| 469 } | |
| 470 | |
| 471 /* Set the normal X error handler */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
472 X_handler = pXSetErrorHandler(x_errhandler); |
| 0 | 473 |
| 474 /* Set the error handler if we lose the X display */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
475 XIO_handler = pXSetIOErrorHandler(xio_errhandler); |
| 0 | 476 |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
477 /* Set the X extension error handler */ |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
478 Xext_handler = pXSetExtensionErrorHandler(xext_errhandler); |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
479 |
| 0 | 480 /* use default screen (from $DISPLAY) */ |
| 481 SDL_Screen = DefaultScreen(SDL_Display); | |
| 482 | |
| 483 #ifndef NO_SHARED_MEMORY | |
| 484 /* Check for MIT shared memory extension */ | |
|
556
08588ee79a67
Fixed compile error if there is no X11 shared memory support.
Sam Lantinga <slouken@libsdl.org>
parents:
499
diff
changeset
|
485 use_mitshm = 0; |
| 0 | 486 if ( local_X11 ) { |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
487 use_mitshm = pXShmQueryExtension(SDL_Display); |
| 0 | 488 } |
| 489 #endif /* NO_SHARED_MEMORY */ | |
| 490 | |
| 491 /* Get the available video modes */ | |
| 492 if(X11_GetVideoModes(this) < 0) | |
| 493 return -1; | |
| 494 | |
| 495 /* Determine the default screen depth: | |
| 496 Use the default visual (or at least one with the same depth) */ | |
| 497 SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen); | |
| 498 for(i = 0; i < this->hidden->nvisuals; i++) | |
| 499 if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display, | |
| 500 SDL_Screen)) | |
| 501 break; | |
| 502 if(i == this->hidden->nvisuals) { | |
| 503 /* default visual was useless, take the deepest one instead */ | |
| 504 i = 0; | |
| 505 } | |
| 506 SDL_Visual = this->hidden->visuals[i].visual; | |
| 507 if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) { | |
| 508 SDL_XColorMap = SDL_DisplayColormap; | |
| 509 } else { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
510 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
| 0 | 511 SDL_Visual, AllocNone); |
| 512 } | |
| 513 this->hidden->depth = this->hidden->visuals[i].depth; | |
| 514 vformat->BitsPerPixel = this->hidden->visuals[i].bpp; | |
| 515 if ( vformat->BitsPerPixel > 8 ) { | |
| 516 vformat->Rmask = SDL_Visual->red_mask; | |
| 517 vformat->Gmask = SDL_Visual->green_mask; | |
| 518 vformat->Bmask = SDL_Visual->blue_mask; | |
| 519 } | |
| 520 X11_SaveVidModeGamma(this); | |
| 521 | |
| 522 /* See if we have been passed a window to use */ | |
| 523 SDL_windowid = getenv("SDL_WINDOWID"); | |
| 524 | |
| 525 /* Create the fullscreen and managed windows */ | |
| 526 create_aux_windows(this); | |
| 527 | |
| 528 /* Create the blank cursor */ | |
| 529 SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask, | |
| 530 BLANK_CWIDTH, BLANK_CHEIGHT, | |
| 531 BLANK_CHOTX, BLANK_CHOTY); | |
| 532 | |
| 533 /* Fill in some window manager capabilities */ | |
| 534 this->info.wm_available = 1; | |
| 535 | |
| 536 /* We're done! */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
537 pXFlush(SDL_Display); |
| 0 | 538 return(0); |
| 539 } | |
| 540 | |
| 541 static void X11_DestroyWindow(_THIS, SDL_Surface *screen) | |
| 542 { | |
| 543 /* Clean up OpenGL */ | |
| 544 if ( screen ) { | |
| 545 screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT); | |
| 546 } | |
| 547 X11_GL_Shutdown(this); | |
| 548 | |
| 549 if ( ! SDL_windowid ) { | |
| 550 /* Hide the managed window */ | |
| 551 if ( WMwindow ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
552 pXUnmapWindow(SDL_Display, WMwindow); |
| 0 | 553 } |
| 554 if ( screen && (screen->flags & SDL_FULLSCREEN) ) { | |
| 555 screen->flags &= ~SDL_FULLSCREEN; | |
| 556 X11_LeaveFullScreen(this); | |
| 557 } | |
| 558 | |
| 559 /* Destroy the output window */ | |
| 560 if ( SDL_Window ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
561 pXDestroyWindow(SDL_Display, SDL_Window); |
| 0 | 562 } |
| 563 | |
| 564 /* Free the colormap entries */ | |
| 565 if ( SDL_XPixels ) { | |
| 566 int numcolors; | |
| 567 unsigned long pixel; | |
| 568 numcolors = SDL_Visual->map_entries; | |
| 569 for ( pixel=0; pixel<numcolors; ++pixel ) { | |
| 570 while ( SDL_XPixels[pixel] > 0 ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
571 pXFreeColors(GFX_Display, |
| 0 | 572 SDL_DisplayColormap,&pixel,1,0); |
| 573 --SDL_XPixels[pixel]; | |
| 574 } | |
| 575 } | |
| 576 free(SDL_XPixels); | |
| 577 SDL_XPixels = NULL; | |
| 578 } | |
| 579 | |
| 580 /* Free the graphics context */ | |
| 581 if ( SDL_GC ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
582 pXFreeGC(SDL_Display, SDL_GC); |
| 0 | 583 SDL_GC = 0; |
| 584 } | |
| 585 } | |
| 586 } | |
| 587 | |
|
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
588 static SDL_bool X11_WindowPosition(_THIS, int *x, int *y, int w, int h) |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
589 { |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
590 const char *window = getenv("SDL_VIDEO_WINDOW_POS"); |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
591 const char *center = getenv("SDL_VIDEO_CENTERED"); |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
592 if ( window ) { |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
593 if ( sscanf(window, "%d,%d", x, y) == 2 ) { |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
594 return SDL_TRUE; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
595 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
596 if ( strcmp(window, "center") == 0 ) { |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
597 center = window; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
598 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
599 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
600 if ( center ) { |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
601 *x = (DisplayWidth(SDL_Display, SDL_Screen) - w)/2; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
602 *y = (DisplayHeight(SDL_Display, SDL_Screen) - h)/2; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
603 return SDL_TRUE; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
604 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
605 return SDL_FALSE; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
606 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
607 |
| 0 | 608 static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags) |
| 609 { | |
| 610 XSizeHints *hints; | |
| 611 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
612 hints = pXAllocSizeHints(); |
| 0 | 613 if ( hints ) { |
| 614 if ( flags & SDL_RESIZABLE ) { | |
| 615 hints->min_width = 32; | |
| 616 hints->min_height = 32; | |
| 617 hints->max_height = 4096; | |
| 618 hints->max_width = 4096; | |
| 619 } else { | |
| 620 hints->min_width = hints->max_width = w; | |
| 621 hints->min_height = hints->max_height = h; | |
| 622 } | |
| 623 hints->flags = PMaxSize | PMinSize; | |
| 624 if ( flags & SDL_FULLSCREEN ) { | |
| 625 hints->x = 0; | |
| 626 hints->y = 0; | |
| 627 hints->flags |= USPosition; | |
| 628 } else | |
| 629 /* Center it, if desired */ | |
|
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
630 if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) { |
| 0 | 631 hints->flags |= USPosition; |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
632 pXMoveWindow(SDL_Display, WMwindow, hints->x, hints->y); |
| 0 | 633 |
| 634 /* Flush the resize event so we don't catch it later */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
635 pXSync(SDL_Display, True); |
| 0 | 636 } |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
637 pXSetWMNormalHints(SDL_Display, WMwindow, hints); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
638 pXFree(hints); |
| 0 | 639 } |
| 640 | |
| 641 /* Respect the window caption style */ | |
| 642 if ( flags & SDL_NOFRAME ) { | |
| 643 SDL_bool set; | |
| 644 Atom WM_HINTS; | |
| 645 | |
| 646 /* We haven't modified the window manager hints yet */ | |
| 647 set = SDL_FALSE; | |
| 648 | |
| 649 /* First try to set MWM hints */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
650 WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
| 0 | 651 if ( WM_HINTS != None ) { |
| 652 /* Hints used by Motif compliant window managers */ | |
| 653 struct { | |
| 654 unsigned long flags; | |
| 655 unsigned long functions; | |
| 656 unsigned long decorations; | |
| 657 long input_mode; | |
| 658 unsigned long status; | |
| 659 } MWMHints = { (1L << 1), 0, 0, 0, 0 }; | |
| 660 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
661 pXChangeProperty(SDL_Display, WMwindow, |
| 0 | 662 WM_HINTS, WM_HINTS, 32, |
| 663 PropModeReplace, | |
| 664 (unsigned char *)&MWMHints, | |
| 665 sizeof(MWMHints)/sizeof(long)); | |
| 666 set = SDL_TRUE; | |
| 667 } | |
| 668 /* Now try to set KWM hints */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
669 WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
| 0 | 670 if ( WM_HINTS != None ) { |
| 671 long KWMHints = 0; | |
| 672 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
673 pXChangeProperty(SDL_Display, WMwindow, |
| 0 | 674 WM_HINTS, WM_HINTS, 32, |
| 675 PropModeReplace, | |
| 676 (unsigned char *)&KWMHints, | |
| 677 sizeof(KWMHints)/sizeof(long)); | |
| 678 set = SDL_TRUE; | |
| 679 } | |
| 680 /* Now try to set GNOME hints */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
681 WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True); |
| 0 | 682 if ( WM_HINTS != None ) { |
| 683 long GNOMEHints = 0; | |
| 684 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
685 pXChangeProperty(SDL_Display, WMwindow, |
| 0 | 686 WM_HINTS, WM_HINTS, 32, |
| 687 PropModeReplace, | |
| 688 (unsigned char *)&GNOMEHints, | |
| 689 sizeof(GNOMEHints)/sizeof(long)); | |
| 690 set = SDL_TRUE; | |
| 691 } | |
| 692 /* Finally set the transient hints if necessary */ | |
| 693 if ( ! set ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
694 pXSetTransientForHint(SDL_Display, WMwindow, SDL_Root); |
| 0 | 695 } |
| 696 } else { | |
| 697 SDL_bool set; | |
| 698 Atom WM_HINTS; | |
| 699 | |
| 700 /* We haven't modified the window manager hints yet */ | |
| 701 set = SDL_FALSE; | |
| 702 | |
| 703 /* First try to unset MWM hints */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
704 WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
| 0 | 705 if ( WM_HINTS != None ) { |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
706 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
| 0 | 707 set = SDL_TRUE; |
| 708 } | |
| 709 /* Now try to unset KWM hints */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
710 WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
| 0 | 711 if ( WM_HINTS != None ) { |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
712 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
| 0 | 713 set = SDL_TRUE; |
| 714 } | |
| 715 /* Now try to unset GNOME hints */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
716 WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True); |
| 0 | 717 if ( WM_HINTS != None ) { |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
718 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
| 0 | 719 set = SDL_TRUE; |
| 720 } | |
| 721 /* Finally unset the transient hints if necessary */ | |
| 722 if ( ! set ) { | |
| 723 /* NOTE: Does this work? */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
724 pXSetTransientForHint(SDL_Display, WMwindow, None); |
| 0 | 725 } |
| 726 } | |
| 727 } | |
| 728 | |
| 729 static int X11_CreateWindow(_THIS, SDL_Surface *screen, | |
| 730 int w, int h, int bpp, Uint32 flags) | |
| 731 { | |
| 732 int i, depth; | |
| 733 Visual *vis; | |
| 734 int vis_change; | |
| 735 | |
| 736 /* If a window is already present, destroy it and start fresh */ | |
| 737 if ( SDL_Window ) { | |
| 738 X11_DestroyWindow(this, screen); | |
|
860
2bac79e27868
Create a 2D window and then manually focus a different window on your desktop,
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
739 switch_waiting = 0; /* Prevent jump back to now-meaningless state. */ |
| 0 | 740 } |
| 741 | |
| 742 /* See if we have been given a window id */ | |
| 743 if ( SDL_windowid ) { | |
| 744 SDL_Window = strtol(SDL_windowid, NULL, 0); | |
| 745 } else { | |
| 746 SDL_Window = 0; | |
| 747 } | |
| 748 | |
| 749 /* find out which visual we are going to use */ | |
| 750 if ( flags & SDL_OPENGL ) { | |
| 751 XVisualInfo *vi; | |
| 752 | |
| 753 vi = X11_GL_GetVisual(this); | |
| 754 if( !vi ) { | |
| 755 return -1; | |
| 756 } | |
| 757 vis = vi->visual; | |
| 758 depth = vi->depth; | |
| 759 } else if ( SDL_windowid ) { | |
| 760 XWindowAttributes a; | |
| 761 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
762 pXGetWindowAttributes(SDL_Display, SDL_Window, &a); |
| 0 | 763 vis = a.visual; |
| 764 depth = a.depth; | |
| 765 } else { | |
| 766 for ( i = 0; i < this->hidden->nvisuals; i++ ) { | |
| 767 if ( this->hidden->visuals[i].bpp == bpp ) | |
| 768 break; | |
| 769 } | |
| 770 if ( i == this->hidden->nvisuals ) { | |
| 771 SDL_SetError("No matching visual for requested depth"); | |
| 772 return -1; /* should never happen */ | |
| 773 } | |
| 774 vis = this->hidden->visuals[i].visual; | |
| 775 depth = this->hidden->visuals[i].depth; | |
| 776 } | |
| 777 #ifdef X11_DEBUG | |
| 778 printf("Choosing %s visual at %d bpp - %d colormap entries\n", vis->class == PseudoColor ? "PseudoColor" : (vis->class == TrueColor ? "TrueColor" : (vis->class == DirectColor ? "DirectColor" : "Unknown")), depth, vis->map_entries); | |
| 779 #endif | |
| 780 vis_change = (vis != SDL_Visual); | |
| 781 SDL_Visual = vis; | |
| 782 this->hidden->depth = depth; | |
| 783 | |
| 784 /* Allocate the new pixel format for this video mode */ | |
| 785 if ( ! SDL_ReallocFormat(screen, bpp, | |
| 786 vis->red_mask, vis->green_mask, vis->blue_mask, 0) ) | |
| 787 return -1; | |
| 788 | |
| 789 /* Create the appropriate colormap */ | |
| 790 if ( SDL_XColorMap != SDL_DisplayColormap ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
791 pXFreeColormap(SDL_Display, SDL_XColorMap); |
| 0 | 792 } |
| 793 if ( SDL_Visual->class == PseudoColor ) { | |
| 794 int ncolors; | |
| 795 | |
| 796 /* Allocate the pixel flags */ | |
| 797 ncolors = SDL_Visual->map_entries; | |
| 798 SDL_XPixels = malloc(ncolors * sizeof(int)); | |
| 799 if(SDL_XPixels == NULL) { | |
| 800 SDL_OutOfMemory(); | |
| 801 return -1; | |
| 802 } | |
| 803 memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels)); | |
| 804 | |
| 805 /* always allocate a private colormap on non-default visuals */ | |
| 806 if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) { | |
| 807 flags |= SDL_HWPALETTE; | |
| 808 } | |
| 809 if ( flags & SDL_HWPALETTE ) { | |
| 810 screen->flags |= SDL_HWPALETTE; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
811 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
| 0 | 812 SDL_Visual, AllocAll); |
| 813 } else { | |
| 814 SDL_XColorMap = SDL_DisplayColormap; | |
| 815 } | |
| 816 } else if ( SDL_Visual->class == DirectColor ) { | |
| 817 | |
| 818 /* Create a colormap which we can manipulate for gamma */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
819 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
| 0 | 820 SDL_Visual, AllocAll); |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
821 pXSync(SDL_Display, False); |
| 0 | 822 |
| 823 /* Initialize the colormap to the identity mapping */ | |
| 824 SDL_GetGammaRamp(0, 0, 0); | |
| 825 this->screen = screen; | |
| 826 X11_SetGammaRamp(this, this->gamma); | |
| 827 this->screen = NULL; | |
| 828 } else { | |
| 829 /* Create a read-only colormap for our window */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
830 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
| 0 | 831 SDL_Visual, AllocNone); |
| 832 } | |
| 833 | |
| 834 /* Recreate the auxiliary windows, if needed (required for GL) */ | |
| 835 if ( vis_change ) | |
| 836 create_aux_windows(this); | |
| 837 | |
| 838 if(screen->flags & SDL_HWPALETTE) { | |
| 839 /* Since the full-screen window might have got a nonzero background | |
| 840 colour (0 is white on some displays), we should reset the | |
| 841 background to 0 here since that is what the user expects | |
| 842 with a private colormap */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
843 pXSetWindowBackground(SDL_Display, FSwindow, 0); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
844 pXClearWindow(SDL_Display, FSwindow); |
| 0 | 845 } |
| 846 | |
| 847 /* resize the (possibly new) window manager window */ | |
| 848 if( !SDL_windowid ) { | |
| 849 X11_SetSizeHints(this, w, h, flags); | |
| 850 current_w = w; | |
| 851 current_h = h; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
852 pXResizeWindow(SDL_Display, WMwindow, w, h); |
| 0 | 853 } |
| 854 | |
| 855 /* Create (or use) the X11 display window */ | |
| 856 if ( !SDL_windowid ) { | |
| 857 if ( flags & SDL_OPENGL ) { | |
| 858 if ( X11_GL_CreateWindow(this, w, h) < 0 ) { | |
| 859 return(-1); | |
| 860 } | |
| 861 } else { | |
| 862 XSetWindowAttributes swa; | |
| 863 | |
| 864 swa.background_pixel = 0; | |
| 865 swa.border_pixel = 0; | |
| 866 swa.colormap = SDL_XColorMap; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
867 SDL_Window = pXCreateWindow(SDL_Display, WMwindow, |
| 0 | 868 0, 0, w, h, 0, depth, |
| 869 InputOutput, SDL_Visual, | |
| 870 CWBackPixel | CWBorderPixel | |
| 871 | CWColormap, &swa); | |
| 872 } | |
| 873 /* Only manage our input if we own the window */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
874 pXSelectInput(SDL_Display, SDL_Window, |
| 0 | 875 ( EnterWindowMask | LeaveWindowMask |
| 876 | ButtonPressMask | ButtonReleaseMask | |
| 877 | PointerMotionMask | ExposureMask )); | |
| 878 } | |
| 879 /* Create the graphics context here, once we have a window */ | |
| 880 if ( flags & SDL_OPENGL ) { | |
| 881 if ( X11_GL_CreateContext(this) < 0 ) { | |
| 882 return(-1); | |
| 883 } else { | |
| 884 screen->flags |= SDL_OPENGL; | |
| 885 } | |
| 886 } else { | |
| 887 XGCValues gcv; | |
| 888 | |
| 889 gcv.graphics_exposures = False; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
890 SDL_GC = pXCreateGC(SDL_Display, SDL_Window, |
| 0 | 891 GCGraphicsExposures, &gcv); |
| 892 if ( ! SDL_GC ) { | |
| 893 SDL_SetError("Couldn't create graphics context"); | |
| 894 return(-1); | |
| 895 } | |
| 896 } | |
| 897 | |
| 898 /* Set our colormaps when not setting a GL mode */ | |
| 899 if ( ! (flags & SDL_OPENGL) ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
900 pXSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); |
| 0 | 901 if( !SDL_windowid ) { |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
902 pXSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
903 pXSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap); |
| 0 | 904 } |
| 905 } | |
| 906 | |
| 907 #if 0 /* This is an experiment - are the graphics faster now? - nope. */ | |
| 908 if ( getenv("SDL_VIDEO_X11_BACKINGSTORE") ) | |
| 909 #endif | |
| 910 /* Cache the window in the server, when possible */ | |
| 911 { | |
| 912 Screen *xscreen; | |
| 913 XSetWindowAttributes a; | |
| 914 | |
| 915 xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen); | |
| 916 a.backing_store = DoesBackingStore(xscreen); | |
| 917 if ( a.backing_store != NotUseful ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
918 pXChangeWindowAttributes(SDL_Display, SDL_Window, |
| 0 | 919 CWBackingStore, &a); |
| 920 } | |
| 921 } | |
| 922 | |
| 923 /* Update the internal keyboard state */ | |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
924 X11_SetKeyboardState(SDL_Display, SDL_IC, NULL); |
| 0 | 925 |
|
444
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
926 /* When the window is first mapped, ignore non-modifier keys */ |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
927 { |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
928 Uint8 *keys = SDL_GetKeyState(NULL); |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
929 for ( i = 0; i < SDLK_LAST; ++i ) { |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
930 switch (i) { |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
931 case SDLK_NUMLOCK: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
932 case SDLK_CAPSLOCK: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
933 case SDLK_LCTRL: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
934 case SDLK_RCTRL: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
935 case SDLK_LSHIFT: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
936 case SDLK_RSHIFT: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
937 case SDLK_LALT: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
938 case SDLK_RALT: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
939 case SDLK_LMETA: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
940 case SDLK_RMETA: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
941 case SDLK_MODE: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
942 break; |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
943 default: |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
944 keys[i] = SDL_RELEASED; |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
945 break; |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
946 } |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
947 } |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
948 } |
|
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
949 |
| 0 | 950 /* Map them both and go fullscreen, if requested */ |
| 951 if ( ! SDL_windowid ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
952 pXMapWindow(SDL_Display, SDL_Window); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
953 pXMapWindow(SDL_Display, WMwindow); |
| 160 | 954 X11_WaitMapped(this, WMwindow); |
| 0 | 955 if ( flags & SDL_FULLSCREEN ) { |
| 956 screen->flags |= SDL_FULLSCREEN; | |
| 957 X11_EnterFullScreen(this); | |
| 958 } else { | |
| 959 screen->flags &= ~SDL_FULLSCREEN; | |
| 960 } | |
| 961 } | |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
962 |
| 0 | 963 return(0); |
| 964 } | |
| 965 | |
| 966 static int X11_ResizeWindow(_THIS, | |
| 967 SDL_Surface *screen, int w, int h, Uint32 flags) | |
| 968 { | |
| 969 if ( ! SDL_windowid ) { | |
| 970 /* Resize the window manager window */ | |
| 971 X11_SetSizeHints(this, w, h, flags); | |
| 972 current_w = w; | |
| 973 current_h = h; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
974 pXResizeWindow(SDL_Display, WMwindow, w, h); |
| 0 | 975 |
| 976 /* Resize the fullscreen and display windows */ | |
| 977 if ( flags & SDL_FULLSCREEN ) { | |
| 978 if ( screen->flags & SDL_FULLSCREEN ) { | |
| 979 X11_ResizeFullScreen(this); | |
| 980 } else { | |
| 981 screen->flags |= SDL_FULLSCREEN; | |
| 982 X11_EnterFullScreen(this); | |
| 983 } | |
| 984 } else { | |
| 985 if ( screen->flags & SDL_FULLSCREEN ) { | |
| 986 screen->flags &= ~SDL_FULLSCREEN; | |
| 987 X11_LeaveFullScreen(this); | |
| 988 } | |
| 989 } | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
990 pXResizeWindow(SDL_Display, SDL_Window, w, h); |
| 0 | 991 } |
| 992 return(0); | |
| 993 } | |
| 994 | |
| 995 SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, | |
| 996 int width, int height, int bpp, Uint32 flags) | |
| 997 { | |
| 998 Uint32 saved_flags; | |
| 999 | |
| 1000 /* Lock the event thread, in multi-threading environments */ | |
| 1001 SDL_Lock_EventThread(); | |
| 1002 | |
| 1003 /* Check the combination of flags we were passed */ | |
| 1004 if ( flags & SDL_FULLSCREEN ) { | |
| 1005 /* Clear fullscreen flag if not supported */ | |
| 1006 if ( SDL_windowid ) { | |
| 1007 flags &= ~SDL_FULLSCREEN; | |
| 1008 } | |
| 1009 } | |
| 1010 | |
| 1011 /* Flush any delayed updates */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1012 pXSync(GFX_Display, False); |
| 0 | 1013 |
| 1014 /* Set up the X11 window */ | |
| 1015 saved_flags = current->flags; | |
|
867
5c7859610bc4
Force recreation of X11 window if going to or from a SDL_NOFRAME vidmode.
Ryan C. Gordon <icculus@icculus.org>
parents:
860
diff
changeset
|
1016 if ( (SDL_Window) && ((saved_flags&SDL_OPENGL) == (flags&SDL_OPENGL)) |
|
5c7859610bc4
Force recreation of X11 window if going to or from a SDL_NOFRAME vidmode.
Ryan C. Gordon <icculus@icculus.org>
parents:
860
diff
changeset
|
1017 && (bpp == current->format->BitsPerPixel) |
|
5c7859610bc4
Force recreation of X11 window if going to or from a SDL_NOFRAME vidmode.
Ryan C. Gordon <icculus@icculus.org>
parents:
860
diff
changeset
|
1018 && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) { |
| 0 | 1019 if (X11_ResizeWindow(this, current, width, height, flags) < 0) { |
| 1020 current = NULL; | |
| 1021 goto done; | |
| 1022 } | |
| 1023 } else { | |
| 1024 if (X11_CreateWindow(this,current,width,height,bpp,flags) < 0) { | |
| 1025 current = NULL; | |
| 1026 goto done; | |
| 1027 } | |
| 1028 } | |
| 1029 | |
| 1030 /* Set up the new mode framebuffer */ | |
| 1031 if ( ((current->w != width) || (current->h != height)) || | |
| 1032 ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) { | |
| 1033 current->w = width; | |
| 1034 current->h = height; | |
| 1035 current->pitch = SDL_CalculatePitch(current); | |
| 1036 X11_ResizeImage(this, current, flags); | |
| 1037 } | |
| 1038 current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME)); | |
| 1039 | |
| 1040 done: | |
| 1041 /* Release the event thread */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1042 pXSync(SDL_Display, False); |
| 0 | 1043 SDL_Unlock_EventThread(); |
| 1044 | |
| 1045 /* We're done! */ | |
| 1046 return(current); | |
| 1047 } | |
| 1048 | |
| 1049 static int X11_ToggleFullScreen(_THIS, int on) | |
| 1050 { | |
| 1051 Uint32 event_thread; | |
| 1052 | |
| 1053 /* Don't switch if we don't own the window */ | |
| 1054 if ( SDL_windowid ) { | |
| 1055 return(0); | |
| 1056 } | |
| 1057 | |
| 1058 /* Don't lock if we are the event thread */ | |
| 1059 event_thread = SDL_EventThreadID(); | |
| 1060 if ( event_thread && (SDL_ThreadID() == event_thread) ) { | |
| 1061 event_thread = 0; | |
| 1062 } | |
| 1063 if ( event_thread ) { | |
| 1064 SDL_Lock_EventThread(); | |
| 1065 } | |
| 1066 if ( on ) { | |
| 1067 this->screen->flags |= SDL_FULLSCREEN; | |
| 1068 X11_EnterFullScreen(this); | |
| 1069 } else { | |
| 1070 this->screen->flags &= ~SDL_FULLSCREEN; | |
| 1071 X11_LeaveFullScreen(this); | |
| 1072 } | |
| 1073 X11_RefreshDisplay(this); | |
| 1074 if ( event_thread ) { | |
| 1075 SDL_Unlock_EventThread(); | |
| 1076 } | |
| 1077 SDL_ResetKeyboard(); | |
| 1078 return(1); | |
| 1079 } | |
| 1080 | |
| 1081 /* Update the current mouse state and position */ | |
| 1082 static void X11_UpdateMouse(_THIS) | |
| 1083 { | |
| 1084 Window u1; int u2; | |
| 1085 Window current_win; | |
| 1086 int x, y; | |
| 1087 unsigned int mask; | |
| 1088 | |
| 1089 /* Lock the event thread, in multi-threading environments */ | |
| 1090 SDL_Lock_EventThread(); | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1091 if ( pXQueryPointer(SDL_Display, SDL_Window, &u1, ¤t_win, |
| 0 | 1092 &u2, &u2, &x, &y, &mask) ) { |
| 1093 if ( (x >= 0) && (x < SDL_VideoSurface->w) && | |
| 1094 (y >= 0) && (y < SDL_VideoSurface->h) ) { | |
| 1095 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); | |
| 1096 SDL_PrivateMouseMotion(0, 0, x, y); | |
| 1097 } else { | |
| 1098 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); | |
| 1099 } | |
| 1100 } | |
| 1101 SDL_Unlock_EventThread(); | |
| 1102 } | |
| 1103 | |
| 1104 /* simple colour distance metric. Supposed to be better than a plain | |
| 1105 Euclidian distance anyway. */ | |
| 1106 #define COLOUR_FACTOR 3 | |
| 1107 #define LIGHT_FACTOR 1 | |
| 1108 #define COLOUR_DIST(r1, g1, b1, r2, g2, b2) \ | |
| 1109 (COLOUR_FACTOR * (abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2)) \ | |
| 1110 + LIGHT_FACTOR * abs(r1 + g1 + b1 - (r2 + g2 + b2))) | |
| 1111 | |
| 1112 static void allocate_nearest(_THIS, SDL_Color *colors, | |
| 1113 SDL_Color *want, int nwant) | |
| 1114 { | |
| 1115 /* | |
| 1116 * There is no way to know which ones to choose from, so we retrieve | |
| 1117 * the entire colormap and try the nearest possible, until we find one | |
| 1118 * that is shared. | |
| 1119 */ | |
| 1120 XColor all[256]; | |
| 1121 int i; | |
| 1122 for(i = 0; i < 256; i++) | |
| 1123 all[i].pixel = i; | |
| 1124 /* | |
| 1125 * XQueryColors sets the flags in the XColor struct, so we use | |
| 1126 * that to keep track of which colours are available | |
| 1127 */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1128 pXQueryColors(GFX_Display, SDL_XColorMap, all, 256); |
| 0 | 1129 |
| 1130 for(i = 0; i < nwant; i++) { | |
| 1131 XColor *c; | |
| 1132 int j; | |
| 1133 int best = 0; | |
| 1134 int mindist = 0x7fffffff; | |
| 1135 int ri = want[i].r; | |
| 1136 int gi = want[i].g; | |
| 1137 int bi = want[i].b; | |
| 1138 for(j = 0; j < 256; j++) { | |
| 1139 int rj, gj, bj, d2; | |
| 1140 if(!all[j].flags) | |
| 1141 continue; /* unavailable colour cell */ | |
| 1142 rj = all[j].red >> 8; | |
| 1143 gj = all[j].green >> 8; | |
| 1144 bj = all[j].blue >> 8; | |
| 1145 d2 = COLOUR_DIST(ri, gi, bi, rj, gj, bj); | |
| 1146 if(d2 < mindist) { | |
| 1147 mindist = d2; | |
| 1148 best = j; | |
| 1149 } | |
| 1150 } | |
| 1151 if(SDL_XPixels[best]) | |
| 1152 continue; /* already allocated, waste no more time */ | |
| 1153 c = all + best; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1154 if(pXAllocColor(GFX_Display, SDL_XColorMap, c)) { |
| 0 | 1155 /* got it */ |
|
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1156 colors[c->pixel].r = c->red >> 8; |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1157 colors[c->pixel].g = c->green >> 8; |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1158 colors[c->pixel].b = c->blue >> 8; |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1159 ++SDL_XPixels[c->pixel]; |
| 0 | 1160 } else { |
| 1161 /* | |
| 1162 * The colour couldn't be allocated, probably being | |
| 1163 * owned as a r/w cell by another client. Flag it as | |
| 1164 * unavailable and try again. The termination of the | |
| 1165 * loop is guaranteed since at least black and white | |
| 1166 * are always there. | |
| 1167 */ | |
| 1168 c->flags = 0; | |
| 1169 i--; | |
| 1170 } | |
| 1171 } | |
| 1172 } | |
| 1173 | |
| 1174 int X11_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | |
| 1175 { | |
| 1176 int nrej = 0; | |
| 1177 | |
| 1178 /* Check to make sure we have a colormap allocated */ | |
| 1179 if ( SDL_XPixels == NULL ) { | |
| 1180 return(0); | |
| 1181 } | |
| 1182 if ( (this->screen->flags & SDL_HWPALETTE) == SDL_HWPALETTE ) { | |
| 1183 /* private writable colormap: just set the colours we need */ | |
| 1184 XColor *xcmap; | |
| 1185 int i; | |
| 1186 xcmap = ALLOCA(ncolors*sizeof(*xcmap)); | |
| 1187 if(xcmap == NULL) | |
| 1188 return 0; | |
| 1189 for ( i=0; i<ncolors; ++i ) { | |
| 1190 xcmap[i].pixel = i + firstcolor; | |
| 1191 xcmap[i].red = (colors[i].r<<8)|colors[i].r; | |
| 1192 xcmap[i].green = (colors[i].g<<8)|colors[i].g; | |
| 1193 xcmap[i].blue = (colors[i].b<<8)|colors[i].b; | |
| 1194 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | |
| 1195 } | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1196 pXStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1197 pXSync(GFX_Display, False); |
| 0 | 1198 FREEA(xcmap); |
| 1199 } else { | |
| 1200 /* | |
| 1201 * Shared colormap: We only allocate read-only cells, which | |
| 1202 * increases the likelyhood of colour sharing with other | |
| 1203 * clients. The pixel values will almost certainly be | |
| 1204 * different from the requested ones, so the user has to | |
| 1205 * walk the colormap and see which index got what colour. | |
| 1206 * | |
| 1207 * We can work directly with the logical palette since it | |
| 1208 * has already been set when we get here. | |
| 1209 */ | |
| 1210 SDL_Color *want, *reject; | |
| 1211 unsigned long *freelist; | |
| 1212 int i; | |
| 1213 int nfree = 0; | |
| 1214 int nc = this->screen->format->palette->ncolors; | |
| 1215 colors = this->screen->format->palette->colors; | |
| 1216 freelist = ALLOCA(nc * sizeof(*freelist)); | |
| 1217 /* make sure multiple allocations of the same cell are freed */ | |
| 1218 for(i = 0; i < ncolors; i++) { | |
| 1219 int pixel = firstcolor + i; | |
| 1220 while(SDL_XPixels[pixel]) { | |
| 1221 freelist[nfree++] = pixel; | |
| 1222 --SDL_XPixels[pixel]; | |
| 1223 } | |
| 1224 } | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1225 pXFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0); |
| 0 | 1226 FREEA(freelist); |
| 1227 | |
| 1228 want = ALLOCA(ncolors * sizeof(SDL_Color)); | |
| 1229 reject = ALLOCA(ncolors * sizeof(SDL_Color)); | |
| 1230 memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color)); | |
| 1231 /* make sure the user isn't fooled by her own wishes | |
| 1232 (black is safe, always available in the default colormap) */ | |
| 1233 memset(colors + firstcolor, 0, ncolors * sizeof(SDL_Color)); | |
| 1234 | |
| 1235 /* now try to allocate the colours */ | |
| 1236 for(i = 0; i < ncolors; i++) { | |
| 1237 XColor col; | |
| 1238 col.red = want[i].r << 8; | |
| 1239 col.green = want[i].g << 8; | |
| 1240 col.blue = want[i].b << 8; | |
| 1241 col.flags = DoRed | DoGreen | DoBlue; | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1242 if(pXAllocColor(GFX_Display, SDL_XColorMap, &col)) { |
| 0 | 1243 /* We got the colour, or at least the nearest |
| 1244 the hardware could get. */ | |
| 1245 colors[col.pixel].r = col.red >> 8; | |
| 1246 colors[col.pixel].g = col.green >> 8; | |
| 1247 colors[col.pixel].b = col.blue >> 8; | |
| 1248 ++SDL_XPixels[col.pixel]; | |
| 1249 } else { | |
| 1250 /* | |
| 1251 * no more free cells, add it to the list | |
| 1252 * of rejected colours | |
| 1253 */ | |
| 1254 reject[nrej++] = want[i]; | |
| 1255 } | |
| 1256 } | |
| 1257 if(nrej) | |
| 1258 allocate_nearest(this, colors, reject, nrej); | |
| 1259 FREEA(reject); | |
| 1260 FREEA(want); | |
| 1261 } | |
| 1262 return nrej == 0; | |
| 1263 } | |
| 1264 | |
| 1265 int X11_SetGammaRamp(_THIS, Uint16 *ramp) | |
| 1266 { | |
| 1267 int i, ncolors; | |
| 1268 XColor xcmap[256]; | |
| 1269 | |
| 1270 /* See if actually setting the gamma is supported */ | |
| 1271 if ( SDL_Visual->class != DirectColor ) { | |
| 1272 SDL_SetError("Gamma correction not supported on this visual"); | |
| 1273 return(-1); | |
| 1274 } | |
| 1275 | |
| 1276 /* Calculate the appropriate palette for the given gamma ramp */ | |
| 1277 ncolors = SDL_Visual->map_entries; | |
| 1278 for ( i=0; i<ncolors; ++i ) { | |
| 1279 Uint8 c = (256 * i / ncolors); | |
| 1280 xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c); | |
| 1281 xcmap[i].red = ramp[0*256+c]; | |
| 1282 xcmap[i].green = ramp[1*256+c]; | |
| 1283 xcmap[i].blue = ramp[2*256+c]; | |
| 1284 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | |
| 1285 } | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1286 pXStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1287 pXSync(GFX_Display, False); |
| 0 | 1288 return(0); |
| 1289 } | |
| 1290 | |
| 1291 /* Note: If we are terminated, this could be called in the middle of | |
| 1292 another SDL video routine -- notably UpdateRects. | |
| 1293 */ | |
| 1294 void X11_VideoQuit(_THIS) | |
| 1295 { | |
| 1296 /* Shutdown everything that's still up */ | |
| 1297 /* The event thread should be done, so we can touch SDL_Display */ | |
| 1298 if ( SDL_Display != NULL ) { | |
| 1299 /* Flush any delayed updates */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1300 pXSync(GFX_Display, False); |
| 0 | 1301 |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1302 /* Close the connection with the IM server */ |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1303 #ifdef X_HAVE_UTF8_STRING |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1304 if (SDL_IC == NULL) { |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1305 pXDestroyIC(SDL_IC); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1306 SDL_IC = NULL; |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1307 } |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1308 if (SDL_IM == NULL) { |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1309 pXCloseIM(SDL_IM); |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1310 SDL_IM = NULL; |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1311 } |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1312 #endif |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1313 |
| 0 | 1314 /* Start shutting down the windows */ |
| 1315 X11_DestroyImage(this, this->screen); | |
| 1316 X11_DestroyWindow(this, this->screen); | |
| 1317 X11_FreeVideoModes(this); | |
| 1318 if ( SDL_XColorMap != SDL_DisplayColormap ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1319 pXFreeColormap(SDL_Display, SDL_XColorMap); |
| 0 | 1320 } |
| 1321 if ( SDL_iconcolors ) { | |
| 1322 unsigned long pixel; | |
|
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1323 Colormap dcmap = DefaultColormap(SDL_Display, |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1324 SDL_Screen); |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1325 for(pixel = 0; pixel < 256; ++pixel) { |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1326 while(SDL_iconcolors[pixel] > 0) { |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1327 pXFreeColors(GFX_Display, |
|
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1328 dcmap, &pixel, 1, 0); |
| 0 | 1329 --SDL_iconcolors[pixel]; |
| 1330 } | |
| 1331 } | |
| 1332 free(SDL_iconcolors); | |
| 1333 SDL_iconcolors = NULL; | |
| 1334 } | |
| 1335 /* Restore gamma settings if they've changed */ | |
| 1336 if ( SDL_GetAppState() & SDL_APPACTIVE ) { | |
| 1337 X11_SwapVidModeGamma(this); | |
| 1338 } | |
| 1339 | |
| 1340 /* Free that blank cursor */ | |
| 1341 if ( SDL_BlankCursor != NULL ) { | |
| 1342 this->FreeWMCursor(this, SDL_BlankCursor); | |
| 1343 SDL_BlankCursor = NULL; | |
| 1344 } | |
| 1345 | |
| 1346 /* Close the X11 graphics connection */ | |
| 1347 if ( GFX_Display != NULL ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1348 pXCloseDisplay(GFX_Display); |
| 0 | 1349 GFX_Display = NULL; |
| 1350 } | |
| 1351 | |
| 1352 /* Close the X11 display connection */ | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1353 pXCloseDisplay(SDL_Display); |
| 0 | 1354 SDL_Display = NULL; |
| 1355 | |
| 1356 /* Reset the X11 error handlers */ | |
| 1357 if ( XIO_handler ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1358 pXSetIOErrorHandler(XIO_handler); |
| 0 | 1359 } |
| 1360 if ( X_handler ) { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1361 pXSetErrorHandler(X_handler); |
| 0 | 1362 } |
| 1363 | |
| 1364 /* Unload GL library after X11 shuts down */ | |
| 1365 X11_GL_UnloadLibrary(this); | |
| 1366 } | |
| 1367 if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) { | |
| 1368 /* Direct screen access, no memory buffer */ | |
| 1369 this->screen->pixels = NULL; | |
| 1370 } | |
| 1371 } | |
| 1372 |