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