Mercurial > sdl-ios-xcode
annotate src/video/x11/SDL_x11video.c @ 1248:d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
queried for a missing extension (such as the XiG vidmode one that most
people don't have), and default Xlib behaviour is to write notification to
stderr, this tends to generate incorrect bug reports.
Since we'll actually deal with the missing extension when querying for it,
we ignore these errors in our hook. The rest continue to pass through to
the default handler.
Fixes Bugzilla #42.
--ryan.
author | Ryan C. Gordon <icculus@icculus.org> |
---|---|
date | Sat, 14 Jan 2006 08:15:38 +0000 |
parents | aac47040c6d7 |
children | 2bf9dda618e5 |
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); |
0 | 439 if ( SDL_Display == NULL ) { |
440 SDL_SetError("Couldn't open X11 display"); | |
441 return(-1); | |
442 } | |
443 #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
|
444 pXSynchronize(SDL_Display, True); |
0 | 445 #endif |
446 | |
447 /* Create an alternate X display for graphics updates -- allows us | |
448 to do graphics updates in a separate thread from event handling. | |
449 Thread-safe X11 doesn't seem to exist. | |
450 */ | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
451 GFX_Display = pXOpenDisplay(display); |
0 | 452 if ( GFX_Display == NULL ) { |
453 SDL_SetError("Couldn't open X11 display"); | |
454 return(-1); | |
455 } | |
456 | |
457 /* 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
|
458 X_handler = pXSetErrorHandler(x_errhandler); |
0 | 459 |
460 /* 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
|
461 XIO_handler = pXSetIOErrorHandler(xio_errhandler); |
0 | 462 |
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
463 /* 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
|
464 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
|
465 |
0 | 466 /* use default screen (from $DISPLAY) */ |
467 SDL_Screen = DefaultScreen(SDL_Display); | |
468 | |
469 #ifndef NO_SHARED_MEMORY | |
470 /* 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
|
471 use_mitshm = 0; |
0 | 472 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
|
473 use_mitshm = pXShmQueryExtension(SDL_Display); |
0 | 474 } |
475 #endif /* NO_SHARED_MEMORY */ | |
476 | |
477 /* Get the available video modes */ | |
478 if(X11_GetVideoModes(this) < 0) | |
479 return -1; | |
480 | |
481 /* Determine the default screen depth: | |
482 Use the default visual (or at least one with the same depth) */ | |
483 SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen); | |
484 for(i = 0; i < this->hidden->nvisuals; i++) | |
485 if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display, | |
486 SDL_Screen)) | |
487 break; | |
488 if(i == this->hidden->nvisuals) { | |
489 /* default visual was useless, take the deepest one instead */ | |
490 i = 0; | |
491 } | |
492 SDL_Visual = this->hidden->visuals[i].visual; | |
493 if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) { | |
494 SDL_XColorMap = SDL_DisplayColormap; | |
495 } 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
|
496 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
0 | 497 SDL_Visual, AllocNone); |
498 } | |
499 this->hidden->depth = this->hidden->visuals[i].depth; | |
500 vformat->BitsPerPixel = this->hidden->visuals[i].bpp; | |
501 if ( vformat->BitsPerPixel > 8 ) { | |
502 vformat->Rmask = SDL_Visual->red_mask; | |
503 vformat->Gmask = SDL_Visual->green_mask; | |
504 vformat->Bmask = SDL_Visual->blue_mask; | |
505 } | |
506 X11_SaveVidModeGamma(this); | |
507 | |
508 /* See if we have been passed a window to use */ | |
509 SDL_windowid = getenv("SDL_WINDOWID"); | |
510 | |
511 /* Create the fullscreen and managed windows */ | |
512 create_aux_windows(this); | |
513 | |
514 /* Create the blank cursor */ | |
515 SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask, | |
516 BLANK_CWIDTH, BLANK_CHEIGHT, | |
517 BLANK_CHOTX, BLANK_CHOTY); | |
518 | |
519 /* Fill in some window manager capabilities */ | |
520 this->info.wm_available = 1; | |
521 | |
522 /* 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
|
523 pXFlush(SDL_Display); |
0 | 524 return(0); |
525 } | |
526 | |
527 static void X11_DestroyWindow(_THIS, SDL_Surface *screen) | |
528 { | |
529 /* Clean up OpenGL */ | |
530 if ( screen ) { | |
531 screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT); | |
532 } | |
533 X11_GL_Shutdown(this); | |
534 | |
535 if ( ! SDL_windowid ) { | |
536 /* Hide the managed window */ | |
537 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
|
538 pXUnmapWindow(SDL_Display, WMwindow); |
0 | 539 } |
540 if ( screen && (screen->flags & SDL_FULLSCREEN) ) { | |
541 screen->flags &= ~SDL_FULLSCREEN; | |
542 X11_LeaveFullScreen(this); | |
543 } | |
544 | |
545 /* Destroy the output window */ | |
546 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
|
547 pXDestroyWindow(SDL_Display, SDL_Window); |
0 | 548 } |
549 | |
550 /* Free the colormap entries */ | |
551 if ( SDL_XPixels ) { | |
552 int numcolors; | |
553 unsigned long pixel; | |
554 numcolors = SDL_Visual->map_entries; | |
555 for ( pixel=0; pixel<numcolors; ++pixel ) { | |
556 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
|
557 pXFreeColors(GFX_Display, |
0 | 558 SDL_DisplayColormap,&pixel,1,0); |
559 --SDL_XPixels[pixel]; | |
560 } | |
561 } | |
562 free(SDL_XPixels); | |
563 SDL_XPixels = NULL; | |
564 } | |
565 | |
566 /* Free the graphics context */ | |
567 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
|
568 pXFreeGC(SDL_Display, SDL_GC); |
0 | 569 SDL_GC = 0; |
570 } | |
571 } | |
572 } | |
573 | |
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
574 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
|
575 { |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
576 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
|
577 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
|
578 if ( window ) { |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
579 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
|
580 return SDL_TRUE; |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
581 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
582 if ( strcmp(window, "center") == 0 ) { |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
583 center = window; |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
584 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
585 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
586 if ( center ) { |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
587 *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
|
588 *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
|
589 return SDL_TRUE; |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
590 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
591 return SDL_FALSE; |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
592 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
593 |
0 | 594 static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags) |
595 { | |
596 XSizeHints *hints; | |
597 | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
598 hints = pXAllocSizeHints(); |
0 | 599 if ( hints ) { |
600 if ( flags & SDL_RESIZABLE ) { | |
601 hints->min_width = 32; | |
602 hints->min_height = 32; | |
603 hints->max_height = 4096; | |
604 hints->max_width = 4096; | |
605 } else { | |
606 hints->min_width = hints->max_width = w; | |
607 hints->min_height = hints->max_height = h; | |
608 } | |
609 hints->flags = PMaxSize | PMinSize; | |
610 if ( flags & SDL_FULLSCREEN ) { | |
611 hints->x = 0; | |
612 hints->y = 0; | |
613 hints->flags |= USPosition; | |
614 } else | |
615 /* Center it, if desired */ | |
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
616 if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) { |
0 | 617 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
|
618 pXMoveWindow(SDL_Display, WMwindow, hints->x, hints->y); |
0 | 619 |
620 /* 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
|
621 pXSync(SDL_Display, True); |
0 | 622 } |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
623 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
|
624 pXFree(hints); |
0 | 625 } |
626 | |
627 /* Respect the window caption style */ | |
628 if ( flags & SDL_NOFRAME ) { | |
629 SDL_bool set; | |
630 Atom WM_HINTS; | |
631 | |
632 /* We haven't modified the window manager hints yet */ | |
633 set = SDL_FALSE; | |
634 | |
635 /* 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
|
636 WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
0 | 637 if ( WM_HINTS != None ) { |
638 /* Hints used by Motif compliant window managers */ | |
639 struct { | |
640 unsigned long flags; | |
641 unsigned long functions; | |
642 unsigned long decorations; | |
643 long input_mode; | |
644 unsigned long status; | |
645 } MWMHints = { (1L << 1), 0, 0, 0, 0 }; | |
646 | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
647 pXChangeProperty(SDL_Display, WMwindow, |
0 | 648 WM_HINTS, WM_HINTS, 32, |
649 PropModeReplace, | |
650 (unsigned char *)&MWMHints, | |
651 sizeof(MWMHints)/sizeof(long)); | |
652 set = SDL_TRUE; | |
653 } | |
654 /* 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
|
655 WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
0 | 656 if ( WM_HINTS != None ) { |
657 long KWMHints = 0; | |
658 | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
659 pXChangeProperty(SDL_Display, WMwindow, |
0 | 660 WM_HINTS, WM_HINTS, 32, |
661 PropModeReplace, | |
662 (unsigned char *)&KWMHints, | |
663 sizeof(KWMHints)/sizeof(long)); | |
664 set = SDL_TRUE; | |
665 } | |
666 /* 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
|
667 WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True); |
0 | 668 if ( WM_HINTS != None ) { |
669 long GNOMEHints = 0; | |
670 | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
671 pXChangeProperty(SDL_Display, WMwindow, |
0 | 672 WM_HINTS, WM_HINTS, 32, |
673 PropModeReplace, | |
674 (unsigned char *)&GNOMEHints, | |
675 sizeof(GNOMEHints)/sizeof(long)); | |
676 set = SDL_TRUE; | |
677 } | |
678 /* Finally set the transient hints if necessary */ | |
679 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
|
680 pXSetTransientForHint(SDL_Display, WMwindow, SDL_Root); |
0 | 681 } |
682 } else { | |
683 SDL_bool set; | |
684 Atom WM_HINTS; | |
685 | |
686 /* We haven't modified the window manager hints yet */ | |
687 set = SDL_FALSE; | |
688 | |
689 /* 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
|
690 WM_HINTS = pXInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
0 | 691 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
|
692 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
0 | 693 set = SDL_TRUE; |
694 } | |
695 /* 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
|
696 WM_HINTS = pXInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
0 | 697 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
|
698 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
0 | 699 set = SDL_TRUE; |
700 } | |
701 /* 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
|
702 WM_HINTS = pXInternAtom(SDL_Display, "_WIN_HINTS", True); |
0 | 703 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
|
704 pXDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
0 | 705 set = SDL_TRUE; |
706 } | |
707 /* Finally unset the transient hints if necessary */ | |
708 if ( ! set ) { | |
709 /* 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
|
710 pXSetTransientForHint(SDL_Display, WMwindow, None); |
0 | 711 } |
712 } | |
713 } | |
714 | |
715 static int X11_CreateWindow(_THIS, SDL_Surface *screen, | |
716 int w, int h, int bpp, Uint32 flags) | |
717 { | |
718 int i, depth; | |
719 Visual *vis; | |
720 int vis_change; | |
721 | |
722 /* If a window is already present, destroy it and start fresh */ | |
723 if ( SDL_Window ) { | |
724 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
|
725 switch_waiting = 0; /* Prevent jump back to now-meaningless state. */ |
0 | 726 } |
727 | |
728 /* See if we have been given a window id */ | |
729 if ( SDL_windowid ) { | |
730 SDL_Window = strtol(SDL_windowid, NULL, 0); | |
731 } else { | |
732 SDL_Window = 0; | |
733 } | |
734 | |
735 /* find out which visual we are going to use */ | |
736 if ( flags & SDL_OPENGL ) { | |
737 XVisualInfo *vi; | |
738 | |
739 vi = X11_GL_GetVisual(this); | |
740 if( !vi ) { | |
741 return -1; | |
742 } | |
743 vis = vi->visual; | |
744 depth = vi->depth; | |
745 } else if ( SDL_windowid ) { | |
746 XWindowAttributes a; | |
747 | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
748 pXGetWindowAttributes(SDL_Display, SDL_Window, &a); |
0 | 749 vis = a.visual; |
750 depth = a.depth; | |
751 } else { | |
752 for ( i = 0; i < this->hidden->nvisuals; i++ ) { | |
753 if ( this->hidden->visuals[i].bpp == bpp ) | |
754 break; | |
755 } | |
756 if ( i == this->hidden->nvisuals ) { | |
757 SDL_SetError("No matching visual for requested depth"); | |
758 return -1; /* should never happen */ | |
759 } | |
760 vis = this->hidden->visuals[i].visual; | |
761 depth = this->hidden->visuals[i].depth; | |
762 } | |
763 #ifdef X11_DEBUG | |
764 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); | |
765 #endif | |
766 vis_change = (vis != SDL_Visual); | |
767 SDL_Visual = vis; | |
768 this->hidden->depth = depth; | |
769 | |
770 /* Allocate the new pixel format for this video mode */ | |
771 if ( ! SDL_ReallocFormat(screen, bpp, | |
772 vis->red_mask, vis->green_mask, vis->blue_mask, 0) ) | |
773 return -1; | |
774 | |
775 /* Create the appropriate colormap */ | |
776 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
|
777 pXFreeColormap(SDL_Display, SDL_XColorMap); |
0 | 778 } |
779 if ( SDL_Visual->class == PseudoColor ) { | |
780 int ncolors; | |
781 | |
782 /* Allocate the pixel flags */ | |
783 ncolors = SDL_Visual->map_entries; | |
784 SDL_XPixels = malloc(ncolors * sizeof(int)); | |
785 if(SDL_XPixels == NULL) { | |
786 SDL_OutOfMemory(); | |
787 return -1; | |
788 } | |
789 memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels)); | |
790 | |
791 /* always allocate a private colormap on non-default visuals */ | |
792 if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) { | |
793 flags |= SDL_HWPALETTE; | |
794 } | |
795 if ( flags & SDL_HWPALETTE ) { | |
796 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
|
797 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
0 | 798 SDL_Visual, AllocAll); |
799 } else { | |
800 SDL_XColorMap = SDL_DisplayColormap; | |
801 } | |
802 } else if ( SDL_Visual->class == DirectColor ) { | |
803 | |
804 /* 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
|
805 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
0 | 806 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
|
807 pXSync(SDL_Display, False); |
0 | 808 |
809 /* Initialize the colormap to the identity mapping */ | |
810 SDL_GetGammaRamp(0, 0, 0); | |
811 this->screen = screen; | |
812 X11_SetGammaRamp(this, this->gamma); | |
813 this->screen = NULL; | |
814 } else { | |
815 /* 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
|
816 SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root, |
0 | 817 SDL_Visual, AllocNone); |
818 } | |
819 | |
820 /* Recreate the auxiliary windows, if needed (required for GL) */ | |
821 if ( vis_change ) | |
822 create_aux_windows(this); | |
823 | |
824 if(screen->flags & SDL_HWPALETTE) { | |
825 /* Since the full-screen window might have got a nonzero background | |
826 colour (0 is white on some displays), we should reset the | |
827 background to 0 here since that is what the user expects | |
828 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
|
829 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
|
830 pXClearWindow(SDL_Display, FSwindow); |
0 | 831 } |
832 | |
833 /* resize the (possibly new) window manager window */ | |
834 if( !SDL_windowid ) { | |
835 X11_SetSizeHints(this, w, h, flags); | |
836 current_w = w; | |
837 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
|
838 pXResizeWindow(SDL_Display, WMwindow, w, h); |
0 | 839 } |
840 | |
841 /* Create (or use) the X11 display window */ | |
842 if ( !SDL_windowid ) { | |
843 if ( flags & SDL_OPENGL ) { | |
844 if ( X11_GL_CreateWindow(this, w, h) < 0 ) { | |
845 return(-1); | |
846 } | |
847 } else { | |
848 XSetWindowAttributes swa; | |
849 | |
850 swa.background_pixel = 0; | |
851 swa.border_pixel = 0; | |
852 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
|
853 SDL_Window = pXCreateWindow(SDL_Display, WMwindow, |
0 | 854 0, 0, w, h, 0, depth, |
855 InputOutput, SDL_Visual, | |
856 CWBackPixel | CWBorderPixel | |
857 | CWColormap, &swa); | |
858 } | |
859 /* 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
|
860 pXSelectInput(SDL_Display, SDL_Window, |
0 | 861 ( EnterWindowMask | LeaveWindowMask |
862 | ButtonPressMask | ButtonReleaseMask | |
863 | PointerMotionMask | ExposureMask )); | |
864 } | |
865 /* Create the graphics context here, once we have a window */ | |
866 if ( flags & SDL_OPENGL ) { | |
867 if ( X11_GL_CreateContext(this) < 0 ) { | |
868 return(-1); | |
869 } else { | |
870 screen->flags |= SDL_OPENGL; | |
871 } | |
872 } else { | |
873 XGCValues gcv; | |
874 | |
875 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
|
876 SDL_GC = pXCreateGC(SDL_Display, SDL_Window, |
0 | 877 GCGraphicsExposures, &gcv); |
878 if ( ! SDL_GC ) { | |
879 SDL_SetError("Couldn't create graphics context"); | |
880 return(-1); | |
881 } | |
882 } | |
883 | |
884 /* Set our colormaps when not setting a GL mode */ | |
885 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
|
886 pXSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); |
0 | 887 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
|
888 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
|
889 pXSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap); |
0 | 890 } |
891 } | |
892 | |
893 #if 0 /* This is an experiment - are the graphics faster now? - nope. */ | |
894 if ( getenv("SDL_VIDEO_X11_BACKINGSTORE") ) | |
895 #endif | |
896 /* Cache the window in the server, when possible */ | |
897 { | |
898 Screen *xscreen; | |
899 XSetWindowAttributes a; | |
900 | |
901 xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen); | |
902 a.backing_store = DoesBackingStore(xscreen); | |
903 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
|
904 pXChangeWindowAttributes(SDL_Display, SDL_Window, |
0 | 905 CWBackingStore, &a); |
906 } | |
907 } | |
908 | |
909 /* 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
|
910 X11_SetKeyboardState(SDL_Display, SDL_IC, NULL); |
0 | 911 |
444
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
912 /* 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
|
913 { |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
914 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
|
915 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
|
916 switch (i) { |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
917 case SDLK_NUMLOCK: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
918 case SDLK_CAPSLOCK: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
919 case SDLK_LCTRL: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
920 case SDLK_RCTRL: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
921 case SDLK_LSHIFT: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
922 case SDLK_RSHIFT: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
923 case SDLK_LALT: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
924 case SDLK_RALT: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
925 case SDLK_LMETA: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
926 case SDLK_RMETA: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
927 case SDLK_MODE: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
928 break; |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
929 default: |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
930 keys[i] = SDL_RELEASED; |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
931 break; |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
932 } |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
933 } |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
934 } |
406b12a17b15
Only modifier key state is noted when X11 window opens
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
935 |
0 | 936 /* Map them both and go fullscreen, if requested */ |
937 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
|
938 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
|
939 pXMapWindow(SDL_Display, WMwindow); |
160 | 940 X11_WaitMapped(this, WMwindow); |
0 | 941 if ( flags & SDL_FULLSCREEN ) { |
942 screen->flags |= SDL_FULLSCREEN; | |
943 X11_EnterFullScreen(this); | |
944 } else { | |
945 screen->flags &= ~SDL_FULLSCREEN; | |
946 } | |
947 } | |
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
948 |
0 | 949 return(0); |
950 } | |
951 | |
952 static int X11_ResizeWindow(_THIS, | |
953 SDL_Surface *screen, int w, int h, Uint32 flags) | |
954 { | |
955 if ( ! SDL_windowid ) { | |
956 /* Resize the window manager window */ | |
957 X11_SetSizeHints(this, w, h, flags); | |
958 current_w = w; | |
959 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
|
960 pXResizeWindow(SDL_Display, WMwindow, w, h); |
0 | 961 |
962 /* Resize the fullscreen and display windows */ | |
963 if ( flags & SDL_FULLSCREEN ) { | |
964 if ( screen->flags & SDL_FULLSCREEN ) { | |
965 X11_ResizeFullScreen(this); | |
966 } else { | |
967 screen->flags |= SDL_FULLSCREEN; | |
968 X11_EnterFullScreen(this); | |
969 } | |
970 } else { | |
971 if ( screen->flags & SDL_FULLSCREEN ) { | |
972 screen->flags &= ~SDL_FULLSCREEN; | |
973 X11_LeaveFullScreen(this); | |
974 } | |
975 } | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
976 pXResizeWindow(SDL_Display, SDL_Window, w, h); |
0 | 977 } |
978 return(0); | |
979 } | |
980 | |
981 SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, | |
982 int width, int height, int bpp, Uint32 flags) | |
983 { | |
984 Uint32 saved_flags; | |
985 | |
986 /* Lock the event thread, in multi-threading environments */ | |
987 SDL_Lock_EventThread(); | |
988 | |
989 /* Check the combination of flags we were passed */ | |
990 if ( flags & SDL_FULLSCREEN ) { | |
991 /* Clear fullscreen flag if not supported */ | |
992 if ( SDL_windowid ) { | |
993 flags &= ~SDL_FULLSCREEN; | |
994 } | |
995 } | |
996 | |
997 /* 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
|
998 pXSync(GFX_Display, False); |
0 | 999 |
1000 /* Set up the X11 window */ | |
1001 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
|
1002 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
|
1003 && (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
|
1004 && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) { |
0 | 1005 if (X11_ResizeWindow(this, current, width, height, flags) < 0) { |
1006 current = NULL; | |
1007 goto done; | |
1008 } | |
1009 } else { | |
1010 if (X11_CreateWindow(this,current,width,height,bpp,flags) < 0) { | |
1011 current = NULL; | |
1012 goto done; | |
1013 } | |
1014 } | |
1015 | |
1016 /* Set up the new mode framebuffer */ | |
1017 if ( ((current->w != width) || (current->h != height)) || | |
1018 ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) { | |
1019 current->w = width; | |
1020 current->h = height; | |
1021 current->pitch = SDL_CalculatePitch(current); | |
1022 X11_ResizeImage(this, current, flags); | |
1023 } | |
1024 current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME)); | |
1025 | |
1026 done: | |
1027 /* 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
|
1028 pXSync(SDL_Display, False); |
0 | 1029 SDL_Unlock_EventThread(); |
1030 | |
1031 /* We're done! */ | |
1032 return(current); | |
1033 } | |
1034 | |
1035 static int X11_ToggleFullScreen(_THIS, int on) | |
1036 { | |
1037 Uint32 event_thread; | |
1038 | |
1039 /* Don't switch if we don't own the window */ | |
1040 if ( SDL_windowid ) { | |
1041 return(0); | |
1042 } | |
1043 | |
1044 /* Don't lock if we are the event thread */ | |
1045 event_thread = SDL_EventThreadID(); | |
1046 if ( event_thread && (SDL_ThreadID() == event_thread) ) { | |
1047 event_thread = 0; | |
1048 } | |
1049 if ( event_thread ) { | |
1050 SDL_Lock_EventThread(); | |
1051 } | |
1052 if ( on ) { | |
1053 this->screen->flags |= SDL_FULLSCREEN; | |
1054 X11_EnterFullScreen(this); | |
1055 } else { | |
1056 this->screen->flags &= ~SDL_FULLSCREEN; | |
1057 X11_LeaveFullScreen(this); | |
1058 } | |
1059 X11_RefreshDisplay(this); | |
1060 if ( event_thread ) { | |
1061 SDL_Unlock_EventThread(); | |
1062 } | |
1063 SDL_ResetKeyboard(); | |
1064 return(1); | |
1065 } | |
1066 | |
1067 /* Update the current mouse state and position */ | |
1068 static void X11_UpdateMouse(_THIS) | |
1069 { | |
1070 Window u1; int u2; | |
1071 Window current_win; | |
1072 int x, y; | |
1073 unsigned int mask; | |
1074 | |
1075 /* Lock the event thread, in multi-threading environments */ | |
1076 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
|
1077 if ( pXQueryPointer(SDL_Display, SDL_Window, &u1, ¤t_win, |
0 | 1078 &u2, &u2, &x, &y, &mask) ) { |
1079 if ( (x >= 0) && (x < SDL_VideoSurface->w) && | |
1080 (y >= 0) && (y < SDL_VideoSurface->h) ) { | |
1081 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); | |
1082 SDL_PrivateMouseMotion(0, 0, x, y); | |
1083 } else { | |
1084 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); | |
1085 } | |
1086 } | |
1087 SDL_Unlock_EventThread(); | |
1088 } | |
1089 | |
1090 /* simple colour distance metric. Supposed to be better than a plain | |
1091 Euclidian distance anyway. */ | |
1092 #define COLOUR_FACTOR 3 | |
1093 #define LIGHT_FACTOR 1 | |
1094 #define COLOUR_DIST(r1, g1, b1, r2, g2, b2) \ | |
1095 (COLOUR_FACTOR * (abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2)) \ | |
1096 + LIGHT_FACTOR * abs(r1 + g1 + b1 - (r2 + g2 + b2))) | |
1097 | |
1098 static void allocate_nearest(_THIS, SDL_Color *colors, | |
1099 SDL_Color *want, int nwant) | |
1100 { | |
1101 /* | |
1102 * There is no way to know which ones to choose from, so we retrieve | |
1103 * the entire colormap and try the nearest possible, until we find one | |
1104 * that is shared. | |
1105 */ | |
1106 XColor all[256]; | |
1107 int i; | |
1108 for(i = 0; i < 256; i++) | |
1109 all[i].pixel = i; | |
1110 /* | |
1111 * XQueryColors sets the flags in the XColor struct, so we use | |
1112 * that to keep track of which colours are available | |
1113 */ | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1114 pXQueryColors(GFX_Display, SDL_XColorMap, all, 256); |
0 | 1115 |
1116 for(i = 0; i < nwant; i++) { | |
1117 XColor *c; | |
1118 int j; | |
1119 int best = 0; | |
1120 int mindist = 0x7fffffff; | |
1121 int ri = want[i].r; | |
1122 int gi = want[i].g; | |
1123 int bi = want[i].b; | |
1124 for(j = 0; j < 256; j++) { | |
1125 int rj, gj, bj, d2; | |
1126 if(!all[j].flags) | |
1127 continue; /* unavailable colour cell */ | |
1128 rj = all[j].red >> 8; | |
1129 gj = all[j].green >> 8; | |
1130 bj = all[j].blue >> 8; | |
1131 d2 = COLOUR_DIST(ri, gi, bi, rj, gj, bj); | |
1132 if(d2 < mindist) { | |
1133 mindist = d2; | |
1134 best = j; | |
1135 } | |
1136 } | |
1137 if(SDL_XPixels[best]) | |
1138 continue; /* already allocated, waste no more time */ | |
1139 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
|
1140 if(pXAllocColor(GFX_Display, SDL_XColorMap, c)) { |
0 | 1141 /* got it */ |
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1142 colors[c->pixel].r = c->red >> 8; |
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1143 colors[c->pixel].g = c->green >> 8; |
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1144 colors[c->pixel].b = c->blue >> 8; |
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1145 ++SDL_XPixels[c->pixel]; |
0 | 1146 } else { |
1147 /* | |
1148 * The colour couldn't be allocated, probably being | |
1149 * owned as a r/w cell by another client. Flag it as | |
1150 * unavailable and try again. The termination of the | |
1151 * loop is guaranteed since at least black and white | |
1152 * are always there. | |
1153 */ | |
1154 c->flags = 0; | |
1155 i--; | |
1156 } | |
1157 } | |
1158 } | |
1159 | |
1160 int X11_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | |
1161 { | |
1162 int nrej = 0; | |
1163 | |
1164 /* Check to make sure we have a colormap allocated */ | |
1165 if ( SDL_XPixels == NULL ) { | |
1166 return(0); | |
1167 } | |
1168 if ( (this->screen->flags & SDL_HWPALETTE) == SDL_HWPALETTE ) { | |
1169 /* private writable colormap: just set the colours we need */ | |
1170 XColor *xcmap; | |
1171 int i; | |
1172 xcmap = ALLOCA(ncolors*sizeof(*xcmap)); | |
1173 if(xcmap == NULL) | |
1174 return 0; | |
1175 for ( i=0; i<ncolors; ++i ) { | |
1176 xcmap[i].pixel = i + firstcolor; | |
1177 xcmap[i].red = (colors[i].r<<8)|colors[i].r; | |
1178 xcmap[i].green = (colors[i].g<<8)|colors[i].g; | |
1179 xcmap[i].blue = (colors[i].b<<8)|colors[i].b; | |
1180 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | |
1181 } | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1182 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
|
1183 pXSync(GFX_Display, False); |
0 | 1184 FREEA(xcmap); |
1185 } else { | |
1186 /* | |
1187 * Shared colormap: We only allocate read-only cells, which | |
1188 * increases the likelyhood of colour sharing with other | |
1189 * clients. The pixel values will almost certainly be | |
1190 * different from the requested ones, so the user has to | |
1191 * walk the colormap and see which index got what colour. | |
1192 * | |
1193 * We can work directly with the logical palette since it | |
1194 * has already been set when we get here. | |
1195 */ | |
1196 SDL_Color *want, *reject; | |
1197 unsigned long *freelist; | |
1198 int i; | |
1199 int nfree = 0; | |
1200 int nc = this->screen->format->palette->ncolors; | |
1201 colors = this->screen->format->palette->colors; | |
1202 freelist = ALLOCA(nc * sizeof(*freelist)); | |
1203 /* make sure multiple allocations of the same cell are freed */ | |
1204 for(i = 0; i < ncolors; i++) { | |
1205 int pixel = firstcolor + i; | |
1206 while(SDL_XPixels[pixel]) { | |
1207 freelist[nfree++] = pixel; | |
1208 --SDL_XPixels[pixel]; | |
1209 } | |
1210 } | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1211 pXFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0); |
0 | 1212 FREEA(freelist); |
1213 | |
1214 want = ALLOCA(ncolors * sizeof(SDL_Color)); | |
1215 reject = ALLOCA(ncolors * sizeof(SDL_Color)); | |
1216 memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color)); | |
1217 /* make sure the user isn't fooled by her own wishes | |
1218 (black is safe, always available in the default colormap) */ | |
1219 memset(colors + firstcolor, 0, ncolors * sizeof(SDL_Color)); | |
1220 | |
1221 /* now try to allocate the colours */ | |
1222 for(i = 0; i < ncolors; i++) { | |
1223 XColor col; | |
1224 col.red = want[i].r << 8; | |
1225 col.green = want[i].g << 8; | |
1226 col.blue = want[i].b << 8; | |
1227 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
|
1228 if(pXAllocColor(GFX_Display, SDL_XColorMap, &col)) { |
0 | 1229 /* We got the colour, or at least the nearest |
1230 the hardware could get. */ | |
1231 colors[col.pixel].r = col.red >> 8; | |
1232 colors[col.pixel].g = col.green >> 8; | |
1233 colors[col.pixel].b = col.blue >> 8; | |
1234 ++SDL_XPixels[col.pixel]; | |
1235 } else { | |
1236 /* | |
1237 * no more free cells, add it to the list | |
1238 * of rejected colours | |
1239 */ | |
1240 reject[nrej++] = want[i]; | |
1241 } | |
1242 } | |
1243 if(nrej) | |
1244 allocate_nearest(this, colors, reject, nrej); | |
1245 FREEA(reject); | |
1246 FREEA(want); | |
1247 } | |
1248 return nrej == 0; | |
1249 } | |
1250 | |
1251 int X11_SetGammaRamp(_THIS, Uint16 *ramp) | |
1252 { | |
1253 int i, ncolors; | |
1254 XColor xcmap[256]; | |
1255 | |
1256 /* See if actually setting the gamma is supported */ | |
1257 if ( SDL_Visual->class != DirectColor ) { | |
1258 SDL_SetError("Gamma correction not supported on this visual"); | |
1259 return(-1); | |
1260 } | |
1261 | |
1262 /* Calculate the appropriate palette for the given gamma ramp */ | |
1263 ncolors = SDL_Visual->map_entries; | |
1264 for ( i=0; i<ncolors; ++i ) { | |
1265 Uint8 c = (256 * i / ncolors); | |
1266 xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c); | |
1267 xcmap[i].red = ramp[0*256+c]; | |
1268 xcmap[i].green = ramp[1*256+c]; | |
1269 xcmap[i].blue = ramp[2*256+c]; | |
1270 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | |
1271 } | |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
1272 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
|
1273 pXSync(GFX_Display, False); |
0 | 1274 return(0); |
1275 } | |
1276 | |
1277 /* Note: If we are terminated, this could be called in the middle of | |
1278 another SDL video routine -- notably UpdateRects. | |
1279 */ | |
1280 void X11_VideoQuit(_THIS) | |
1281 { | |
1282 /* Shutdown everything that's still up */ | |
1283 /* The event thread should be done, so we can touch SDL_Display */ | |
1284 if ( SDL_Display != NULL ) { | |
1285 /* 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
|
1286 pXSync(GFX_Display, False); |
0 | 1287 |
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1288 /* 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
|
1289 #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
|
1290 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
|
1291 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
|
1292 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
|
1293 } |
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1294 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
|
1295 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
|
1296 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
|
1297 } |
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1298 #endif |
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1299 |
0 | 1300 /* Start shutting down the windows */ |
1301 X11_DestroyImage(this, this->screen); | |
1302 X11_DestroyWindow(this, this->screen); | |
1303 X11_FreeVideoModes(this); | |
1304 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
|
1305 pXFreeColormap(SDL_Display, SDL_XColorMap); |
0 | 1306 } |
1307 if ( SDL_iconcolors ) { | |
1308 unsigned long pixel; | |
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1309 Colormap dcmap = DefaultColormap(SDL_Display, |
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1310 SDL_Screen); |
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1311 for(pixel = 0; pixel < 256; ++pixel) { |
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1312 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
|
1313 pXFreeColors(GFX_Display, |
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1314 dcmap, &pixel, 1, 0); |
0 | 1315 --SDL_iconcolors[pixel]; |
1316 } | |
1317 } | |
1318 free(SDL_iconcolors); | |
1319 SDL_iconcolors = NULL; | |
1320 } | |
1321 /* Restore gamma settings if they've changed */ | |
1322 if ( SDL_GetAppState() & SDL_APPACTIVE ) { | |
1323 X11_SwapVidModeGamma(this); | |
1324 } | |
1325 | |
1326 /* Free that blank cursor */ | |
1327 if ( SDL_BlankCursor != NULL ) { | |
1328 this->FreeWMCursor(this, SDL_BlankCursor); | |
1329 SDL_BlankCursor = NULL; | |
1330 } | |
1331 | |
1332 /* Close the X11 graphics connection */ | |
1333 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
|
1334 pXCloseDisplay(GFX_Display); |
0 | 1335 GFX_Display = NULL; |
1336 } | |
1337 | |
1338 /* 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
|
1339 pXCloseDisplay(SDL_Display); |
0 | 1340 SDL_Display = NULL; |
1341 | |
1342 /* Reset the X11 error handlers */ | |
1343 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
|
1344 pXSetIOErrorHandler(XIO_handler); |
0 | 1345 } |
1346 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
|
1347 pXSetErrorHandler(X_handler); |
0 | 1348 } |
1349 | |
1350 /* Unload GL library after X11 shuts down */ | |
1351 X11_GL_UnloadLibrary(this); | |
1352 } | |
1353 if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) { | |
1354 /* Direct screen access, no memory buffer */ | |
1355 this->screen->pixels = NULL; | |
1356 } | |
1357 } | |
1358 |