Mercurial > sdl-ios-xcode
annotate src/video/x11/SDL_x11video.c @ 4278:010efca83dfc SDL-1.2
Fixed building without OpenGL support
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Wed, 07 Oct 2009 06:10:40 +0000 |
| parents | d48035d857d3 |
| children | 4ab46e81d08e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
| 4159 | 3 Copyright (C) 1997-2009 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1299
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
| 0 | 7 License as published by the Free Software Foundation; either |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1299
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
| 0 | 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 | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1299
diff
changeset
|
13 Lesser General Public License for more details. |
| 0 | 14 |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1299
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1299
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1299
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 0 | 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 */ |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
22 #include "SDL_config.h" |
| 0 | 23 |
| 24 /* X11 based SDL video driver implementation. | |
| 25 Note: This implementation does not currently need X11 thread locking, | |
| 26 since the event thread uses a separate X connection and any | |
| 27 additional locking necessary is handled internally. However, | |
| 28 if full locking is neccessary, take a look at XInitThreads(). | |
| 29 */ | |
| 30 | |
| 31 #include <unistd.h> | |
| 32 #include <sys/ioctl.h> | |
| 33 #ifdef MTRR_SUPPORT | |
| 34 #include <asm/mtrr.h> | |
| 35 #include <sys/fcntl.h> | |
| 36 #endif | |
| 37 | |
|
1358
c71e05b4dc2e
More header massaging... works great on Windows. ;-)
Sam Lantinga <slouken@libsdl.org>
parents:
1338
diff
changeset
|
38 #include "SDL_endian.h" |
| 0 | 39 #include "SDL_timer.h" |
| 40 #include "SDL_thread.h" | |
| 41 #include "SDL_video.h" | |
| 42 #include "SDL_mouse.h" | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
43 #include "../SDL_sysvideo.h" |
|
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
44 #include "../SDL_pixels_c.h" |
|
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
45 #include "../../events/SDL_events_c.h" |
| 0 | 46 #include "SDL_x11video.h" |
| 47 #include "SDL_x11wm_c.h" | |
| 48 #include "SDL_x11mouse_c.h" | |
| 49 #include "SDL_x11events_c.h" | |
| 50 #include "SDL_x11modes_c.h" | |
| 51 #include "SDL_x11image_c.h" | |
| 52 #include "SDL_x11yuv_c.h" | |
| 53 #include "SDL_x11gl_c.h" | |
| 54 #include "SDL_x11gamma_c.h" | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
55 #include "../blank_cursor.h" |
| 0 | 56 |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
57 #ifdef X_HAVE_UTF8_STRING |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
58 #include <locale.h> |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
59 #endif |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
60 |
| 0 | 61 /* Initialization/Query functions */ |
| 62 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat); | |
| 63 static SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | |
| 64 static int X11_ToggleFullScreen(_THIS, int on); | |
| 65 static void X11_UpdateMouse(_THIS); | |
| 66 static int X11_SetColors(_THIS, int firstcolor, int ncolors, | |
| 67 SDL_Color *colors); | |
| 68 static int X11_SetGammaRamp(_THIS, Uint16 *ramp); | |
| 69 static void X11_VideoQuit(_THIS); | |
| 70 | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
71 |
| 0 | 72 /* X11 driver bootstrap functions */ |
| 73 | |
| 74 static int X11_Available(void) | |
| 75 { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
76 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
|
77 if ( SDL_X11_LoadSymbols() ) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
78 display = XOpenDisplay(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
|
79 if ( display != NULL ) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
80 XCloseDisplay(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
|
81 } |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
82 SDL_X11_UnloadSymbols(); |
| 0 | 83 } |
| 84 return(display != NULL); | |
| 85 } | |
| 86 | |
| 87 static void X11_DeleteDevice(SDL_VideoDevice *device) | |
| 88 { | |
| 89 if ( device ) { | |
| 90 if ( device->hidden ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
91 SDL_free(device->hidden); |
| 0 | 92 } |
| 93 if ( device->gl_data ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
94 SDL_free(device->gl_data); |
| 0 | 95 } |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
96 SDL_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
|
97 SDL_X11_UnloadSymbols(); |
| 0 | 98 } |
| 99 } | |
| 100 | |
| 101 static SDL_VideoDevice *X11_CreateDevice(int devindex) | |
| 102 { | |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
103 SDL_VideoDevice *device = NULL; |
| 0 | 104 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
105 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
|
106 /* Initialize all variables that we clean on shutdown */ |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
107 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
108 if ( device ) { |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
109 SDL_memset(device, 0, (sizeof *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
|
110 device->hidden = (struct SDL_PrivateVideoData *) |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
111 SDL_malloc((sizeof *device->hidden)); |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
112 device->gl_data = (struct SDL_PrivateGLData *) |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
113 SDL_malloc((sizeof *device->gl_data)); |
|
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 } |
|
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
115 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
|
116 (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
|
117 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
|
118 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
|
119 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
|
120 } |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
121 SDL_memset(device->hidden, 0, (sizeof *device->hidden)); |
|
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
122 SDL_memset(device->gl_data, 0, (sizeof *device->gl_data)); |
| 0 | 123 |
|
4278
010efca83dfc
Fixed building without OpenGL support
Sam Lantinga <slouken@libsdl.org>
parents:
4268
diff
changeset
|
124 #if SDL_VIDEO_OPENGL_GLX |
|
4268
d48035d857d3
Make SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL) work with GLX_SGI_swap_control.
Ryan C. Gordon <icculus@icculus.org>
parents:
4266
diff
changeset
|
125 device->gl_data->sgi_swap_interval = 1; |
|
4278
010efca83dfc
Fixed building without OpenGL support
Sam Lantinga <slouken@libsdl.org>
parents:
4268
diff
changeset
|
126 #endif |
|
4268
d48035d857d3
Make SDL_GL_GetAttribute(SDL_GL_SWAP_CONTROL) work with GLX_SGI_swap_control.
Ryan C. Gordon <icculus@icculus.org>
parents:
4266
diff
changeset
|
127 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
128 /* 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
|
129 device->handles_any_size = 1; |
| 0 | 130 |
|
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
131 /* 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
|
132 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
|
133 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
|
134 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
|
135 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
|
136 device->UpdateMouse = X11_UpdateMouse; |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
137 #if SDL_VIDEO_DRIVER_X11_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
|
138 device->CreateYUVOverlay = X11_CreateYUVOverlay; |
| 0 | 139 #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
|
140 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
|
141 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
|
142 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
|
143 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
|
144 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
|
145 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
|
146 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
|
147 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
|
148 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
|
149 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
|
150 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
|
151 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
|
152 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
|
153 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
|
154 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
|
155 device->GetGammaRamp = NULL; |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
156 #if SDL_VIDEO_OPENGL_GLX |
|
1168
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->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
|
158 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
|
159 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
|
160 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
|
161 device->GL_SwapBuffers = X11_GL_SwapBuffers; |
| 0 | 162 #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
|
163 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
|
164 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
|
165 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
|
166 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
|
167 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
|
168 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
|
169 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
|
170 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
|
171 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
|
172 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
|
173 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
|
174 device->PumpEvents = X11_PumpEvents; |
| 0 | 175 |
|
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->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
|
177 } |
| 0 | 178 |
| 179 return device; | |
| 180 } | |
| 181 | |
| 182 VideoBootStrap X11_bootstrap = { | |
| 183 "x11", "X Window System", | |
| 184 X11_Available, X11_CreateDevice | |
| 185 }; | |
| 186 | |
| 187 /* Normal X11 error handler routine */ | |
| 188 static int (*X_handler)(Display *, XErrorEvent *) = NULL; | |
| 189 static int x_errhandler(Display *d, XErrorEvent *e) | |
| 190 { | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
191 #if SDL_VIDEO_DRIVER_X11_VIDMODE |
| 0 | 192 extern int vm_error; |
| 193 #endif | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
194 #if SDL_VIDEO_DRIVER_X11_DGAMOUSE |
| 0 | 195 extern int dga_error; |
| 196 #endif | |
| 197 | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
198 #if SDL_VIDEO_DRIVER_X11_VIDMODE |
| 0 | 199 /* VidMode errors are non-fatal. :) */ |
| 200 /* Are the errors offset by one from the error base? | |
| 201 e.g. the error base is 143, the code is 148, and the | |
| 202 actual error is XF86VidModeExtensionDisabled (4) ? | |
| 203 */ | |
| 204 if ( (vm_error >= 0) && | |
| 205 (((e->error_code == BadRequest)&&(e->request_code == vm_error)) || | |
| 206 ((e->error_code > vm_error) && | |
| 207 (e->error_code <= (vm_error+XF86VidModeNumberErrors)))) ) { | |
| 1765 | 208 #ifdef X11_DEBUG |
| 0 | 209 { char errmsg[1024]; |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
210 XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg)); |
| 0 | 211 printf("VidMode error: %s\n", errmsg); |
| 212 } | |
| 213 #endif | |
| 214 return(0); | |
| 215 } | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
216 #endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */ |
| 0 | 217 |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
218 #if SDL_VIDEO_DRIVER_X11_DGAMOUSE |
| 0 | 219 /* DGA errors can be non-fatal. :) */ |
| 220 if ( (dga_error >= 0) && | |
| 221 ((e->error_code > dga_error) && | |
| 222 (e->error_code <= (dga_error+XF86DGANumberErrors))) ) { | |
| 1765 | 223 #ifdef X11_DEBUG |
| 0 | 224 { char errmsg[1024]; |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
225 XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg)); |
| 0 | 226 printf("DGA error: %s\n", errmsg); |
| 227 } | |
| 228 #endif | |
| 229 return(0); | |
| 230 } | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
231 #endif /* SDL_VIDEO_DRIVER_X11_DGAMOUSE */ |
| 0 | 232 |
| 233 return(X_handler(d,e)); | |
| 234 } | |
| 235 | |
| 236 /* X11 I/O error handler routine */ | |
| 237 static int (*XIO_handler)(Display *) = NULL; | |
| 238 static int xio_errhandler(Display *d) | |
| 239 { | |
| 240 /* Ack! Lost X11 connection! */ | |
| 241 | |
| 242 /* We will crash if we try to clean up our display */ | |
|
4210
8f501bbc3bf1
Fixed bug #571.. I think. :)
Sam Lantinga <slouken@libsdl.org>
parents:
4159
diff
changeset
|
243 if ( SDL_VideoSurface && current_video->hidden->Ximage ) { |
| 0 | 244 SDL_VideoSurface->pixels = NULL; |
| 245 } | |
| 246 current_video->hidden->X11_Display = NULL; | |
| 247 | |
| 248 /* Continue with the standard X11 error handler */ | |
| 249 return(XIO_handler(d)); | |
| 250 } | |
| 251 | |
|
1609
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
252 static int (*Xext_handler)(Display *, _Xconst char *, _Xconst char *) = NULL; |
|
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
253 static int xext_errhandler(Display *d, _Xconst char *ext, _Xconst char *reason) |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
254 { |
| 1765 | 255 #ifdef X11_DEBUG |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
256 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
|
257 printf(" Extension \"%s\" %s on display \"%s\".\n", |
|
1609
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
258 ext, reason, XDisplayString(d)); |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
259 #endif |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
260 |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
261 if (SDL_strcmp(reason, "missing") == 0) { |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
262 /* |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
263 * 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
|
264 * 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
|
265 * 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
|
266 */ |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
267 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
|
268 } |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
269 |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
270 /* Everything else goes to the default handler... */ |
|
1609
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
271 return Xext_handler(d, ext, reason); |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
272 } |
|
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
273 |
| 1325 | 274 /* Find out what class name we should use */ |
| 275 static char *get_classname(char *classname, int maxlen) | |
| 276 { | |
| 277 char *spot; | |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
278 #if defined(__LINUX__) || defined(__FREEBSD__) |
| 1325 | 279 char procfile[1024]; |
| 280 char linkfile[1024]; | |
| 281 int linksize; | |
| 282 #endif | |
| 283 | |
| 284 /* First allow environment variable override */ | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
285 spot = SDL_getenv("SDL_VIDEO_X11_WMCLASS"); |
| 1325 | 286 if ( spot ) { |
|
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
287 SDL_strlcpy(classname, spot, maxlen); |
| 1325 | 288 return classname; |
| 289 } | |
| 290 | |
| 291 /* Next look at the application's executable name */ | |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
292 #if defined(__LINUX__) || defined(__FREEBSD__) |
|
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
293 #if defined(__LINUX__) |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
294 SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/exe", getpid()); |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
295 #elif defined(__FREEBSD__) |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
296 SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/file", getpid()); |
| 1325 | 297 #else |
| 298 #error Where can we find the executable name? | |
| 299 #endif | |
| 300 linksize = readlink(procfile, linkfile, sizeof(linkfile)-1); | |
| 301 if ( linksize > 0 ) { | |
| 302 linkfile[linksize] = '\0'; | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
303 spot = SDL_strrchr(linkfile, '/'); |
| 1325 | 304 if ( spot ) { |
|
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
305 SDL_strlcpy(classname, spot+1, maxlen); |
| 1325 | 306 } else { |
|
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
307 SDL_strlcpy(classname, linkfile, maxlen); |
| 1325 | 308 } |
| 309 return classname; | |
| 310 } | |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
311 #endif /* __LINUX__ */ |
| 1325 | 312 |
| 313 /* Finally use the default we've used forever */ | |
|
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
314 SDL_strlcpy(classname, "SDL_App", maxlen); |
| 1325 | 315 return classname; |
| 316 } | |
| 317 | |
| 0 | 318 /* Create auxiliary (toplevel) windows with the current visual */ |
| 319 static void create_aux_windows(_THIS) | |
| 320 { | |
| 1765 | 321 int x = 0, y = 0; |
| 1325 | 322 char classname[1024]; |
| 0 | 323 XSetWindowAttributes xattr; |
| 324 XWMHints *hints; | |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
325 unsigned long app_event_mask; |
| 0 | 326 int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen)); |
| 327 | |
| 1558 | 328 /* Look up some useful Atoms */ |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
329 WM_DELETE_WINDOW = XInternAtom(SDL_Display, "WM_DELETE_WINDOW", False); |
| 1558 | 330 |
| 0 | 331 /* Don't create any extra windows if we are being managed */ |
| 332 if ( SDL_windowid ) { | |
| 333 FSwindow = 0; | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
334 WMwindow = SDL_strtol(SDL_windowid, NULL, 0); |
| 0 | 335 return; |
| 336 } | |
| 337 | |
| 338 if(FSwindow) | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
339 XDestroyWindow(SDL_Display, FSwindow); |
| 0 | 340 |
| 1863 | 341 #if SDL_VIDEO_DRIVER_X11_XINERAMA |
| 1765 | 342 if ( use_xinerama ) { |
| 343 x = xinerama_info.x_org; | |
| 344 y = xinerama_info.y_org; | |
| 345 } | |
| 346 #endif | |
| 0 | 347 xattr.override_redirect = True; |
| 348 xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0; | |
| 349 xattr.border_pixel = 0; | |
| 350 xattr.colormap = SDL_XColorMap; | |
| 351 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
352 FSwindow = XCreateWindow(SDL_Display, SDL_Root, |
| 1765 | 353 x, y, 32, 32, 0, |
| 0 | 354 this->hidden->depth, InputOutput, SDL_Visual, |
| 355 CWOverrideRedirect | CWBackPixel | CWBorderPixel | |
| 356 | CWColormap, | |
| 357 &xattr); | |
| 358 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
359 XSelectInput(SDL_Display, FSwindow, StructureNotifyMask); |
| 0 | 360 |
| 361 /* Tell KDE to keep the fullscreen window on top */ | |
| 362 { | |
| 363 XEvent ev; | |
| 364 long mask; | |
| 365 | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
366 SDL_memset(&ev, 0, sizeof(ev)); |
| 0 | 367 ev.xclient.type = ClientMessage; |
| 368 ev.xclient.window = SDL_Root; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
369 ev.xclient.message_type = XInternAtom(SDL_Display, |
| 0 | 370 "KWM_KEEP_ON_TOP", False); |
| 371 ev.xclient.format = 32; | |
| 372 ev.xclient.data.l[0] = FSwindow; | |
| 373 ev.xclient.data.l[1] = CurrentTime; | |
| 374 mask = SubstructureRedirectMask; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
375 XSendEvent(SDL_Display, SDL_Root, False, mask, &ev); |
| 0 | 376 } |
| 377 | |
| 378 hints = NULL; | |
| 379 if(WMwindow) { | |
| 380 /* All window attributes must survive the recreation */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
381 hints = XGetWMHints(SDL_Display, WMwindow); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
382 XDestroyWindow(SDL_Display, WMwindow); |
| 0 | 383 } |
| 384 | |
| 385 /* Create the window for windowed management */ | |
| 386 /* (reusing the xattr structure above) */ | |
| 1765 | 387 WMwindow = XCreateWindow(SDL_Display, SDL_Root, |
| 388 x, y, 32, 32, 0, | |
| 0 | 389 this->hidden->depth, InputOutput, SDL_Visual, |
| 390 CWBackPixel | CWBorderPixel | CWColormap, | |
| 391 &xattr); | |
| 392 | |
| 393 /* Set the input hints so we get keyboard input */ | |
| 394 if(!hints) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
395 hints = XAllocWMHints(); |
| 0 | 396 hints->input = True; |
| 397 hints->flags = InputHint; | |
| 398 } | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
399 XSetWMHints(SDL_Display, WMwindow, hints); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
400 XFree(hints); |
| 1767 | 401 X11_SetCaptionNoLock(this, this->wm_title, this->wm_icon); |
| 0 | 402 |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
403 app_event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
404 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask; |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
405 XSelectInput(SDL_Display, WMwindow, app_event_mask); |
| 0 | 406 |
| 407 /* Set the class hints so we can get an icon (AfterStep) */ | |
| 1325 | 408 get_classname(classname, sizeof(classname)); |
| 0 | 409 { |
| 410 XClassHint *classhints; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
411 classhints = XAllocClassHint(); |
| 0 | 412 if(classhints != NULL) { |
|
449
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
413 classhints->res_name = classname; |
|
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
414 classhints->res_class = classname; |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
415 XSetClassHint(SDL_Display, WMwindow, classhints); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
416 XFree(classhints); |
| 0 | 417 } |
| 418 } | |
| 419 | |
|
3964
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
420 /* Setup the communication with the IM server */ |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
421 /* create_aux_windows may be called several times against the same |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
422 Display. We should reuse the SDL_IM if one has been opened for |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
423 the Display, so we should not simply reset SDL_IM here. */ |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
424 |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
425 #ifdef X_HAVE_UTF8_STRING |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
426 if (SDL_X11_HAVE_UTF8) { |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
427 /* Discard obsolete resources if any. */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
428 if (SDL_IM != NULL && SDL_Display != XDisplayOfIM(SDL_IM)) { |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
429 /* Just a double check. I don't think this |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
430 code is ever executed. */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
431 SDL_SetError("display has changed while an IM is kept"); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
432 if (SDL_IC) { |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
433 XUnsetICFocus(SDL_IC); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
434 XDestroyIC(SDL_IC); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
435 SDL_IC = NULL; |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
436 } |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
437 XCloseIM(SDL_IM); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
438 SDL_IM = NULL; |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
439 } |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
440 |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
441 /* Open an input method. */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
442 if (SDL_IM == NULL) { |
|
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
443 char *old_locale = NULL, *old_modifiers = NULL; |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
444 const char *p; |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
445 size_t n; |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
446 /* I'm not comfortable to do locale setup |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
447 here. However, we need C library locale |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
448 (and xlib modifiers) to be set based on the |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
449 user's preference to use XIM, and many |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
450 existing game programs doesn't take care of |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
451 users' locale preferences, so someone other |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
452 than the game program should do it. |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
453 Moreover, ones say that some game programs |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
454 heavily rely on the C locale behaviour, |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
455 e.g., strcol()'s, and we can't change the C |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
456 library locale. Given the situation, I |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
457 couldn't find better place to do the |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
458 job... */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
459 |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
460 /* Save the current (application program's) |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
461 locale settings. */ |
|
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
462 p = setlocale(LC_ALL, NULL); |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
463 if ( p ) { |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
464 n = SDL_strlen(p)+1; |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
465 old_locale = SDL_stack_alloc(char, n); |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
466 if ( old_locale ) { |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
467 SDL_strlcpy(old_locale, p, n); |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
468 } |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
469 } |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
470 p = XSetLocaleModifiers(NULL); |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
471 if ( p ) { |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
472 n = SDL_strlen(p)+1; |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
473 old_modifiers = SDL_stack_alloc(char, n); |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
474 if ( old_modifiers ) { |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
475 SDL_strlcpy(old_modifiers, p, n); |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
476 } |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
477 } |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
478 |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
479 /* Fetch the user's preferences and open the |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
480 input method with them. */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
481 setlocale(LC_ALL, ""); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
482 XSetLocaleModifiers(""); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
483 SDL_IM = XOpenIM(SDL_Display, NULL, classname, classname); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
484 |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
485 /* Restore the application's locale settings |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
486 so that we don't break the application's |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
487 expected behaviour. */ |
|
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
488 if ( old_locale ) { |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
489 /* We need to restore the C library |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
490 locale first, since the |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
491 interpretation of the X modifier |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
492 may depend on it. */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
493 setlocale(LC_ALL, old_locale); |
|
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
494 SDL_stack_free(old_locale); |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
495 } |
|
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
496 if ( old_modifiers ) { |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
497 XSetLocaleModifiers(old_modifiers); |
|
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
498 SDL_stack_free(old_modifiers); |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
499 } |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
500 } |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
501 |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
502 /* Create a new input context for the new window just created. */ |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
503 if (SDL_IM == NULL) { |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
504 SDL_SetError("no input method could be opened"); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
505 } else { |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
506 if (SDL_IC != NULL) { |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
507 /* Discard the old IC before creating new one. */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
508 XUnsetICFocus(SDL_IC); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
509 XDestroyIC(SDL_IC); |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
510 } |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
511 /* Theoretically we should check the current IM supports |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
512 PreeditNothing+StatusNothing style (i.e., root window method) |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
513 before creating the IC. However, it is the bottom line method, |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
514 and we supports any other options. If the IM didn't support |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
515 root window method, the following call fails, and SDL falls |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
516 back to pre-XIM keyboard handling. */ |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
517 SDL_IC = pXCreateIC(SDL_IM, |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
518 XNClientWindow, WMwindow, |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
519 XNFocusWindow, WMwindow, |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
520 XNInputStyle, XIMPreeditNothing | XIMStatusNothing, |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
521 XNResourceName, classname, |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
522 XNResourceClass, classname, |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
523 NULL); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
524 |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
525 if (SDL_IC == NULL) { |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
526 SDL_SetError("no input context could be created"); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
527 XCloseIM(SDL_IM); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
528 SDL_IM = NULL; |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
529 } else { |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
530 /* We need to receive X events that an IM wants and to pass |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
531 them to the IM through XFilterEvent. The set of events may |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
532 vary depending on the IM implementation and the options |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
533 specified through various routes. Although unlikely, the |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
534 xlib specification allows IM to change the event requirement |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
535 with its own circumstances, it is safe to call SelectInput |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
536 whenever we re-create an IC. */ |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
537 unsigned long mask = 0; |
|
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
538 char *ret = pXGetICValues(SDL_IC, XNFilterEvents, &mask, NULL); |
|
4014
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
539 if (ret != NULL) { |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
540 XUnsetICFocus(SDL_IC); |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
541 XDestroyIC(SDL_IC); |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
542 SDL_IC = NULL; |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
543 SDL_SetError("no input context could be created"); |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
544 XCloseIM(SDL_IM); |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
545 SDL_IM = NULL; |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
546 } else { |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
547 XSelectInput(SDL_Display, WMwindow, app_event_mask | mask); |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
548 XSetICFocus(SDL_IC); |
|
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
549 } |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
550 } |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
551 } |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
552 } |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
553 #endif |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
554 |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
555 /* Allow the window to be deleted by the window manager */ |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
556 XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1); |
| 0 | 557 } |
| 558 | |
| 559 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat) | |
| 560 { | |
|
4139
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
561 const char *env; |
| 0 | 562 char *display; |
| 563 int i; | |
| 564 | |
| 565 /* Open the X11 display */ | |
| 566 display = NULL; /* Get it from DISPLAY environment variable */ | |
| 567 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
568 if ( (SDL_strncmp(XDisplayName(display), ":", 1) == 0) || |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
569 (SDL_strncmp(XDisplayName(display), "unix:", 5) == 0) ) { |
| 0 | 570 local_X11 = 1; |
| 571 } else { | |
| 572 local_X11 = 0; | |
| 573 } | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
574 SDL_Display = XOpenDisplay(display); |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
575 #if defined(__osf__) && defined(SDL_VIDEO_DRIVER_X11_DYNAMIC) |
|
1299
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
576 /* On Tru64 if linking without -lX11, it fails and you get following message. |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
577 * Xlib: connection to ":0.0" refused by server |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
578 * Xlib: XDM authorization key matches an existing client! |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
579 * |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
580 * It succeeds if retrying 1 second later |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
581 * or if running xhost +localhost on shell. |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
582 * |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
583 */ |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
584 if ( SDL_Display == NULL ) { |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
585 SDL_Delay(1000); |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
586 SDL_Display = XOpenDisplay(display); |
|
1299
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
587 } |
|
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
588 #endif |
| 0 | 589 if ( SDL_Display == NULL ) { |
| 590 SDL_SetError("Couldn't open X11 display"); | |
| 591 return(-1); | |
| 592 } | |
| 593 #ifdef X11_DEBUG | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
594 XSynchronize(SDL_Display, True); |
| 0 | 595 #endif |
| 596 | |
| 597 /* Create an alternate X display for graphics updates -- allows us | |
| 598 to do graphics updates in a separate thread from event handling. | |
| 599 Thread-safe X11 doesn't seem to exist. | |
| 600 */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
601 GFX_Display = XOpenDisplay(display); |
| 0 | 602 if ( GFX_Display == NULL ) { |
|
3964
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
603 XCloseDisplay(SDL_Display); |
|
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
604 SDL_Display = NULL; |
| 0 | 605 SDL_SetError("Couldn't open X11 display"); |
| 606 return(-1); | |
| 607 } | |
| 608 | |
| 609 /* Set the normal X error handler */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
610 X_handler = XSetErrorHandler(x_errhandler); |
| 0 | 611 |
| 612 /* Set the error handler if we lose the X display */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
613 XIO_handler = XSetIOErrorHandler(xio_errhandler); |
| 0 | 614 |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
615 /* Set the X extension error handler */ |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
616 Xext_handler = XSetExtensionErrorHandler(xext_errhandler); |
|
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
617 |
| 0 | 618 /* use default screen (from $DISPLAY) */ |
| 619 SDL_Screen = DefaultScreen(SDL_Display); | |
| 620 | |
| 621 #ifndef NO_SHARED_MEMORY | |
| 622 /* 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
|
623 use_mitshm = 0; |
| 0 | 624 if ( local_X11 ) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
625 use_mitshm = XShmQueryExtension(SDL_Display); |
| 0 | 626 } |
| 627 #endif /* NO_SHARED_MEMORY */ | |
| 628 | |
| 629 /* Get the available video modes */ | |
|
3964
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
630 if(X11_GetVideoModes(this) < 0) { |
|
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
631 XCloseDisplay(GFX_Display); |
|
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
632 GFX_Display = NULL; |
|
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
633 XCloseDisplay(SDL_Display); |
|
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
634 SDL_Display = NULL; |
| 0 | 635 return -1; |
|
3964
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
636 } |
| 0 | 637 |
|
1545
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
638 /* Determine the current screen size */ |
|
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
639 this->info.current_w = DisplayWidth(SDL_Display, SDL_Screen); |
|
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
640 this->info.current_h = DisplayHeight(SDL_Display, SDL_Screen); |
|
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
641 |
| 0 | 642 /* Determine the default screen depth: |
| 643 Use the default visual (or at least one with the same depth) */ | |
| 644 SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen); | |
| 645 for(i = 0; i < this->hidden->nvisuals; i++) | |
| 646 if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display, | |
| 647 SDL_Screen)) | |
| 648 break; | |
| 649 if(i == this->hidden->nvisuals) { | |
| 650 /* default visual was useless, take the deepest one instead */ | |
| 651 i = 0; | |
| 652 } | |
| 653 SDL_Visual = this->hidden->visuals[i].visual; | |
| 654 if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) { | |
| 655 SDL_XColorMap = SDL_DisplayColormap; | |
| 656 } else { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
657 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
| 0 | 658 SDL_Visual, AllocNone); |
| 659 } | |
| 660 this->hidden->depth = this->hidden->visuals[i].depth; | |
| 661 vformat->BitsPerPixel = this->hidden->visuals[i].bpp; | |
| 662 if ( vformat->BitsPerPixel > 8 ) { | |
| 663 vformat->Rmask = SDL_Visual->red_mask; | |
| 664 vformat->Gmask = SDL_Visual->green_mask; | |
| 665 vformat->Bmask = SDL_Visual->blue_mask; | |
| 666 } | |
| 1641 | 667 if ( this->hidden->depth == 32 ) { |
| 668 vformat->Amask = (0xFFFFFFFF & ~(vformat->Rmask|vformat->Gmask|vformat->Bmask)); | |
| 669 } | |
| 0 | 670 X11_SaveVidModeGamma(this); |
| 671 | |
| 4124 | 672 /* Allow environment override of screensaver disable. */ |
| 673 env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER"); | |
|
4139
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
674 if ( env ) { |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
675 allow_screensaver = SDL_atoi(env); |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
676 } else { |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
677 #ifdef SDL_VIDEO_DISABLE_SCREENSAVER |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
678 allow_screensaver = 0; |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
679 #else |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
680 allow_screensaver = 1; |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
681 #endif |
|
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
682 } |
| 1783 | 683 |
| 0 | 684 /* See if we have been passed a window to use */ |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
685 SDL_windowid = SDL_getenv("SDL_WINDOWID"); |
| 0 | 686 |
| 687 /* Create the fullscreen and managed windows */ | |
| 688 create_aux_windows(this); | |
| 689 | |
| 690 /* Create the blank cursor */ | |
| 691 SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask, | |
| 692 BLANK_CWIDTH, BLANK_CHEIGHT, | |
| 693 BLANK_CHOTX, BLANK_CHOTY); | |
| 694 | |
| 695 /* Fill in some window manager capabilities */ | |
| 696 this->info.wm_available = 1; | |
| 697 | |
| 698 /* We're done! */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
699 XFlush(SDL_Display); |
| 0 | 700 return(0); |
| 701 } | |
| 702 | |
| 703 static void X11_DestroyWindow(_THIS, SDL_Surface *screen) | |
| 704 { | |
| 705 /* Clean up OpenGL */ | |
| 706 if ( screen ) { | |
| 707 screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT); | |
| 708 } | |
| 709 X11_GL_Shutdown(this); | |
| 710 | |
| 711 if ( ! SDL_windowid ) { | |
| 712 /* Hide the managed window */ | |
| 713 if ( WMwindow ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
714 XUnmapWindow(SDL_Display, WMwindow); |
| 0 | 715 } |
| 716 if ( screen && (screen->flags & SDL_FULLSCREEN) ) { | |
| 717 screen->flags &= ~SDL_FULLSCREEN; | |
| 718 X11_LeaveFullScreen(this); | |
| 719 } | |
| 720 | |
| 721 /* Destroy the output window */ | |
| 722 if ( SDL_Window ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
723 XDestroyWindow(SDL_Display, SDL_Window); |
| 0 | 724 } |
| 725 | |
| 726 /* Free the colormap entries */ | |
| 727 if ( SDL_XPixels ) { | |
| 728 int numcolors; | |
| 729 unsigned long pixel; | |
| 730 numcolors = SDL_Visual->map_entries; | |
| 731 for ( pixel=0; pixel<numcolors; ++pixel ) { | |
| 732 while ( SDL_XPixels[pixel] > 0 ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
733 XFreeColors(GFX_Display, |
| 0 | 734 SDL_DisplayColormap,&pixel,1,0); |
| 735 --SDL_XPixels[pixel]; | |
| 736 } | |
| 737 } | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
738 SDL_free(SDL_XPixels); |
| 0 | 739 SDL_XPixels = NULL; |
| 740 } | |
| 741 | |
| 742 /* Free the graphics context */ | |
| 743 if ( SDL_GC ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
744 XFreeGC(SDL_Display, SDL_GC); |
| 0 | 745 SDL_GC = 0; |
| 746 } | |
| 747 } | |
| 748 } | |
| 749 | |
|
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
750 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
|
751 { |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
752 const char *window = SDL_getenv("SDL_VIDEO_WINDOW_POS"); |
|
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
753 const char *center = SDL_getenv("SDL_VIDEO_CENTERED"); |
|
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
754 if ( window ) { |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
755 if ( SDL_sscanf(window, "%d,%d", x, y) == 2 ) { |
|
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
756 return SDL_TRUE; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
757 } |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
758 if ( SDL_strcmp(window, "center") == 0 ) { |
|
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
759 center = window; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
760 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
761 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
762 if ( center ) { |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
763 *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
|
764 *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
|
765 return SDL_TRUE; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
766 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
767 return SDL_FALSE; |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
768 } |
|
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
769 |
| 0 | 770 static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags) |
| 771 { | |
| 772 XSizeHints *hints; | |
| 773 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
774 hints = XAllocSizeHints(); |
| 0 | 775 if ( hints ) { |
| 4218 | 776 if (!(flags & SDL_RESIZABLE)) { |
| 0 | 777 hints->min_width = hints->max_width = w; |
| 778 hints->min_height = hints->max_height = h; | |
| 4218 | 779 hints->flags = PMaxSize | PMinSize; |
| 0 | 780 } |
| 781 if ( flags & SDL_FULLSCREEN ) { | |
| 782 hints->x = 0; | |
| 783 hints->y = 0; | |
| 784 hints->flags |= USPosition; | |
| 785 } else | |
| 786 /* Center it, if desired */ | |
|
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
787 if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) { |
| 0 | 788 hints->flags |= USPosition; |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
789 XMoveWindow(SDL_Display, WMwindow, hints->x, hints->y); |
| 0 | 790 |
| 791 /* Flush the resize event so we don't catch it later */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
792 XSync(SDL_Display, True); |
| 0 | 793 } |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
794 XSetWMNormalHints(SDL_Display, WMwindow, hints); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
795 XFree(hints); |
| 0 | 796 } |
| 797 | |
| 798 /* Respect the window caption style */ | |
| 799 if ( flags & SDL_NOFRAME ) { | |
| 800 SDL_bool set; | |
| 801 Atom WM_HINTS; | |
| 802 | |
| 803 /* We haven't modified the window manager hints yet */ | |
| 804 set = SDL_FALSE; | |
| 805 | |
| 806 /* First try to set MWM hints */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
807 WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
| 0 | 808 if ( WM_HINTS != None ) { |
| 809 /* Hints used by Motif compliant window managers */ | |
| 810 struct { | |
| 811 unsigned long flags; | |
| 812 unsigned long functions; | |
| 813 unsigned long decorations; | |
| 814 long input_mode; | |
| 815 unsigned long status; | |
| 816 } MWMHints = { (1L << 1), 0, 0, 0, 0 }; | |
| 817 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
818 XChangeProperty(SDL_Display, WMwindow, |
| 0 | 819 WM_HINTS, WM_HINTS, 32, |
| 820 PropModeReplace, | |
| 821 (unsigned char *)&MWMHints, | |
| 822 sizeof(MWMHints)/sizeof(long)); | |
| 823 set = SDL_TRUE; | |
| 824 } | |
| 825 /* Now try to set KWM hints */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
826 WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
| 0 | 827 if ( WM_HINTS != None ) { |
| 828 long KWMHints = 0; | |
| 829 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
830 XChangeProperty(SDL_Display, WMwindow, |
| 0 | 831 WM_HINTS, WM_HINTS, 32, |
| 832 PropModeReplace, | |
| 833 (unsigned char *)&KWMHints, | |
| 834 sizeof(KWMHints)/sizeof(long)); | |
| 835 set = SDL_TRUE; | |
| 836 } | |
| 837 /* Now try to set GNOME hints */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
838 WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True); |
| 0 | 839 if ( WM_HINTS != None ) { |
| 840 long GNOMEHints = 0; | |
| 841 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
842 XChangeProperty(SDL_Display, WMwindow, |
| 0 | 843 WM_HINTS, WM_HINTS, 32, |
| 844 PropModeReplace, | |
| 845 (unsigned char *)&GNOMEHints, | |
| 846 sizeof(GNOMEHints)/sizeof(long)); | |
| 847 set = SDL_TRUE; | |
| 848 } | |
| 849 /* Finally set the transient hints if necessary */ | |
| 850 if ( ! set ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
851 XSetTransientForHint(SDL_Display, WMwindow, SDL_Root); |
| 0 | 852 } |
| 853 } else { | |
| 854 SDL_bool set; | |
| 855 Atom WM_HINTS; | |
| 856 | |
| 857 /* We haven't modified the window manager hints yet */ | |
| 858 set = SDL_FALSE; | |
| 859 | |
| 860 /* First try to unset MWM hints */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
861 WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
| 0 | 862 if ( WM_HINTS != None ) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
863 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
| 0 | 864 set = SDL_TRUE; |
| 865 } | |
| 866 /* Now try to unset KWM hints */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
867 WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
| 0 | 868 if ( WM_HINTS != None ) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
869 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
| 0 | 870 set = SDL_TRUE; |
| 871 } | |
| 872 /* Now try to unset GNOME hints */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
873 WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True); |
| 0 | 874 if ( WM_HINTS != None ) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
875 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
| 0 | 876 set = SDL_TRUE; |
| 877 } | |
| 878 /* Finally unset the transient hints if necessary */ | |
| 879 if ( ! set ) { | |
| 880 /* NOTE: Does this work? */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
881 XSetTransientForHint(SDL_Display, WMwindow, None); |
| 0 | 882 } |
| 883 } | |
| 884 } | |
| 885 | |
| 886 static int X11_CreateWindow(_THIS, SDL_Surface *screen, | |
| 887 int w, int h, int bpp, Uint32 flags) | |
| 888 { | |
| 889 int i, depth; | |
| 890 Visual *vis; | |
| 891 int vis_change; | |
| 1641 | 892 Uint32 Amask; |
| 0 | 893 |
| 894 /* If a window is already present, destroy it and start fresh */ | |
| 895 if ( SDL_Window ) { | |
| 896 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
|
897 switch_waiting = 0; /* Prevent jump back to now-meaningless state. */ |
| 0 | 898 } |
| 899 | |
| 900 /* See if we have been given a window id */ | |
| 901 if ( SDL_windowid ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
902 SDL_Window = SDL_strtol(SDL_windowid, NULL, 0); |
| 0 | 903 } else { |
| 904 SDL_Window = 0; | |
| 905 } | |
| 906 | |
| 907 /* find out which visual we are going to use */ | |
| 908 if ( flags & SDL_OPENGL ) { | |
| 909 XVisualInfo *vi; | |
| 910 | |
| 911 vi = X11_GL_GetVisual(this); | |
| 912 if( !vi ) { | |
| 913 return -1; | |
| 914 } | |
| 915 vis = vi->visual; | |
| 916 depth = vi->depth; | |
| 917 } else if ( SDL_windowid ) { | |
| 918 XWindowAttributes a; | |
| 919 | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
920 XGetWindowAttributes(SDL_Display, SDL_Window, &a); |
| 0 | 921 vis = a.visual; |
| 922 depth = a.depth; | |
| 923 } else { | |
| 924 for ( i = 0; i < this->hidden->nvisuals; i++ ) { | |
| 925 if ( this->hidden->visuals[i].bpp == bpp ) | |
| 926 break; | |
| 927 } | |
| 928 if ( i == this->hidden->nvisuals ) { | |
| 929 SDL_SetError("No matching visual for requested depth"); | |
| 930 return -1; /* should never happen */ | |
| 931 } | |
| 932 vis = this->hidden->visuals[i].visual; | |
| 933 depth = this->hidden->visuals[i].depth; | |
| 934 } | |
| 935 #ifdef X11_DEBUG | |
| 936 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); | |
| 937 #endif | |
| 938 vis_change = (vis != SDL_Visual); | |
| 939 SDL_Visual = vis; | |
| 940 this->hidden->depth = depth; | |
| 941 | |
| 942 /* Allocate the new pixel format for this video mode */ | |
| 1641 | 943 if ( this->hidden->depth == 32 ) { |
| 944 Amask = (0xFFFFFFFF & ~(vis->red_mask|vis->green_mask|vis->blue_mask)); | |
| 945 } else { | |
| 946 Amask = 0; | |
| 947 } | |
| 0 | 948 if ( ! SDL_ReallocFormat(screen, bpp, |
| 1641 | 949 vis->red_mask, vis->green_mask, vis->blue_mask, Amask) ) { |
| 0 | 950 return -1; |
| 1641 | 951 } |
| 0 | 952 |
| 953 /* Create the appropriate colormap */ | |
| 954 if ( SDL_XColorMap != SDL_DisplayColormap ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
955 XFreeColormap(SDL_Display, SDL_XColorMap); |
| 0 | 956 } |
| 957 if ( SDL_Visual->class == PseudoColor ) { | |
| 958 int ncolors; | |
| 959 | |
| 960 /* Allocate the pixel flags */ | |
| 961 ncolors = SDL_Visual->map_entries; | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
962 SDL_XPixels = SDL_malloc(ncolors * sizeof(int)); |
| 0 | 963 if(SDL_XPixels == NULL) { |
| 964 SDL_OutOfMemory(); | |
| 965 return -1; | |
| 966 } | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
967 SDL_memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels)); |
| 0 | 968 |
| 969 /* always allocate a private colormap on non-default visuals */ | |
| 970 if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) { | |
| 971 flags |= SDL_HWPALETTE; | |
| 972 } | |
| 973 if ( flags & SDL_HWPALETTE ) { | |
| 974 screen->flags |= SDL_HWPALETTE; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
975 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
| 0 | 976 SDL_Visual, AllocAll); |
| 977 } else { | |
| 978 SDL_XColorMap = SDL_DisplayColormap; | |
| 979 } | |
| 980 } else if ( SDL_Visual->class == DirectColor ) { | |
| 981 | |
| 982 /* Create a colormap which we can manipulate for gamma */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
983 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
| 0 | 984 SDL_Visual, AllocAll); |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
985 XSync(SDL_Display, False); |
| 0 | 986 |
| 987 /* Initialize the colormap to the identity mapping */ | |
| 988 SDL_GetGammaRamp(0, 0, 0); | |
| 989 this->screen = screen; | |
| 990 X11_SetGammaRamp(this, this->gamma); | |
| 991 this->screen = NULL; | |
| 992 } else { | |
| 993 /* Create a read-only colormap for our window */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
994 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
| 0 | 995 SDL_Visual, AllocNone); |
| 996 } | |
| 997 | |
| 998 /* Recreate the auxiliary windows, if needed (required for GL) */ | |
| 999 if ( vis_change ) | |
| 1000 create_aux_windows(this); | |
| 1001 | |
| 1002 if(screen->flags & SDL_HWPALETTE) { | |
| 1003 /* Since the full-screen window might have got a nonzero background | |
| 1004 colour (0 is white on some displays), we should reset the | |
| 1005 background to 0 here since that is what the user expects | |
| 1006 with a private colormap */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1007 XSetWindowBackground(SDL_Display, FSwindow, 0); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1008 XClearWindow(SDL_Display, FSwindow); |
| 0 | 1009 } |
| 1010 | |
| 1011 /* resize the (possibly new) window manager window */ | |
| 1012 if( !SDL_windowid ) { | |
| 1013 X11_SetSizeHints(this, w, h, flags); | |
|
1545
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
1014 window_w = w; |
|
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
1015 window_h = h; |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1016 XResizeWindow(SDL_Display, WMwindow, w, h); |
| 0 | 1017 } |
| 1018 | |
| 1019 /* Create (or use) the X11 display window */ | |
| 1020 if ( !SDL_windowid ) { | |
| 1021 if ( flags & SDL_OPENGL ) { | |
| 1022 if ( X11_GL_CreateWindow(this, w, h) < 0 ) { | |
| 1023 return(-1); | |
| 1024 } | |
| 1025 } else { | |
| 1026 XSetWindowAttributes swa; | |
| 1027 | |
| 1028 swa.background_pixel = 0; | |
| 1029 swa.border_pixel = 0; | |
| 1030 swa.colormap = SDL_XColorMap; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1031 SDL_Window = XCreateWindow(SDL_Display, WMwindow, |
| 0 | 1032 0, 0, w, h, 0, depth, |
| 1033 InputOutput, SDL_Visual, | |
| 1034 CWBackPixel | CWBorderPixel | |
| 1035 | CWColormap, &swa); | |
| 1036 } | |
| 1037 /* Only manage our input if we own the window */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1038 XSelectInput(SDL_Display, SDL_Window, |
| 0 | 1039 ( EnterWindowMask | LeaveWindowMask |
| 1040 | ButtonPressMask | ButtonReleaseMask | |
| 1041 | PointerMotionMask | ExposureMask )); | |
| 1042 } | |
| 1043 /* Create the graphics context here, once we have a window */ | |
| 1044 if ( flags & SDL_OPENGL ) { | |
| 1045 if ( X11_GL_CreateContext(this) < 0 ) { | |
| 1046 return(-1); | |
| 1047 } else { | |
| 1048 screen->flags |= SDL_OPENGL; | |
| 1049 } | |
| 1050 } else { | |
| 1051 XGCValues gcv; | |
| 1052 | |
| 1053 gcv.graphics_exposures = False; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1054 SDL_GC = XCreateGC(SDL_Display, SDL_Window, |
| 0 | 1055 GCGraphicsExposures, &gcv); |
| 1056 if ( ! SDL_GC ) { | |
| 1057 SDL_SetError("Couldn't create graphics context"); | |
| 1058 return(-1); | |
| 1059 } | |
| 1060 } | |
| 1061 | |
| 1062 /* Set our colormaps when not setting a GL mode */ | |
| 1063 if ( ! (flags & SDL_OPENGL) ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1064 XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); |
| 0 | 1065 if( !SDL_windowid ) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1066 XSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1067 XSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap); |
| 0 | 1068 } |
| 1069 } | |
| 1070 | |
| 1071 #if 0 /* This is an experiment - are the graphics faster now? - nope. */ | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
1072 if ( SDL_getenv("SDL_VIDEO_X11_BACKINGSTORE") ) |
| 0 | 1073 #endif |
| 1074 /* Cache the window in the server, when possible */ | |
| 1075 { | |
| 1076 Screen *xscreen; | |
| 1077 XSetWindowAttributes a; | |
| 1078 | |
| 1079 xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen); | |
| 1080 a.backing_store = DoesBackingStore(xscreen); | |
| 1081 if ( a.backing_store != NotUseful ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1082 XChangeWindowAttributes(SDL_Display, SDL_Window, |
| 0 | 1083 CWBackingStore, &a); |
| 1084 } | |
| 1085 } | |
| 1086 | |
| 1087 /* Map them both and go fullscreen, if requested */ | |
| 1088 if ( ! SDL_windowid ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1089 XMapWindow(SDL_Display, SDL_Window); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1090 XMapWindow(SDL_Display, WMwindow); |
| 160 | 1091 X11_WaitMapped(this, WMwindow); |
| 0 | 1092 if ( flags & SDL_FULLSCREEN ) { |
| 1093 screen->flags |= SDL_FULLSCREEN; | |
| 1094 X11_EnterFullScreen(this); | |
| 1095 } else { | |
| 1096 screen->flags &= ~SDL_FULLSCREEN; | |
| 1097 } | |
| 1098 } | |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1099 |
| 0 | 1100 return(0); |
| 1101 } | |
| 1102 | |
| 1103 static int X11_ResizeWindow(_THIS, | |
| 1104 SDL_Surface *screen, int w, int h, Uint32 flags) | |
| 1105 { | |
| 1106 if ( ! SDL_windowid ) { | |
| 1107 /* Resize the window manager window */ | |
| 1108 X11_SetSizeHints(this, w, h, flags); | |
|
1545
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
1109 window_w = w; |
|
8d9bb0cf2c2a
Added current_w and current_h to the SDL_VideoInfo structure, which is set to the desktop resolution during video intialization, and then set to the current resolution when a video mode is set.
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
1110 window_h = h; |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1111 XResizeWindow(SDL_Display, WMwindow, w, h); |
| 0 | 1112 |
| 1113 /* Resize the fullscreen and display windows */ | |
| 1114 if ( flags & SDL_FULLSCREEN ) { | |
| 1115 if ( screen->flags & SDL_FULLSCREEN ) { | |
| 1116 X11_ResizeFullScreen(this); | |
| 1117 } else { | |
| 1118 screen->flags |= SDL_FULLSCREEN; | |
| 1119 X11_EnterFullScreen(this); | |
| 1120 } | |
| 1121 } else { | |
| 1122 if ( screen->flags & SDL_FULLSCREEN ) { | |
| 1123 screen->flags &= ~SDL_FULLSCREEN; | |
| 1124 X11_LeaveFullScreen(this); | |
| 1125 } | |
| 1126 } | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1127 XResizeWindow(SDL_Display, SDL_Window, w, h); |
| 0 | 1128 } |
| 1129 return(0); | |
| 1130 } | |
| 1131 | |
| 1132 SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, | |
| 1133 int width, int height, int bpp, Uint32 flags) | |
| 1134 { | |
| 1135 Uint32 saved_flags; | |
| 1136 | |
| 1137 /* Lock the event thread, in multi-threading environments */ | |
| 1138 SDL_Lock_EventThread(); | |
| 1139 | |
| 1140 /* Check the combination of flags we were passed */ | |
| 1141 if ( flags & SDL_FULLSCREEN ) { | |
| 1142 /* Clear fullscreen flag if not supported */ | |
| 1143 if ( SDL_windowid ) { | |
| 1144 flags &= ~SDL_FULLSCREEN; | |
| 1145 } | |
| 1146 } | |
| 1147 | |
| 1148 /* Flush any delayed updates */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1149 XSync(GFX_Display, False); |
| 0 | 1150 |
| 1151 /* Set up the X11 window */ | |
| 1152 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
|
1153 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
|
1154 && (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
|
1155 && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) { |
| 0 | 1156 if (X11_ResizeWindow(this, current, width, height, flags) < 0) { |
| 1157 current = NULL; | |
| 1158 goto done; | |
| 1159 } | |
| 1160 } else { | |
| 1161 if (X11_CreateWindow(this,current,width,height,bpp,flags) < 0) { | |
| 1162 current = NULL; | |
| 1163 goto done; | |
| 1164 } | |
| 1165 } | |
| 1166 | |
| 4008 | 1167 /* Update the internal keyboard state */ |
| 1168 X11_SetKeyboardState(SDL_Display, NULL); | |
| 1169 | |
| 1170 /* When the window is first mapped, ignore non-modifier keys */ | |
| 1171 if ( !current->w && !current->h ) { | |
| 1172 Uint8 *keys = SDL_GetKeyState(NULL); | |
| 1173 int i; | |
| 1174 for ( i = 0; i < SDLK_LAST; ++i ) { | |
| 1175 switch (i) { | |
| 1176 case SDLK_NUMLOCK: | |
| 1177 case SDLK_CAPSLOCK: | |
| 1178 case SDLK_LCTRL: | |
| 1179 case SDLK_RCTRL: | |
| 1180 case SDLK_LSHIFT: | |
| 1181 case SDLK_RSHIFT: | |
| 1182 case SDLK_LALT: | |
| 1183 case SDLK_RALT: | |
| 1184 case SDLK_LMETA: | |
| 1185 case SDLK_RMETA: | |
| 1186 case SDLK_MODE: | |
| 1187 break; | |
| 1188 default: | |
| 1189 keys[i] = SDL_RELEASED; | |
| 1190 break; | |
| 1191 } | |
| 1192 } | |
| 1193 } | |
| 1194 | |
| 0 | 1195 /* Set up the new mode framebuffer */ |
| 1196 if ( ((current->w != width) || (current->h != height)) || | |
| 1197 ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) { | |
| 1198 current->w = width; | |
| 1199 current->h = height; | |
| 1200 current->pitch = SDL_CalculatePitch(current); | |
| 4253 | 1201 if (X11_ResizeImage(this, current, flags) < 0) { |
| 1202 current = NULL; | |
| 1203 goto done; | |
| 1204 } | |
| 0 | 1205 } |
|
4016
3f93ccc2c01e
Clear the NOFRAME and RESIZABLE flags in the X11 target before setting their
Ryan C. Gordon <icculus@icculus.org>
parents:
4014
diff
changeset
|
1206 |
|
3f93ccc2c01e
Clear the NOFRAME and RESIZABLE flags in the X11 target before setting their
Ryan C. Gordon <icculus@icculus.org>
parents:
4014
diff
changeset
|
1207 /* Clear these flags and set them only if they are in the new set. */ |
|
3f93ccc2c01e
Clear the NOFRAME and RESIZABLE flags in the X11 target before setting their
Ryan C. Gordon <icculus@icculus.org>
parents:
4014
diff
changeset
|
1208 current->flags &= ~(SDL_RESIZABLE|SDL_NOFRAME); |
| 0 | 1209 current->flags |= (flags&(SDL_RESIZABLE|SDL_NOFRAME)); |
| 1210 | |
| 1211 done: | |
| 1212 /* Release the event thread */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1213 XSync(SDL_Display, False); |
| 0 | 1214 SDL_Unlock_EventThread(); |
| 1215 | |
| 1216 /* We're done! */ | |
| 1217 return(current); | |
| 1218 } | |
| 1219 | |
| 1220 static int X11_ToggleFullScreen(_THIS, int on) | |
| 1221 { | |
| 1222 Uint32 event_thread; | |
| 1223 | |
| 1224 /* Don't switch if we don't own the window */ | |
| 1225 if ( SDL_windowid ) { | |
| 1226 return(0); | |
| 1227 } | |
| 1228 | |
| 1229 /* Don't lock if we are the event thread */ | |
| 1230 event_thread = SDL_EventThreadID(); | |
| 1231 if ( event_thread && (SDL_ThreadID() == event_thread) ) { | |
| 1232 event_thread = 0; | |
| 1233 } | |
| 1234 if ( event_thread ) { | |
| 1235 SDL_Lock_EventThread(); | |
| 1236 } | |
| 1237 if ( on ) { | |
| 1238 this->screen->flags |= SDL_FULLSCREEN; | |
| 1239 X11_EnterFullScreen(this); | |
| 1240 } else { | |
| 1241 this->screen->flags &= ~SDL_FULLSCREEN; | |
| 1242 X11_LeaveFullScreen(this); | |
| 1243 } | |
| 1244 X11_RefreshDisplay(this); | |
| 1245 if ( event_thread ) { | |
| 1246 SDL_Unlock_EventThread(); | |
| 1247 } | |
| 1248 SDL_ResetKeyboard(); | |
| 1249 return(1); | |
| 1250 } | |
| 1251 | |
| 1252 /* Update the current mouse state and position */ | |
| 1253 static void X11_UpdateMouse(_THIS) | |
| 1254 { | |
| 1255 Window u1; int u2; | |
| 1256 Window current_win; | |
| 1257 int x, y; | |
| 1258 unsigned int mask; | |
| 1259 | |
| 1260 /* Lock the event thread, in multi-threading environments */ | |
| 1261 SDL_Lock_EventThread(); | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1262 if ( XQueryPointer(SDL_Display, SDL_Window, &u1, ¤t_win, |
| 0 | 1263 &u2, &u2, &x, &y, &mask) ) { |
| 1264 if ( (x >= 0) && (x < SDL_VideoSurface->w) && | |
| 1265 (y >= 0) && (y < SDL_VideoSurface->h) ) { | |
| 1266 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); | |
| 1267 SDL_PrivateMouseMotion(0, 0, x, y); | |
| 1268 } else { | |
| 1269 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); | |
| 1270 } | |
| 1271 } | |
| 1272 SDL_Unlock_EventThread(); | |
| 1273 } | |
| 1274 | |
| 1275 /* simple colour distance metric. Supposed to be better than a plain | |
| 1276 Euclidian distance anyway. */ | |
| 1277 #define COLOUR_FACTOR 3 | |
| 1278 #define LIGHT_FACTOR 1 | |
| 1279 #define COLOUR_DIST(r1, g1, b1, r2, g2, b2) \ | |
| 1280 (COLOUR_FACTOR * (abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2)) \ | |
| 1281 + LIGHT_FACTOR * abs(r1 + g1 + b1 - (r2 + g2 + b2))) | |
| 1282 | |
| 1283 static void allocate_nearest(_THIS, SDL_Color *colors, | |
| 1284 SDL_Color *want, int nwant) | |
| 1285 { | |
| 1286 /* | |
| 1287 * There is no way to know which ones to choose from, so we retrieve | |
| 1288 * the entire colormap and try the nearest possible, until we find one | |
| 1289 * that is shared. | |
| 1290 */ | |
| 1291 XColor all[256]; | |
| 1292 int i; | |
| 1293 for(i = 0; i < 256; i++) | |
| 1294 all[i].pixel = i; | |
| 1295 /* | |
| 1296 * XQueryColors sets the flags in the XColor struct, so we use | |
| 1297 * that to keep track of which colours are available | |
| 1298 */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1299 XQueryColors(GFX_Display, SDL_XColorMap, all, 256); |
| 0 | 1300 |
| 1301 for(i = 0; i < nwant; i++) { | |
| 1302 XColor *c; | |
| 1303 int j; | |
| 1304 int best = 0; | |
| 1305 int mindist = 0x7fffffff; | |
| 1306 int ri = want[i].r; | |
| 1307 int gi = want[i].g; | |
| 1308 int bi = want[i].b; | |
| 1309 for(j = 0; j < 256; j++) { | |
| 1310 int rj, gj, bj, d2; | |
| 1311 if(!all[j].flags) | |
| 1312 continue; /* unavailable colour cell */ | |
| 1313 rj = all[j].red >> 8; | |
| 1314 gj = all[j].green >> 8; | |
| 1315 bj = all[j].blue >> 8; | |
| 1316 d2 = COLOUR_DIST(ri, gi, bi, rj, gj, bj); | |
| 1317 if(d2 < mindist) { | |
| 1318 mindist = d2; | |
| 1319 best = j; | |
| 1320 } | |
| 1321 } | |
| 1322 if(SDL_XPixels[best]) | |
| 1323 continue; /* already allocated, waste no more time */ | |
| 1324 c = all + best; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1325 if(XAllocColor(GFX_Display, SDL_XColorMap, c)) { |
| 0 | 1326 /* got it */ |
|
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1327 colors[c->pixel].r = c->red >> 8; |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1328 colors[c->pixel].g = c->green >> 8; |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1329 colors[c->pixel].b = c->blue >> 8; |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1330 ++SDL_XPixels[c->pixel]; |
| 0 | 1331 } else { |
| 1332 /* | |
| 1333 * The colour couldn't be allocated, probably being | |
| 1334 * owned as a r/w cell by another client. Flag it as | |
| 1335 * unavailable and try again. The termination of the | |
| 1336 * loop is guaranteed since at least black and white | |
| 1337 * are always there. | |
| 1338 */ | |
| 1339 c->flags = 0; | |
| 1340 i--; | |
| 1341 } | |
| 1342 } | |
| 1343 } | |
| 1344 | |
| 1345 int X11_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | |
| 1346 { | |
| 1347 int nrej = 0; | |
| 1348 | |
| 1349 /* Check to make sure we have a colormap allocated */ | |
| 1350 if ( SDL_XPixels == NULL ) { | |
| 1351 return(0); | |
| 1352 } | |
| 1353 if ( (this->screen->flags & SDL_HWPALETTE) == SDL_HWPALETTE ) { | |
| 1354 /* private writable colormap: just set the colours we need */ | |
| 1355 XColor *xcmap; | |
| 1356 int i; | |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1357 xcmap = SDL_stack_alloc(XColor, ncolors); |
| 0 | 1358 if(xcmap == NULL) |
| 1359 return 0; | |
| 1360 for ( i=0; i<ncolors; ++i ) { | |
| 1361 xcmap[i].pixel = i + firstcolor; | |
| 1362 xcmap[i].red = (colors[i].r<<8)|colors[i].r; | |
| 1363 xcmap[i].green = (colors[i].g<<8)|colors[i].g; | |
| 1364 xcmap[i].blue = (colors[i].b<<8)|colors[i].b; | |
| 1365 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | |
| 1366 } | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1367 XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1368 XSync(GFX_Display, False); |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1369 SDL_stack_free(xcmap); |
| 0 | 1370 } else { |
| 1371 /* | |
| 1372 * Shared colormap: We only allocate read-only cells, which | |
| 1373 * increases the likelyhood of colour sharing with other | |
| 1374 * clients. The pixel values will almost certainly be | |
| 1375 * different from the requested ones, so the user has to | |
| 1376 * walk the colormap and see which index got what colour. | |
| 1377 * | |
| 1378 * We can work directly with the logical palette since it | |
| 1379 * has already been set when we get here. | |
| 1380 */ | |
| 1381 SDL_Color *want, *reject; | |
| 1382 unsigned long *freelist; | |
| 1383 int i; | |
| 1384 int nfree = 0; | |
| 1385 int nc = this->screen->format->palette->ncolors; | |
| 1386 colors = this->screen->format->palette->colors; | |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1387 freelist = SDL_stack_alloc(unsigned long, nc); |
| 0 | 1388 /* make sure multiple allocations of the same cell are freed */ |
| 1389 for(i = 0; i < ncolors; i++) { | |
| 1390 int pixel = firstcolor + i; | |
| 1391 while(SDL_XPixels[pixel]) { | |
| 1392 freelist[nfree++] = pixel; | |
| 1393 --SDL_XPixels[pixel]; | |
| 1394 } | |
| 1395 } | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1396 XFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0); |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1397 SDL_stack_free(freelist); |
| 0 | 1398 |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1399 want = SDL_stack_alloc(SDL_Color, ncolors); |
|
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1400 reject = SDL_stack_alloc(SDL_Color, ncolors); |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
1401 SDL_memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color)); |
| 0 | 1402 /* make sure the user isn't fooled by her own wishes |
| 1403 (black is safe, always available in the default colormap) */ | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
1404 SDL_memset(colors + firstcolor, 0, ncolors * sizeof(SDL_Color)); |
| 0 | 1405 |
| 1406 /* now try to allocate the colours */ | |
| 1407 for(i = 0; i < ncolors; i++) { | |
| 1408 XColor col; | |
| 1409 col.red = want[i].r << 8; | |
| 1410 col.green = want[i].g << 8; | |
| 1411 col.blue = want[i].b << 8; | |
| 1412 col.flags = DoRed | DoGreen | DoBlue; | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1413 if(XAllocColor(GFX_Display, SDL_XColorMap, &col)) { |
| 0 | 1414 /* We got the colour, or at least the nearest |
| 1415 the hardware could get. */ | |
| 1416 colors[col.pixel].r = col.red >> 8; | |
| 1417 colors[col.pixel].g = col.green >> 8; | |
| 1418 colors[col.pixel].b = col.blue >> 8; | |
| 1419 ++SDL_XPixels[col.pixel]; | |
| 1420 } else { | |
| 1421 /* | |
| 1422 * no more free cells, add it to the list | |
| 1423 * of rejected colours | |
| 1424 */ | |
| 1425 reject[nrej++] = want[i]; | |
| 1426 } | |
| 1427 } | |
| 1428 if(nrej) | |
| 1429 allocate_nearest(this, colors, reject, nrej); | |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1430 SDL_stack_free(reject); |
|
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
1431 SDL_stack_free(want); |
| 0 | 1432 } |
| 1433 return nrej == 0; | |
| 1434 } | |
| 1435 | |
| 1436 int X11_SetGammaRamp(_THIS, Uint16 *ramp) | |
| 1437 { | |
| 1438 int i, ncolors; | |
| 1439 XColor xcmap[256]; | |
| 1440 | |
| 1441 /* See if actually setting the gamma is supported */ | |
| 1442 if ( SDL_Visual->class != DirectColor ) { | |
| 1443 SDL_SetError("Gamma correction not supported on this visual"); | |
| 1444 return(-1); | |
| 1445 } | |
| 1446 | |
| 1447 /* Calculate the appropriate palette for the given gamma ramp */ | |
| 1448 ncolors = SDL_Visual->map_entries; | |
| 1449 for ( i=0; i<ncolors; ++i ) { | |
| 1450 Uint8 c = (256 * i / ncolors); | |
| 1451 xcmap[i].pixel = SDL_MapRGB(this->screen->format, c, c, c); | |
| 1452 xcmap[i].red = ramp[0*256+c]; | |
| 1453 xcmap[i].green = ramp[1*256+c]; | |
| 1454 xcmap[i].blue = ramp[2*256+c]; | |
| 1455 xcmap[i].flags = (DoRed|DoGreen|DoBlue); | |
| 1456 } | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1457 XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors); |
|
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1458 XSync(GFX_Display, False); |
| 0 | 1459 return(0); |
| 1460 } | |
| 1461 | |
| 1462 /* Note: If we are terminated, this could be called in the middle of | |
| 1463 another SDL video routine -- notably UpdateRects. | |
| 1464 */ | |
| 1465 void X11_VideoQuit(_THIS) | |
| 1466 { | |
| 1467 /* Shutdown everything that's still up */ | |
| 1468 /* The event thread should be done, so we can touch SDL_Display */ | |
| 1469 if ( SDL_Display != NULL ) { | |
| 1470 /* Flush any delayed updates */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1471 XSync(GFX_Display, False); |
| 0 | 1472 |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1473 /* 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
|
1474 #ifdef X_HAVE_UTF8_STRING |
|
1319
66f6c64c2c69
Logic bug in X11 Unicode input shutdown...was checking for == NULL
Ryan C. Gordon <icculus@icculus.org>
parents:
1312
diff
changeset
|
1475 if (SDL_IC != NULL) { |
|
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
1476 XUnsetICFocus(SDL_IC); |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1477 XDestroyIC(SDL_IC); |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1478 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
|
1479 } |
|
1319
66f6c64c2c69
Logic bug in X11 Unicode input shutdown...was checking for == NULL
Ryan C. Gordon <icculus@icculus.org>
parents:
1312
diff
changeset
|
1480 if (SDL_IM != NULL) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1481 XCloseIM(SDL_IM); |
|
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1482 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
|
1483 } |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1484 #endif |
|
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1485 |
| 0 | 1486 /* Start shutting down the windows */ |
| 1487 X11_DestroyImage(this, this->screen); | |
| 1488 X11_DestroyWindow(this, this->screen); | |
| 1489 X11_FreeVideoModes(this); | |
| 1490 if ( SDL_XColorMap != SDL_DisplayColormap ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1491 XFreeColormap(SDL_Display, SDL_XColorMap); |
| 0 | 1492 } |
| 1493 if ( SDL_iconcolors ) { | |
| 1494 unsigned long pixel; | |
|
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1495 Colormap dcmap = DefaultColormap(SDL_Display, |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1496 SDL_Screen); |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1497 for(pixel = 0; pixel < 256; ++pixel) { |
|
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1498 while(SDL_iconcolors[pixel] > 0) { |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1499 XFreeColors(GFX_Display, |
|
236
3f09f52ac2cc
Fixed X11 icon color allocation (thanks Mattias!)
Sam Lantinga <slouken@libsdl.org>
parents:
160
diff
changeset
|
1500 dcmap, &pixel, 1, 0); |
| 0 | 1501 --SDL_iconcolors[pixel]; |
| 1502 } | |
| 1503 } | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
1504 SDL_free(SDL_iconcolors); |
| 0 | 1505 SDL_iconcolors = NULL; |
| 1506 } | |
| 1783 | 1507 |
| 0 | 1508 /* Restore gamma settings if they've changed */ |
| 1509 if ( SDL_GetAppState() & SDL_APPACTIVE ) { | |
| 1510 X11_SwapVidModeGamma(this); | |
| 1511 } | |
| 1512 | |
| 1513 /* Free that blank cursor */ | |
| 1514 if ( SDL_BlankCursor != NULL ) { | |
| 1515 this->FreeWMCursor(this, SDL_BlankCursor); | |
| 1516 SDL_BlankCursor = NULL; | |
| 1517 } | |
| 1518 | |
| 1519 /* Close the X11 graphics connection */ | |
| 1520 if ( GFX_Display != NULL ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1521 XCloseDisplay(GFX_Display); |
| 0 | 1522 GFX_Display = NULL; |
| 1523 } | |
| 1524 | |
| 1525 /* Close the X11 display connection */ | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1526 XCloseDisplay(SDL_Display); |
| 0 | 1527 SDL_Display = NULL; |
| 1528 | |
| 1529 /* Reset the X11 error handlers */ | |
| 1530 if ( XIO_handler ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1531 XSetIOErrorHandler(XIO_handler); |
| 0 | 1532 } |
| 1533 if ( X_handler ) { | |
|
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1534 XSetErrorHandler(X_handler); |
| 0 | 1535 } |
| 1536 | |
| 1537 /* Unload GL library after X11 shuts down */ | |
| 1538 X11_GL_UnloadLibrary(this); | |
| 1539 } | |
| 1540 if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) { | |
| 1541 /* Direct screen access, no memory buffer */ | |
| 1542 this->screen->pixels = NULL; | |
| 1543 } | |
|
3885
a10bddfdc40f
Closing minor memory leak in XME code.
Ryan C. Gordon <icculus@icculus.org>
parents:
1863
diff
changeset
|
1544 |
|
a10bddfdc40f
Closing minor memory leak in XME code.
Ryan C. Gordon <icculus@icculus.org>
parents:
1863
diff
changeset
|
1545 #if SDL_VIDEO_DRIVER_X11_XME |
|
a10bddfdc40f
Closing minor memory leak in XME code.
Ryan C. Gordon <icculus@icculus.org>
parents:
1863
diff
changeset
|
1546 XiGMiscDestroy(); |
|
a10bddfdc40f
Closing minor memory leak in XME code.
Ryan C. Gordon <icculus@icculus.org>
parents:
1863
diff
changeset
|
1547 #endif |
| 0 | 1548 } |
| 1549 |