Mercurial > sdl-ios-xcode
annotate src/video/x11/SDL_x11video.c @ 4139:568c9b3c0167 SDL-1.2
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
* Use XResetScreenSaver() instead of disabling screensaver entirely.
Full discussion summary from Erik on the SDL mailing list:
Current behaviour
=================
SDL changes the user's display power management settings without
permission from the user and without telling the user.
The interface that it uses to do so is DPMSDisable/DPMSEnable, which
should only ever be used by configuration utilities like KControl, never
by normal application programs, let alone by the libraries that they
use. Using an interface that is not at all intended for what SDL tries
to achieve means that it will not work as it should. Firstly, the power
management is completely disabled during the whole lifetime of the SDL
program, not only when it should be. Secondly, it makes SDL
non-reentrant, meaning that things will break when multiple SDL programs
are clients of the same X server simultaneously. Thirdly, no cleanup
mechanism ensures that the setting is restored if the client does not do
that (for example if it crashes).
In addition to that, this interface is broken on xorg,
[http://bugs.freedesktop.org/show_bug.cgi?id=13962], so what SDL tries
to do does not work at all on that implementation of the X Window
System. (The reason that the DPMSEnable works in KControl is that it
calls DPMSSetTimeout immediately after,
[http://websvn.kde.org/tags/KDE/3.5.9/kdebase/kcontrol/energy/energy.cpp?annotate=774532#l343]).
The problems that the current behaviour causes
==============================================
1. Information leak. When the user is away, someone might see what the
user has on the display when the user counts on the screensaver
preventing this. This does not even require physical access to the
workstation, it is enough to see it from a distance.
2. Draining battery. An SDL program that runs on a laptop will quickly
drain the battery while the user is away. The system will soon shut down
and require recharging before being usable again, while it should in
fact have consumed very little energy if the user's settings would have
been obeyed.
3. Wasting energy. Even if battery issues are not considered, energy as
such is wasted.
4. Display wear. The display may be worn out.
The problems that the current behaviour tries to solve
======================================================
1. Preventing screensaver while playing movies.
Many SDL applications are media players. They have reasons to prevent
screensavers from being activated while a movie is being played. When a
user clicks on the play button it can be interpreted as saying "play
this movie, but do not turn off the display while playing it, because I
will watch it even though I do not interact with the system".
2. Preventing screensaver when some input bypasses X.
Sometimes SDL uses input from another source than the X server, so
that the X server is bypassed. This obviously breaks the screensaver
handling. SDL tries to work around that.
3. Preventing screensaver when all input bypasses X.
There is something called Direct Graphics Access mode, where a
program takes control of both the display and the input devices from the
X server. This obviously means that the X server can not handle the
screensaver alone, since screensaver handling depends on input handling.
SDL does not do what it should to help the X server to handle the
screensaver. Nor does SDL take care of screeensaver handling itself. SDL
simply disables the screensaver completely.
How the problems should be solved
=================================
The correct way for an application program to prevent the screensaver
under X is to call XResetScreenSaver. This was recently discovered and
implemented by the mplayer developers,
[http://svn.mplayerhq.hu/mplayer?view=rev&revision=25637]. SDL needs to
wrap this in an API call (SDL_ResetScreenSaver) and implement it for the
other video targets (if they do not have a corresponding call, SDL
should do what it takes on that particular target, for example sending
fake key events).
1. When a movie is played, the player should reset the screensaver when
the animation is advanced to a new frame. The same applies to anything
similar, like slideshows.
2. When the X server is handling input, it must handle all input
(keyboards, mice, gamepads, ...). This is necessary, not only to be able
to handle the screensaver, but also so that it can send the events to
the correct (the currently active) client. If there is an input device
that the X server can not handle for some reason (such as lack of Plug
and Play capability), the program that handles the device as a
workaround must simulate what would happen if the X server would have
handled the device, by calling XResetScreenSaver when input is received
from the device.
3. When the X server is not handling the input, it depends on the
program that does to call XResetScreenSaver whenever an input event
occurs. Alternatively the program must handle the screensaver countdown
internally and call XActivateScreenSaver.
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Fri, 29 Feb 2008 13:55:44 +0000 |
parents | df2f562890a0 |
children | a1b03ba2fcd0 |
rev | line source |
---|---|
0 | 1 /* |
2 SDL - Simple DirectMedia Layer | |
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1299
diff
changeset
|
3 Copyright (C) 1997-2006 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)); |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
112 SDL_memset(device->hidden, 0, (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
|
113 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
|
114 SDL_malloc((sizeof *device->gl_data)); |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
115 SDL_memset(device->gl_data, 0, (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
|
116 } |
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
117 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
|
118 (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
|
119 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
|
120 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
|
121 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
|
122 } |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
123 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
|
124 SDL_memset(device->gl_data, 0, (sizeof *device->gl_data)); |
0 | 125 |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
126 /* 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
|
127 device->handles_any_size = 1; |
0 | 128 |
1168
045f186426e1
Dynamically load X11 libraries like we currently do for alsa, esd, etc.
Ryan C. Gordon <icculus@icculus.org>
parents:
867
diff
changeset
|
129 /* 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
|
130 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
|
131 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
|
132 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
|
133 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
|
134 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
|
135 #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
|
136 device->CreateYUVOverlay = X11_CreateYUVOverlay; |
0 | 137 #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
|
138 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
|
139 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
|
140 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
|
141 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
|
142 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
|
143 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
|
144 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
|
145 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
|
146 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
|
147 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
|
148 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
|
149 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
|
150 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
|
151 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
|
152 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
|
153 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
|
154 #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
|
155 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
|
156 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
|
157 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
|
158 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
|
159 device->GL_SwapBuffers = X11_GL_SwapBuffers; |
0 | 160 #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
|
161 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
|
162 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
|
163 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
|
164 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
|
165 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
|
166 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
|
167 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
|
168 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
|
169 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
|
170 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
|
171 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
|
172 device->PumpEvents = X11_PumpEvents; |
0 | 173 |
1168
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->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
|
175 } |
0 | 176 |
177 return device; | |
178 } | |
179 | |
180 VideoBootStrap X11_bootstrap = { | |
181 "x11", "X Window System", | |
182 X11_Available, X11_CreateDevice | |
183 }; | |
184 | |
185 /* Normal X11 error handler routine */ | |
186 static int (*X_handler)(Display *, XErrorEvent *) = NULL; | |
187 static int x_errhandler(Display *d, XErrorEvent *e) | |
188 { | |
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
189 #if SDL_VIDEO_DRIVER_X11_VIDMODE |
0 | 190 extern int vm_error; |
191 #endif | |
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
192 #if SDL_VIDEO_DRIVER_X11_DGAMOUSE |
0 | 193 extern int dga_error; |
194 #endif | |
195 | |
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
196 #if SDL_VIDEO_DRIVER_X11_VIDMODE |
0 | 197 /* VidMode errors are non-fatal. :) */ |
198 /* Are the errors offset by one from the error base? | |
199 e.g. the error base is 143, the code is 148, and the | |
200 actual error is XF86VidModeExtensionDisabled (4) ? | |
201 */ | |
202 if ( (vm_error >= 0) && | |
203 (((e->error_code == BadRequest)&&(e->request_code == vm_error)) || | |
204 ((e->error_code > vm_error) && | |
205 (e->error_code <= (vm_error+XF86VidModeNumberErrors)))) ) { | |
1765 | 206 #ifdef X11_DEBUG |
0 | 207 { char errmsg[1024]; |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
208 XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg)); |
0 | 209 printf("VidMode error: %s\n", errmsg); |
210 } | |
211 #endif | |
212 return(0); | |
213 } | |
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
214 #endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */ |
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 #if SDL_VIDEO_DRIVER_X11_DGAMOUSE |
0 | 217 /* DGA errors can be non-fatal. :) */ |
218 if ( (dga_error >= 0) && | |
219 ((e->error_code > dga_error) && | |
220 (e->error_code <= (dga_error+XF86DGANumberErrors))) ) { | |
1765 | 221 #ifdef X11_DEBUG |
0 | 222 { char errmsg[1024]; |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
223 XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg)); |
0 | 224 printf("DGA error: %s\n", errmsg); |
225 } | |
226 #endif | |
227 return(0); | |
228 } | |
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
229 #endif /* SDL_VIDEO_DRIVER_X11_DGAMOUSE */ |
0 | 230 |
231 return(X_handler(d,e)); | |
232 } | |
233 | |
234 /* X11 I/O error handler routine */ | |
235 static int (*XIO_handler)(Display *) = NULL; | |
236 static int xio_errhandler(Display *d) | |
237 { | |
238 /* Ack! Lost X11 connection! */ | |
239 | |
240 /* We will crash if we try to clean up our display */ | |
241 if ( current_video->hidden->Ximage ) { | |
242 SDL_VideoSurface->pixels = NULL; | |
243 } | |
244 current_video->hidden->X11_Display = NULL; | |
245 | |
246 /* Continue with the standard X11 error handler */ | |
247 return(XIO_handler(d)); | |
248 } | |
249 | |
1609
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
250 static int (*Xext_handler)(Display *, _Xconst char *, _Xconst char *) = NULL; |
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
251 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
|
252 { |
1765 | 253 #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
|
254 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
|
255 printf(" Extension \"%s\" %s on display \"%s\".\n", |
1609
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
256 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
|
257 #endif |
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
258 |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
259 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
|
260 /* |
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
261 * 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
|
262 * 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
|
263 * 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
|
264 */ |
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
265 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
|
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 |
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
268 /* Everything else goes to the default handler... */ |
1609
c3b5d17277d4
Fixed compiler warning.
Ryan C. Gordon <icculus@icculus.org>
parents:
1575
diff
changeset
|
269 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
|
270 } |
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
271 |
1325 | 272 /* Find out what class name we should use */ |
273 static char *get_classname(char *classname, int maxlen) | |
274 { | |
275 char *spot; | |
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
276 #if defined(__LINUX__) || defined(__FREEBSD__) |
1325 | 277 char procfile[1024]; |
278 char linkfile[1024]; | |
279 int linksize; | |
280 #endif | |
281 | |
282 /* First allow environment variable override */ | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
283 spot = SDL_getenv("SDL_VIDEO_X11_WMCLASS"); |
1325 | 284 if ( spot ) { |
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
285 SDL_strlcpy(classname, spot, maxlen); |
1325 | 286 return classname; |
287 } | |
288 | |
289 /* 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
|
290 #if defined(__LINUX__) || defined(__FREEBSD__) |
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
291 #if defined(__LINUX__) |
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
292 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
|
293 #elif defined(__FREEBSD__) |
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/file", getpid()); |
1325 | 295 #else |
296 #error Where can we find the executable name? | |
297 #endif | |
298 linksize = readlink(procfile, linkfile, sizeof(linkfile)-1); | |
299 if ( linksize > 0 ) { | |
300 linkfile[linksize] = '\0'; | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
301 spot = SDL_strrchr(linkfile, '/'); |
1325 | 302 if ( spot ) { |
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
303 SDL_strlcpy(classname, spot+1, maxlen); |
1325 | 304 } else { |
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
305 SDL_strlcpy(classname, linkfile, maxlen); |
1325 | 306 } |
307 return classname; | |
308 } | |
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
309 #endif /* __LINUX__ */ |
1325 | 310 |
311 /* Finally use the default we've used forever */ | |
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
312 SDL_strlcpy(classname, "SDL_App", maxlen); |
1325 | 313 return classname; |
314 } | |
315 | |
0 | 316 /* Create auxiliary (toplevel) windows with the current visual */ |
317 static void create_aux_windows(_THIS) | |
318 { | |
1765 | 319 int x = 0, y = 0; |
1325 | 320 char classname[1024]; |
0 | 321 XSetWindowAttributes xattr; |
322 XWMHints *hints; | |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
323 unsigned long app_event_mask; |
0 | 324 int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen)); |
325 | |
1558 | 326 /* 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
|
327 WM_DELETE_WINDOW = XInternAtom(SDL_Display, "WM_DELETE_WINDOW", False); |
1558 | 328 |
0 | 329 /* Don't create any extra windows if we are being managed */ |
330 if ( SDL_windowid ) { | |
331 FSwindow = 0; | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
332 WMwindow = SDL_strtol(SDL_windowid, NULL, 0); |
0 | 333 return; |
334 } | |
335 | |
336 if(FSwindow) | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
337 XDestroyWindow(SDL_Display, FSwindow); |
0 | 338 |
1863 | 339 #if SDL_VIDEO_DRIVER_X11_XINERAMA |
1765 | 340 if ( use_xinerama ) { |
341 x = xinerama_info.x_org; | |
342 y = xinerama_info.y_org; | |
343 } | |
344 #endif | |
0 | 345 xattr.override_redirect = True; |
346 xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0; | |
347 xattr.border_pixel = 0; | |
348 xattr.colormap = SDL_XColorMap; | |
349 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
350 FSwindow = XCreateWindow(SDL_Display, SDL_Root, |
1765 | 351 x, y, 32, 32, 0, |
0 | 352 this->hidden->depth, InputOutput, SDL_Visual, |
353 CWOverrideRedirect | CWBackPixel | CWBorderPixel | |
354 | CWColormap, | |
355 &xattr); | |
356 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
357 XSelectInput(SDL_Display, FSwindow, StructureNotifyMask); |
0 | 358 |
359 /* Tell KDE to keep the fullscreen window on top */ | |
360 { | |
361 XEvent ev; | |
362 long mask; | |
363 | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
364 SDL_memset(&ev, 0, sizeof(ev)); |
0 | 365 ev.xclient.type = ClientMessage; |
366 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
|
367 ev.xclient.message_type = XInternAtom(SDL_Display, |
0 | 368 "KWM_KEEP_ON_TOP", False); |
369 ev.xclient.format = 32; | |
370 ev.xclient.data.l[0] = FSwindow; | |
371 ev.xclient.data.l[1] = CurrentTime; | |
372 mask = SubstructureRedirectMask; | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
373 XSendEvent(SDL_Display, SDL_Root, False, mask, &ev); |
0 | 374 } |
375 | |
376 hints = NULL; | |
377 if(WMwindow) { | |
378 /* 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
|
379 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
|
380 XDestroyWindow(SDL_Display, WMwindow); |
0 | 381 } |
382 | |
383 /* Create the window for windowed management */ | |
384 /* (reusing the xattr structure above) */ | |
1765 | 385 WMwindow = XCreateWindow(SDL_Display, SDL_Root, |
386 x, y, 32, 32, 0, | |
0 | 387 this->hidden->depth, InputOutput, SDL_Visual, |
388 CWBackPixel | CWBorderPixel | CWColormap, | |
389 &xattr); | |
390 | |
391 /* Set the input hints so we get keyboard input */ | |
392 if(!hints) { | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
393 hints = XAllocWMHints(); |
0 | 394 hints->input = True; |
395 hints->flags = InputHint; | |
396 } | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
397 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
|
398 XFree(hints); |
1767 | 399 X11_SetCaptionNoLock(this, this->wm_title, this->wm_icon); |
0 | 400 |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
401 app_event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
402 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask; |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
403 XSelectInput(SDL_Display, WMwindow, app_event_mask); |
0 | 404 |
405 /* Set the class hints so we can get an icon (AfterStep) */ | |
1325 | 406 get_classname(classname, sizeof(classname)); |
0 | 407 { |
408 XClassHint *classhints; | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
409 classhints = XAllocClassHint(); |
0 | 410 if(classhints != NULL) { |
449
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
411 classhints->res_name = classname; |
8a687496061f
Added an environment variable SDL_VIDEO_X11_WMCLASS
Sam Lantinga <slouken@libsdl.org>
parents:
444
diff
changeset
|
412 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
|
413 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
|
414 XFree(classhints); |
0 | 415 } |
416 } | |
417 | |
3964
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
418 /* Setup the communication with the IM server */ |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
419 /* 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
|
420 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
|
421 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
|
422 |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
423 #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
|
424 if (SDL_X11_HAVE_UTF8) { |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
425 /* Discard obsolete resources if any. */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
426 if (SDL_IM != NULL && SDL_Display != XDisplayOfIM(SDL_IM)) { |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
427 /* Just a double check. I don't think this |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
428 code is ever executed. */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
429 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
|
430 if (SDL_IC) { |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
431 XUnsetICFocus(SDL_IC); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
432 XDestroyIC(SDL_IC); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
433 SDL_IC = NULL; |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
434 } |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
435 XCloseIM(SDL_IM); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
436 SDL_IM = NULL; |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
437 } |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
438 |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
439 /* Open an input method. */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
440 if (SDL_IM == NULL) { |
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
441 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
|
442 const char *p; |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
443 size_t n; |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
444 /* I'm not comfortable to do locale setup |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
445 here. However, we need C library locale |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
446 (and xlib modifiers) to be set based on the |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
447 user's preference to use XIM, and many |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
448 existing game programs doesn't take care of |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
449 users' locale preferences, so someone other |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
450 than the game program should do it. |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
451 Moreover, ones say that some game programs |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
452 heavily rely on the C locale behaviour, |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
453 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
|
454 library locale. Given the situation, I |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
455 couldn't find better place to do the |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
456 job... */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
457 |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
458 /* Save the current (application program's) |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
459 locale settings. */ |
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
460 p = setlocale(LC_ALL, NULL); |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
461 if ( p ) { |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
462 n = SDL_strlen(p)+1; |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
463 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
|
464 if ( old_locale ) { |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
465 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
|
466 } |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
467 } |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
468 p = XSetLocaleModifiers(NULL); |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
469 if ( p ) { |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
470 n = SDL_strlen(p)+1; |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
471 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
|
472 if ( old_modifiers ) { |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
473 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
|
474 } |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
475 } |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
476 |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
477 /* Fetch the user's preferences and open the |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
478 input method with them. */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
479 setlocale(LC_ALL, ""); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
480 XSetLocaleModifiers(""); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
481 SDL_IM = XOpenIM(SDL_Display, NULL, classname, classname); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
482 |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
483 /* Restore the application's locale settings |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
484 so that we don't break the application's |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
485 expected behaviour. */ |
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
486 if ( old_locale ) { |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
487 /* We need to restore the C library |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
488 locale first, since the |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
489 interpretation of the X modifier |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
490 may depend on it. */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
491 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
|
492 SDL_stack_free(old_locale); |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
493 } |
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
494 if ( old_modifiers ) { |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
495 XSetLocaleModifiers(old_modifiers); |
4067
07d621a03a94
Use SDL C functions (fixes security warnings on OpenBSD)
Sam Lantinga <slouken@libsdl.org>
parents:
4016
diff
changeset
|
496 SDL_stack_free(old_modifiers); |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
497 } |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
498 } |
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 /* 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
|
501 if (SDL_IM == NULL) { |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
502 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
|
503 } else { |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
504 if (SDL_IC != NULL) { |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
505 /* Discard the old IC before creating new one. */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
506 XUnsetICFocus(SDL_IC); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
507 XDestroyIC(SDL_IC); |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
508 } |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
509 /* Theoretically we should check the current IM supports |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
510 PreeditNothing+StatusNothing style (i.e., root window method) |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
511 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
|
512 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
|
513 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
|
514 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
|
515 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
|
516 XNClientWindow, WMwindow, |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
517 XNFocusWindow, WMwindow, |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
518 XNInputStyle, XIMPreeditNothing | XIMStatusNothing, |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
519 XNResourceName, classname, |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
520 XNResourceClass, classname, |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
521 NULL); |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
522 |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
523 if (SDL_IC == NULL) { |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
524 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
|
525 XCloseIM(SDL_IM); |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
526 SDL_IM = NULL; |
3978
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
527 } else { |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
528 /* 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
|
529 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
|
530 vary depending on the IM implementation and the options |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
531 specified through various routes. Although unlikely, the |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
532 xlib specification allows IM to change the event requirement |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
533 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
|
534 whenever we re-create an IC. */ |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
535 unsigned long mask = 0; |
b966761fef6c
Significantly improved XIM support.
Ryan C. Gordon <icculus@icculus.org>
parents:
3964
diff
changeset
|
536 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
|
537 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
|
538 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
|
539 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
|
540 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
|
541 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
|
542 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
|
543 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
|
544 } else { |
a6264945ac52
Fixed compiler warning (gcc w/ -Wall) for unused variable, and checked for
Ryan C. Gordon <icculus@icculus.org>
parents:
4008
diff
changeset
|
545 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
|
546 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
|
547 } |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
548 } |
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
549 } |
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
550 } |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
551 #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
|
552 |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
553 /* 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
|
554 XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1); |
0 | 555 } |
556 | |
557 static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat) | |
558 { | |
4139
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
559 const char *env; |
0 | 560 char *display; |
561 int i; | |
562 | |
563 /* Open the X11 display */ | |
564 display = NULL; /* Get it from DISPLAY environment variable */ | |
565 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
566 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
|
567 (SDL_strncmp(XDisplayName(display), "unix:", 5) == 0) ) { |
0 | 568 local_X11 = 1; |
569 } else { | |
570 local_X11 = 0; | |
571 } | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
572 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
|
573 #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
|
574 /* 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
|
575 * 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
|
576 * 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
|
577 * |
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
578 * 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
|
579 * 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
|
580 * |
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
581 */ |
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
582 if ( SDL_Display == NULL ) { |
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
583 SDL_Delay(1000); |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
584 SDL_Display = XOpenDisplay(display); |
1299
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
585 } |
2bf9dda618e5
Corrects dynamic X11 code on Tru64 systems.
Ryan C. Gordon <icculus@icculus.org>
parents:
1248
diff
changeset
|
586 #endif |
0 | 587 if ( SDL_Display == NULL ) { |
588 SDL_SetError("Couldn't open X11 display"); | |
589 return(-1); | |
590 } | |
591 #ifdef X11_DEBUG | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
592 XSynchronize(SDL_Display, True); |
0 | 593 #endif |
594 | |
595 /* Create an alternate X display for graphics updates -- allows us | |
596 to do graphics updates in a separate thread from event handling. | |
597 Thread-safe X11 doesn't seem to exist. | |
598 */ | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
599 GFX_Display = XOpenDisplay(display); |
0 | 600 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
|
601 XCloseDisplay(SDL_Display); |
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
602 SDL_Display = NULL; |
0 | 603 SDL_SetError("Couldn't open X11 display"); |
604 return(-1); | |
605 } | |
606 | |
607 /* 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
|
608 X_handler = XSetErrorHandler(x_errhandler); |
0 | 609 |
610 /* 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
|
611 XIO_handler = XSetIOErrorHandler(xio_errhandler); |
0 | 612 |
1248
d2c6881935be
Catch X11 extension errors...since most of these are notifications that we
Ryan C. Gordon <icculus@icculus.org>
parents:
1206
diff
changeset
|
613 /* 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
|
614 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
|
615 |
0 | 616 /* use default screen (from $DISPLAY) */ |
617 SDL_Screen = DefaultScreen(SDL_Display); | |
618 | |
619 #ifndef NO_SHARED_MEMORY | |
620 /* 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
|
621 use_mitshm = 0; |
0 | 622 if ( local_X11 ) { |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
623 use_mitshm = XShmQueryExtension(SDL_Display); |
0 | 624 } |
625 #endif /* NO_SHARED_MEMORY */ | |
626 | |
627 /* 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
|
628 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
|
629 XCloseDisplay(GFX_Display); |
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
630 GFX_Display = NULL; |
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
631 XCloseDisplay(SDL_Display); |
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
632 SDL_Display = NULL; |
0 | 633 return -1; |
3964
3dc92ff218dd
Clean up have-initialized resources in some failing edge cases.
Ryan C. Gordon <icculus@icculus.org>
parents:
3936
diff
changeset
|
634 } |
0 | 635 |
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
|
636 /* 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
|
637 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
|
638 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
|
639 |
0 | 640 /* Determine the default screen depth: |
641 Use the default visual (or at least one with the same depth) */ | |
642 SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen); | |
643 for(i = 0; i < this->hidden->nvisuals; i++) | |
644 if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display, | |
645 SDL_Screen)) | |
646 break; | |
647 if(i == this->hidden->nvisuals) { | |
648 /* default visual was useless, take the deepest one instead */ | |
649 i = 0; | |
650 } | |
651 SDL_Visual = this->hidden->visuals[i].visual; | |
652 if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) { | |
653 SDL_XColorMap = SDL_DisplayColormap; | |
654 } else { | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
655 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
0 | 656 SDL_Visual, AllocNone); |
657 } | |
658 this->hidden->depth = this->hidden->visuals[i].depth; | |
659 vformat->BitsPerPixel = this->hidden->visuals[i].bpp; | |
660 if ( vformat->BitsPerPixel > 8 ) { | |
661 vformat->Rmask = SDL_Visual->red_mask; | |
662 vformat->Gmask = SDL_Visual->green_mask; | |
663 vformat->Bmask = SDL_Visual->blue_mask; | |
664 } | |
1641 | 665 if ( this->hidden->depth == 32 ) { |
666 vformat->Amask = (0xFFFFFFFF & ~(vformat->Rmask|vformat->Gmask|vformat->Bmask)); | |
667 } | |
0 | 668 X11_SaveVidModeGamma(this); |
669 | |
4124 | 670 /* Allow environment override of screensaver disable. */ |
671 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
|
672 if ( env ) { |
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
673 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
|
674 } else { |
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
675 #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
|
676 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
|
677 #else |
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 = 1; |
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
679 #endif |
568c9b3c0167
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
Sam Lantinga <slouken@libsdl.org>
parents:
4124
diff
changeset
|
680 } |
1783 | 681 |
0 | 682 /* 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
|
683 SDL_windowid = SDL_getenv("SDL_WINDOWID"); |
0 | 684 |
685 /* Create the fullscreen and managed windows */ | |
686 create_aux_windows(this); | |
687 | |
688 /* Create the blank cursor */ | |
689 SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask, | |
690 BLANK_CWIDTH, BLANK_CHEIGHT, | |
691 BLANK_CHOTX, BLANK_CHOTY); | |
692 | |
693 /* Fill in some window manager capabilities */ | |
694 this->info.wm_available = 1; | |
695 | |
696 /* We're done! */ | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
697 XFlush(SDL_Display); |
0 | 698 return(0); |
699 } | |
700 | |
701 static void X11_DestroyWindow(_THIS, SDL_Surface *screen) | |
702 { | |
703 /* Clean up OpenGL */ | |
704 if ( screen ) { | |
705 screen->flags &= ~(SDL_OPENGL|SDL_OPENGLBLIT); | |
706 } | |
707 X11_GL_Shutdown(this); | |
708 | |
709 if ( ! SDL_windowid ) { | |
710 /* Hide the managed window */ | |
711 if ( WMwindow ) { | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
712 XUnmapWindow(SDL_Display, WMwindow); |
0 | 713 } |
714 if ( screen && (screen->flags & SDL_FULLSCREEN) ) { | |
715 screen->flags &= ~SDL_FULLSCREEN; | |
716 X11_LeaveFullScreen(this); | |
717 } | |
718 | |
719 /* Destroy the output window */ | |
720 if ( SDL_Window ) { | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
721 XDestroyWindow(SDL_Display, SDL_Window); |
0 | 722 } |
723 | |
724 /* Free the colormap entries */ | |
725 if ( SDL_XPixels ) { | |
726 int numcolors; | |
727 unsigned long pixel; | |
728 numcolors = SDL_Visual->map_entries; | |
729 for ( pixel=0; pixel<numcolors; ++pixel ) { | |
730 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
|
731 XFreeColors(GFX_Display, |
0 | 732 SDL_DisplayColormap,&pixel,1,0); |
733 --SDL_XPixels[pixel]; | |
734 } | |
735 } | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
736 SDL_free(SDL_XPixels); |
0 | 737 SDL_XPixels = NULL; |
738 } | |
739 | |
740 /* Free the graphics context */ | |
741 if ( SDL_GC ) { | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
742 XFreeGC(SDL_Display, SDL_GC); |
0 | 743 SDL_GC = 0; |
744 } | |
745 } | |
746 } | |
747 | |
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
748 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
|
749 { |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
750 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
|
751 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
|
752 if ( window ) { |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
753 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
|
754 return SDL_TRUE; |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
755 } |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
756 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
|
757 center = window; |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
758 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
759 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
760 if ( center ) { |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
761 *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
|
762 *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
|
763 return SDL_TRUE; |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
764 } |
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
765 return SDL_FALSE; |
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 |
0 | 768 static void X11_SetSizeHints(_THIS, int w, int h, Uint32 flags) |
769 { | |
770 XSizeHints *hints; | |
771 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
772 hints = XAllocSizeHints(); |
0 | 773 if ( hints ) { |
774 if ( flags & SDL_RESIZABLE ) { | |
775 hints->min_width = 32; | |
776 hints->min_height = 32; | |
777 hints->max_height = 4096; | |
778 hints->max_width = 4096; | |
779 } else { | |
780 hints->min_width = hints->max_width = w; | |
781 hints->min_height = hints->max_height = h; | |
782 } | |
783 hints->flags = PMaxSize | PMinSize; | |
784 if ( flags & SDL_FULLSCREEN ) { | |
785 hints->x = 0; | |
786 hints->y = 0; | |
787 hints->flags |= USPosition; | |
788 } else | |
789 /* Center it, if desired */ | |
497
bb2d68294e81
Cleaned up the SDL_VIDEO_WINDOW_POS variable support
Sam Lantinga <slouken@libsdl.org>
parents:
485
diff
changeset
|
790 if ( X11_WindowPosition(this, &hints->x, &hints->y, w, h) ) { |
0 | 791 hints->flags |= USPosition; |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
792 XMoveWindow(SDL_Display, WMwindow, hints->x, hints->y); |
0 | 793 |
794 /* 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
|
795 XSync(SDL_Display, True); |
0 | 796 } |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
797 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
|
798 XFree(hints); |
0 | 799 } |
800 | |
801 /* Respect the window caption style */ | |
802 if ( flags & SDL_NOFRAME ) { | |
803 SDL_bool set; | |
804 Atom WM_HINTS; | |
805 | |
806 /* We haven't modified the window manager hints yet */ | |
807 set = SDL_FALSE; | |
808 | |
809 /* 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
|
810 WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
0 | 811 if ( WM_HINTS != None ) { |
812 /* Hints used by Motif compliant window managers */ | |
813 struct { | |
814 unsigned long flags; | |
815 unsigned long functions; | |
816 unsigned long decorations; | |
817 long input_mode; | |
818 unsigned long status; | |
819 } MWMHints = { (1L << 1), 0, 0, 0, 0 }; | |
820 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
821 XChangeProperty(SDL_Display, WMwindow, |
0 | 822 WM_HINTS, WM_HINTS, 32, |
823 PropModeReplace, | |
824 (unsigned char *)&MWMHints, | |
825 sizeof(MWMHints)/sizeof(long)); | |
826 set = SDL_TRUE; | |
827 } | |
828 /* 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
|
829 WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
0 | 830 if ( WM_HINTS != None ) { |
831 long KWMHints = 0; | |
832 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
833 XChangeProperty(SDL_Display, WMwindow, |
0 | 834 WM_HINTS, WM_HINTS, 32, |
835 PropModeReplace, | |
836 (unsigned char *)&KWMHints, | |
837 sizeof(KWMHints)/sizeof(long)); | |
838 set = SDL_TRUE; | |
839 } | |
840 /* 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
|
841 WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True); |
0 | 842 if ( WM_HINTS != None ) { |
843 long GNOMEHints = 0; | |
844 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
845 XChangeProperty(SDL_Display, WMwindow, |
0 | 846 WM_HINTS, WM_HINTS, 32, |
847 PropModeReplace, | |
848 (unsigned char *)&GNOMEHints, | |
849 sizeof(GNOMEHints)/sizeof(long)); | |
850 set = SDL_TRUE; | |
851 } | |
852 /* Finally set the transient hints if necessary */ | |
853 if ( ! set ) { | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
854 XSetTransientForHint(SDL_Display, WMwindow, SDL_Root); |
0 | 855 } |
856 } else { | |
857 SDL_bool set; | |
858 Atom WM_HINTS; | |
859 | |
860 /* We haven't modified the window manager hints yet */ | |
861 set = SDL_FALSE; | |
862 | |
863 /* 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
|
864 WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True); |
0 | 865 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
|
866 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
0 | 867 set = SDL_TRUE; |
868 } | |
869 /* 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
|
870 WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True); |
0 | 871 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
|
872 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
0 | 873 set = SDL_TRUE; |
874 } | |
875 /* 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
|
876 WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True); |
0 | 877 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
|
878 XDeleteProperty(SDL_Display, WMwindow, WM_HINTS); |
0 | 879 set = SDL_TRUE; |
880 } | |
881 /* Finally unset the transient hints if necessary */ | |
882 if ( ! set ) { | |
883 /* 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
|
884 XSetTransientForHint(SDL_Display, WMwindow, None); |
0 | 885 } |
886 } | |
887 } | |
888 | |
889 static int X11_CreateWindow(_THIS, SDL_Surface *screen, | |
890 int w, int h, int bpp, Uint32 flags) | |
891 { | |
892 int i, depth; | |
893 Visual *vis; | |
894 int vis_change; | |
1641 | 895 Uint32 Amask; |
0 | 896 |
897 /* If a window is already present, destroy it and start fresh */ | |
898 if ( SDL_Window ) { | |
899 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
|
900 switch_waiting = 0; /* Prevent jump back to now-meaningless state. */ |
0 | 901 } |
902 | |
903 /* See if we have been given a window id */ | |
904 if ( SDL_windowid ) { | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
905 SDL_Window = SDL_strtol(SDL_windowid, NULL, 0); |
0 | 906 } else { |
907 SDL_Window = 0; | |
908 } | |
909 | |
910 /* find out which visual we are going to use */ | |
911 if ( flags & SDL_OPENGL ) { | |
912 XVisualInfo *vi; | |
913 | |
914 vi = X11_GL_GetVisual(this); | |
915 if( !vi ) { | |
916 return -1; | |
917 } | |
918 vis = vi->visual; | |
919 depth = vi->depth; | |
920 } else if ( SDL_windowid ) { | |
921 XWindowAttributes a; | |
922 | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
923 XGetWindowAttributes(SDL_Display, SDL_Window, &a); |
0 | 924 vis = a.visual; |
925 depth = a.depth; | |
926 } else { | |
927 for ( i = 0; i < this->hidden->nvisuals; i++ ) { | |
928 if ( this->hidden->visuals[i].bpp == bpp ) | |
929 break; | |
930 } | |
931 if ( i == this->hidden->nvisuals ) { | |
932 SDL_SetError("No matching visual for requested depth"); | |
933 return -1; /* should never happen */ | |
934 } | |
935 vis = this->hidden->visuals[i].visual; | |
936 depth = this->hidden->visuals[i].depth; | |
937 } | |
938 #ifdef X11_DEBUG | |
939 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); | |
940 #endif | |
941 vis_change = (vis != SDL_Visual); | |
942 SDL_Visual = vis; | |
943 this->hidden->depth = depth; | |
944 | |
945 /* Allocate the new pixel format for this video mode */ | |
1641 | 946 if ( this->hidden->depth == 32 ) { |
947 Amask = (0xFFFFFFFF & ~(vis->red_mask|vis->green_mask|vis->blue_mask)); | |
948 } else { | |
949 Amask = 0; | |
950 } | |
0 | 951 if ( ! SDL_ReallocFormat(screen, bpp, |
1641 | 952 vis->red_mask, vis->green_mask, vis->blue_mask, Amask) ) { |
0 | 953 return -1; |
1641 | 954 } |
0 | 955 |
956 /* Create the appropriate colormap */ | |
957 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
|
958 XFreeColormap(SDL_Display, SDL_XColorMap); |
0 | 959 } |
960 if ( SDL_Visual->class == PseudoColor ) { | |
961 int ncolors; | |
962 | |
963 /* Allocate the pixel flags */ | |
964 ncolors = SDL_Visual->map_entries; | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
965 SDL_XPixels = SDL_malloc(ncolors * sizeof(int)); |
0 | 966 if(SDL_XPixels == NULL) { |
967 SDL_OutOfMemory(); | |
968 return -1; | |
969 } | |
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1327
diff
changeset
|
970 SDL_memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels)); |
0 | 971 |
972 /* always allocate a private colormap on non-default visuals */ | |
973 if ( SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen) ) { | |
974 flags |= SDL_HWPALETTE; | |
975 } | |
976 if ( flags & SDL_HWPALETTE ) { | |
977 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
|
978 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
0 | 979 SDL_Visual, AllocAll); |
980 } else { | |
981 SDL_XColorMap = SDL_DisplayColormap; | |
982 } | |
983 } else if ( SDL_Visual->class == DirectColor ) { | |
984 | |
985 /* 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
|
986 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
0 | 987 SDL_Visual, AllocAll); |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
988 XSync(SDL_Display, False); |
0 | 989 |
990 /* Initialize the colormap to the identity mapping */ | |
991 SDL_GetGammaRamp(0, 0, 0); | |
992 this->screen = screen; | |
993 X11_SetGammaRamp(this, this->gamma); | |
994 this->screen = NULL; | |
995 } else { | |
996 /* 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
|
997 SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root, |
0 | 998 SDL_Visual, AllocNone); |
999 } | |
1000 | |
1001 /* Recreate the auxiliary windows, if needed (required for GL) */ | |
1002 if ( vis_change ) | |
1003 create_aux_windows(this); | |
1004 | |
1005 if(screen->flags & SDL_HWPALETTE) { | |
1006 /* Since the full-screen window might have got a nonzero background | |
1007 colour (0 is white on some displays), we should reset the | |
1008 background to 0 here since that is what the user expects | |
1009 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
|
1010 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
|
1011 XClearWindow(SDL_Display, FSwindow); |
0 | 1012 } |
1013 | |
1014 /* resize the (possibly new) window manager window */ | |
1015 if( !SDL_windowid ) { | |
1016 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
|
1017 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
|
1018 window_h = h; |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1019 XResizeWindow(SDL_Display, WMwindow, w, h); |
0 | 1020 } |
1021 | |
1022 /* Create (or use) the X11 display window */ | |
1023 if ( !SDL_windowid ) { | |
1024 if ( flags & SDL_OPENGL ) { | |
1025 if ( X11_GL_CreateWindow(this, w, h) < 0 ) { | |
1026 return(-1); | |
1027 } | |
1028 } else { | |
1029 XSetWindowAttributes swa; | |
1030 | |
1031 swa.background_pixel = 0; | |
1032 swa.border_pixel = 0; | |
1033 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
|
1034 SDL_Window = XCreateWindow(SDL_Display, WMwindow, |
0 | 1035 0, 0, w, h, 0, depth, |
1036 InputOutput, SDL_Visual, | |
1037 CWBackPixel | CWBorderPixel | |
1038 | CWColormap, &swa); | |
1039 } | |
1040 /* 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
|
1041 XSelectInput(SDL_Display, SDL_Window, |
0 | 1042 ( EnterWindowMask | LeaveWindowMask |
1043 | ButtonPressMask | ButtonReleaseMask | |
1044 | PointerMotionMask | ExposureMask )); | |
1045 } | |
1046 /* Create the graphics context here, once we have a window */ | |
1047 if ( flags & SDL_OPENGL ) { | |
1048 if ( X11_GL_CreateContext(this) < 0 ) { | |
1049 return(-1); | |
1050 } else { | |
1051 screen->flags |= SDL_OPENGL; | |
1052 } | |
1053 } else { | |
1054 XGCValues gcv; | |
1055 | |
1056 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
|
1057 SDL_GC = XCreateGC(SDL_Display, SDL_Window, |
0 | 1058 GCGraphicsExposures, &gcv); |
1059 if ( ! SDL_GC ) { | |
1060 SDL_SetError("Couldn't create graphics context"); | |
1061 return(-1); | |
1062 } | |
1063 } | |
1064 | |
1065 /* Set our colormaps when not setting a GL mode */ | |
1066 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
|
1067 XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap); |
0 | 1068 if( !SDL_windowid ) { |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1069 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
|
1070 XSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap); |
0 | 1071 } |
1072 } | |
1073 | |
1074 #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
|
1075 if ( SDL_getenv("SDL_VIDEO_X11_BACKINGSTORE") ) |
0 | 1076 #endif |
1077 /* Cache the window in the server, when possible */ | |
1078 { | |
1079 Screen *xscreen; | |
1080 XSetWindowAttributes a; | |
1081 | |
1082 xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen); | |
1083 a.backing_store = DoesBackingStore(xscreen); | |
1084 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
|
1085 XChangeWindowAttributes(SDL_Display, SDL_Window, |
0 | 1086 CWBackingStore, &a); |
1087 } | |
1088 } | |
1089 | |
1090 /* Map them both and go fullscreen, if requested */ | |
1091 if ( ! SDL_windowid ) { | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1092 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
|
1093 XMapWindow(SDL_Display, WMwindow); |
160 | 1094 X11_WaitMapped(this, WMwindow); |
0 | 1095 if ( flags & SDL_FULLSCREEN ) { |
1096 screen->flags |= SDL_FULLSCREEN; | |
1097 X11_EnterFullScreen(this); | |
1098 } else { | |
1099 screen->flags &= ~SDL_FULLSCREEN; | |
1100 } | |
1101 } | |
1178
9867f3d86e44
Real Unicode support for X11. Based on updated version of this patch:
Ryan C. Gordon <icculus@icculus.org>
parents:
1168
diff
changeset
|
1102 |
0 | 1103 return(0); |
1104 } | |
1105 | |
1106 static int X11_ResizeWindow(_THIS, | |
1107 SDL_Surface *screen, int w, int h, Uint32 flags) | |
1108 { | |
1109 if ( ! SDL_windowid ) { | |
1110 /* Resize the window manager window */ | |
1111 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
|
1112 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
|
1113 window_h = h; |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1114 XResizeWindow(SDL_Display, WMwindow, w, h); |
0 | 1115 |
1116 /* Resize the fullscreen and display windows */ | |
1117 if ( flags & SDL_FULLSCREEN ) { | |
1118 if ( screen->flags & SDL_FULLSCREEN ) { | |
1119 X11_ResizeFullScreen(this); | |
1120 } else { | |
1121 screen->flags |= SDL_FULLSCREEN; | |
1122 X11_EnterFullScreen(this); | |
1123 } | |
1124 } else { | |
1125 if ( screen->flags & SDL_FULLSCREEN ) { | |
1126 screen->flags &= ~SDL_FULLSCREEN; | |
1127 X11_LeaveFullScreen(this); | |
1128 } | |
1129 } | |
1575
3ba88cb7eb1b
Updated dynamic X11 code. See details in Bugzilla #170.
Ryan C. Gordon <icculus@icculus.org>
parents:
1558
diff
changeset
|
1130 XResizeWindow(SDL_Display, SDL_Window, w, h); |
0 | 1131 } |
1132 return(0); | |
1133 } | |
1134 | |
1135 SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, | |
1136 int width, int height, int bpp, Uint32 flags) | |
1137 { | |
1138 Uint32 saved_flags; | |
1139 | |
1140 /* Lock the event thread, in multi-threading environments */ | |
1141 SDL_Lock_EventThread(); | |
1142 | |
1143 /* Check the combination of flags we were passed */ | |
1144 if ( flags & SDL_FULLSCREEN ) { | |
1145 /* Clear fullscreen flag if not supported */ | |
1146 if ( SDL_windowid ) { | |
1147 flags &= ~SDL_FULLSCREEN; | |
1148 } | |
1149 } | |
1150 | |
1151 /* 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
|
1152 XSync(GFX_Display, False); |
0 | 1153 |
1154 /* Set up the X11 window */ | |
1155 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
|
1156 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
|
1157 && (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
|
1158 && ((saved_flags&SDL_NOFRAME) == (flags&SDL_NOFRAME)) ) { |
0 | 1159 if (X11_ResizeWindow(this, current, width, height, flags) < 0) { |
1160 current = NULL; | |
1161 goto done; | |
1162 } | |
1163 } else { | |
1164 if (X11_CreateWindow(this,current,width,height,bpp,flags) < 0) { | |
1165 current = NULL; | |
1166 goto done; | |
1167 } | |
1168 } | |
1169 | |
4008 | 1170 /* Update the internal keyboard state */ |
1171 X11_SetKeyboardState(SDL_Display, NULL); | |
1172 | |
1173 /* When the window is first mapped, ignore non-modifier keys */ | |
1174 if ( !current->w && !current->h ) { | |
1175 Uint8 *keys = SDL_GetKeyState(NULL); | |
1176 int i; | |
1177 for ( i = 0; i < SDLK_LAST; ++i ) { | |
1178 switch (i) { | |
1179 case SDLK_NUMLOCK: | |
1180 case SDLK_CAPSLOCK: | |
1181 case SDLK_LCTRL: | |
1182 case SDLK_RCTRL: | |
1183 case SDLK_LSHIFT: | |
1184 case SDLK_RSHIFT: | |
1185 case SDLK_LALT: | |
1186 case SDLK_RALT: | |
1187 case SDLK_LMETA: | |
1188 case SDLK_RMETA: | |
1189 case SDLK_MODE: | |
1190 break; | |
1191 default: | |
1192 keys[i] = SDL_RELEASED; | |
1193 break; | |
1194 } | |
1195 } | |
1196 } | |
1197 | |
0 | 1198 /* Set up the new mode framebuffer */ |
1199 if ( ((current->w != width) || (current->h != height)) || | |
1200 ((saved_flags&SDL_OPENGL) != (flags&SDL_OPENGL)) ) { | |
1201 current->w = width; | |
1202 current->h = height; | |
1203 current->pitch = SDL_CalculatePitch(current); | |
1204 X11_ResizeImage(this, current, flags); | |
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 |