Mercurial > sdl-ios-xcode
annotate src/SDL_compat.c @ 1670:eef792d31de8 SDL-1.3
Work in progress. :)
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Wed, 07 Jun 2006 16:10:28 +0000 |
| parents | 9857d21967bb |
| children | d33dcfc3fde7 |
| rev | line source |
|---|---|
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
1 /* |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
2 SDL - Simple DirectMedia Layer |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
3 Copyright (C) 1997-2006 Sam Lantinga |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
4 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
5 This library is free software; you can redistribute it and/or |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
7 License as published by the Free Software Foundation; either |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
9 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
10 This library is distributed in the hope that it will be useful, |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
11 but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
13 Lesser General Public License for more details. |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
14 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
18 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
19 Sam Lantinga |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
20 slouken@libsdl.org |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
21 */ |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
22 #include "SDL_config.h" |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
23 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
24 /* This file contains functions for backwards compatibility with SDL 1.2 */ |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
25 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
26 #include "SDL.h" |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
27 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
28 #include "video/SDL_sysvideo.h" |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
29 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
30 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
31 static SDL_WindowID window; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
32 static char *wm_title; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
33 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
34 char * |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
35 SDL_AudioDriverName(char *namebuf, int maxlen) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
36 { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
37 const char *name = SDL_GetCurrentAudioDriver(); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
38 if (name) { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
39 SDL_strlcpy(namebuf, name, maxlen); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
40 return namebuf; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
41 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
42 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
43 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
44 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
45 char * |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
46 SDL_VideoDriverName(char *namebuf, int maxlen) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
47 { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
48 const char *name = SDL_GetCurrentVideoDriver(); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
49 if (name) { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
50 SDL_strlcpy(namebuf, name, maxlen); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
51 return namebuf; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
52 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
53 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
54 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
55 |
| 1670 | 56 const SDL_VideoInfo * |
| 57 SDL_GetVideoInfo(void) | |
| 58 { | |
| 59 static SDL_VideoInfo info; | |
| 60 | |
| 61 /* Memory leak, compatibility code, who cares? */ | |
| 62 if (!info.vfmt && SDL_GetDesktopDisplayMode()) { | |
| 63 int bpp; | |
| 64 Uint32 Rmask, Gmask, Bmask, Amask; | |
| 65 | |
| 66 SDL_PixelFormatEnumToMasks(SDL_GetDesktopDisplayMode()->format, &bpp, | |
| 67 &Rmask, &Gmask, &Bmask, &Amask); | |
| 68 info.vfmt = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); | |
| 69 } | |
| 70 return &info; | |
| 71 } | |
| 72 | |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
73 int |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
74 SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
75 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
76 int i, actual_bpp = 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
77 |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
78 if (!SDL_GetVideoDevice()) { |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
79 return 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
80 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
81 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
82 if (!(flags & SDL_FULLSCREEN)) { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
83 return SDL_BITSPERPIXEL(SDL_GetDesktopDisplayMode()->format); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
84 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
85 |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
86 for (i = 0; i < SDL_GetNumDisplayModes(); ++i) { |
|
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
87 const SDL_DisplayMode *mode = SDL_GetDisplayMode(i); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
88 if (!mode->w || !mode->h || (width == mode->w && height == mode->h)) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
89 if (!mode->format) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
90 return bpp; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
91 } |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
92 if (SDL_BITSPERPIXEL(mode->format) >= bpp) { |
|
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
93 actual_bpp = SDL_BITSPERPIXEL(mode->format); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
94 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
95 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
96 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
97 return actual_bpp; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
98 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
99 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
100 SDL_Rect ** |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
101 SDL_ListModes(SDL_PixelFormat * format, Uint32 flags) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
102 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
103 int i, nmodes; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
104 SDL_Rect **modes; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
105 |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
106 if (!SDL_GetVideoDevice()) { |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
107 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
108 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
109 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
110 if (!(flags & SDL_FULLSCREEN)) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
111 return (SDL_Rect **) (-1); |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
112 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
113 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
114 /* Memory leak, but this is a compatibility function, who cares? */ |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
115 nmodes = 0; |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
116 for (i = 0; i < SDL_GetNumDisplayModes(); ++i) { |
|
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
117 const SDL_DisplayMode *mode = SDL_GetDisplayMode(i); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
118 if (!mode->w || !mode->h) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
119 return (SDL_Rect **) (-1); |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
120 } |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
121 if (SDL_BITSPERPIXEL(mode->format) != format->BitsPerPixel) { |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
122 continue; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
123 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
124 if (nmodes > 0 && modes[nmodes - 1]->w == mode->w |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
125 && modes[nmodes - 1]->h == mode->h) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
126 continue; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
127 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
128 |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
129 modes = SDL_realloc(modes, (nmodes + 2) * sizeof(*modes)); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
130 if (!modes) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
131 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
132 } |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
133 modes[nmodes] = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect)); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
134 if (!modes[nmodes]) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
135 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
136 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
137 modes[nmodes]->x = 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
138 modes[nmodes]->y = 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
139 modes[nmodes]->w = mode->w; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
140 modes[nmodes]->h = mode->h; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
141 ++nmodes; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
142 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
143 if (modes) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
144 modes[nmodes] = NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
145 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
146 return modes; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
147 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
148 |
|
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
149 static int (*orig_eventfilter) (const SDL_Event * event); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
150 |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
151 static int |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
152 SDL_CompatEventFilter(const SDL_Event * event) |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
153 { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
154 SDL_Event fake; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
155 |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
156 switch (event->type) { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
157 case SDL_WINDOWEVENT: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
158 switch (event->window.event) { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
159 case SDL_WINDOWEVENT_RESIZED: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
160 fake.type = SDL_VIDEORESIZE; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
161 fake.resize.w = event->window.data1; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
162 fake.resize.h = event->window.data2; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
163 SDL_PushEvent(&fake); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
164 break; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
165 case SDL_WINDOWEVENT_MINIMIZED: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
166 fake.type = SDL_ACTIVEEVENT; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
167 fake.active.gain = 0; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
168 fake.active.state = SDL_APPACTIVE; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
169 SDL_PushEvent(&fake); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
170 break; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
171 case SDL_WINDOWEVENT_RESTORED: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
172 fake.type = SDL_ACTIVEEVENT; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
173 fake.active.gain = 1; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
174 fake.active.state = SDL_APPACTIVE; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
175 SDL_PushEvent(&fake); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
176 break; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
177 case SDL_WINDOWEVENT_ENTER: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
178 fake.type = SDL_ACTIVEEVENT; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
179 fake.active.gain = 1; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
180 fake.active.state = SDL_APPMOUSEFOCUS; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
181 SDL_PushEvent(&fake); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
182 break; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
183 case SDL_WINDOWEVENT_LEAVE: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
184 fake.type = SDL_ACTIVEEVENT; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
185 fake.active.gain = 0; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
186 fake.active.state = SDL_APPMOUSEFOCUS; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
187 SDL_PushEvent(&fake); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
188 break; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
189 case SDL_WINDOWEVENT_FOCUS_GAINED: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
190 fake.type = SDL_ACTIVEEVENT; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
191 fake.active.gain = 1; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
192 fake.active.state = SDL_APPINPUTFOCUS; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
193 SDL_PushEvent(&fake); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
194 break; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
195 case SDL_WINDOWEVENT_FOCUS_LOST: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
196 fake.type = SDL_ACTIVEEVENT; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
197 fake.active.gain = 1; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
198 fake.active.state = SDL_APPINPUTFOCUS; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
199 SDL_PushEvent(&fake); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
200 break; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
201 } |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
202 } |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
203 return orig_eventfilter(event); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
204 } |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
205 |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
206 SDL_Surface * |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
207 SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
208 { |
|
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
209 int (*filter) (const SDL_Event * event); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
210 const SDL_DisplayMode *desktop_mode; |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
211 SDL_DisplayMode mode; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
212 int i; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
213 Uint32 window_flags; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
214 Uint32 desktop_format; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
215 Uint32 desired_format; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
216 |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
217 if (!SDL_GetVideoDevice()) { |
|
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
218 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) { |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
219 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
220 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
221 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
222 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
223 /* Destroy existing window */ |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
224 SDL_DestroyWindow(window); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
225 |
|
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
226 /* Set up the event filter */ |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
227 filter = SDL_GetEventFilter(); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
228 if (filter != SDL_CompatEventFilter) { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
229 orig_eventfilter = filter; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
230 } |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
231 SDL_SetEventFilter(SDL_CompatEventFilter); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
232 |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
233 /* Create a new window */ |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
234 window_flags = SDL_WINDOW_SHOWN; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
235 if (flags & SDL_FULLSCREEN) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
236 window_flags |= SDL_WINDOW_FULLSCREEN; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
237 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
238 if (flags & SDL_OPENGL) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
239 window_flags |= SDL_WINDOW_OPENGL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
240 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
241 if (flags & SDL_RESIZABLE) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
242 window_flags |= SDL_WINDOW_RESIZABLE; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
243 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
244 if (flags & SDL_NOFRAME) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
245 window_flags |= SDL_WINDOW_BORDERLESS; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
246 } |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
247 window = SDL_CreateWindow(wm_title, 0, 0, width, height, window_flags); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
248 if (!window) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
249 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
250 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
251 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
252 /* Set up the desired display mode */ |
|
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
253 desktop_mode = SDL_GetDesktopDisplayMode(); |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
254 desktop_format = desktop_mode->format; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
255 if (desktop_format && ((flags & SDL_ANYFORMAT) |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
256 || (bpp == SDL_BITSPERPIXEL(desktop_format)))) { |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
257 desired_format = desktop_format; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
258 } else { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
259 switch (bpp) { |
|
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
260 case 0: |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
261 if (desktop_format) { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
262 desired_format = desktop_format; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
263 } else { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
264 desired_format = SDL_PixelFormat_RGB888; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
265 } |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
266 break; |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
267 case 8: |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
268 desired_format = SDL_PixelFormat_Index8; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
269 break; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
270 case 15: |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
271 desired_format = SDL_PixelFormat_RGB555; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
272 break; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
273 case 16: |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
274 desired_format = SDL_PixelFormat_RGB565; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
275 break; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
276 case 24: |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
277 desired_format = SDL_PixelFormat_RGB24; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
278 break; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
279 case 32: |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
280 desired_format = SDL_PixelFormat_RGB888; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
281 break; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
282 default: |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
283 SDL_SetError("Unsupported bpp in SDL_SetVideoMode()"); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
284 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
285 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
286 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
287 mode.format = desired_format; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
288 mode.w = width; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
289 mode.h = height; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
290 mode.refresh_rate = 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
291 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
292 /* Set the desired display mode */ |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
293 if (flags & SDL_FULLSCREEN) { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
294 if (!SDL_GetClosestDisplayMode(&mode, &mode)) { |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
295 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
296 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
297 } else { |
|
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
298 if (desktop_format) { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
299 mode.format = desktop_format; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
300 } |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
301 if (desktop_mode->w && desktop_mode->h) { |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
302 mode.w = desktop_mode->w; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
303 mode.h = desktop_mode->h; |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
304 } |
|
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset
|
305 mode.refresh_rate = desktop_mode->refresh_rate; |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
306 } |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
307 if (SDL_SetDisplayMode(&mode) < 0) { |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
308 return NULL; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
309 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
310 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
311 /* Create the display surface */ |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
312 return SDL_CreateWindowSurface(window, desired_format, flags); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
313 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
314 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
315 SDL_Surface * |
| 1670 | 316 SDL_CreateWindowSurface(SDL_WindowID windowID, Uint32 format, Uint32 flags) |
| 317 { | |
| 318 SDL_Window *window = SDL_GetWindowFromID(windowID); | |
| 319 Uint32 black; | |
| 320 SDL_Surface *surface; | |
| 321 | |
| 322 if (!window) { | |
| 323 return NULL; | |
| 324 } | |
| 325 | |
| 326 if (!_this->CreateWindowSurface) { | |
| 327 return NULL; | |
| 328 } | |
| 329 | |
| 330 if (!window->surface) { | |
| 331 _this->CreateWindowSurface(_this, window, flags); | |
| 332 if (!window->surface) { | |
| 333 return NULL; | |
| 334 } | |
| 335 window->surface->flags |= SDL_SCREEN_SURFACE; | |
| 336 | |
| 337 /* If we have a palettized surface, create a default palette */ | |
| 338 if (window->surface->format->palette) { | |
| 339 SDL_Color colors[256]; | |
| 340 SDL_PixelFormat *vf = window->surface->format; | |
| 341 SDL_DitherColors(colors, vf->BitsPerPixel); | |
| 342 SDL_SetColors(window->surface, colors, 0, vf->palette->ncolors); | |
| 343 } | |
| 344 } | |
| 345 surface = window->surface; | |
| 346 | |
| 347 if (window->shadow) { | |
| 348 SDL_FreeSurface(window->shadow); | |
| 349 window->shadow = NULL; | |
| 350 } | |
| 351 | |
| 352 /* Create a shadow surface if necessary */ | |
| 353 if ((!(flags & SDL_ANYFORMAT) | |
| 354 && (format != SDL_GetCurrentDisplayMode()->format)) | |
| 355 || ((flags & SDL_HWPALETTE) | |
| 356 && !(window->surface->flags & SDL_HWPALETTE))) { | |
| 357 int bpp; | |
| 358 Uint32 Rmask, Gmask, Bmask, Amask; | |
| 359 | |
| 360 SDL_PixelFormatEnumToMasks(format, &bpp, &Amask, &Gmask, &Bmask, | |
| 361 &Amask); | |
| 362 window->shadow = | |
| 363 SDL_CreateRGBSurface(SDL_SWSURFACE, surface->w, surface->h, bpp, | |
| 364 Rmask, Gmask, Bmask, Amask); | |
| 365 if (window->shadow == NULL) { | |
| 366 return NULL; | |
| 367 } | |
| 368 window->shadow->flags |= SDL_SHADOW_SURFACE; | |
| 369 | |
| 370 surface = window->shadow; | |
| 371 | |
| 372 /* 8-bit shadow surfaces report that they have exclusive palette */ | |
| 373 if (surface->format->palette) { | |
| 374 surface->flags |= SDL_HWPALETTE; | |
| 375 if (format == SDL_GetCurrentDisplayMode()->format) { | |
| 376 SDL_memcpy(surface->format->palette->colors, | |
| 377 window->surface->format->palette->colors, | |
| 378 window->surface->format->palette->ncolors * | |
| 379 sizeof(SDL_Color)); | |
| 380 } else { | |
| 381 SDL_DitherColors(surface->format->palette->colors, bpp); | |
| 382 } | |
| 383 } | |
| 384 } | |
| 385 | |
| 386 /* Clear the surface for display */ | |
| 387 { | |
| 388 Uint32 black = SDL_MapRGB(surface->format, 0, 0, 0); | |
| 389 SDL_FillRect(surface, NULL, black); | |
| 390 if (surface->flags & SDL_DOUBLEBUF) { | |
| 391 SDL_Flip(surface); | |
| 392 SDL_FillRect(surface, NULL, black); | |
| 393 } | |
| 394 SDL_Flip(surface); | |
| 395 } | |
| 396 | |
| 397 return surface; | |
| 398 } | |
| 399 | |
| 400 SDL_Surface * | |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
401 SDL_GetVideoSurface(void) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
402 { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
403 SDL_VideoDevice *_this = SDL_GetVideoDevice(); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
404 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
405 return SDL_VideoSurface; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
406 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
407 |
| 1670 | 408 SDL_Surface * |
| 409 SDL_DisplayFormat(SDL_Surface * surface) | |
| 410 { | |
| 411 Uint32 flags; | |
| 412 | |
| 413 if (!SDL_PublicSurface) { | |
| 414 SDL_SetError("No video mode has been set"); | |
| 415 return (NULL); | |
| 416 } | |
| 417 /* Set the flags appropriate for copying to display surface */ | |
| 418 if (((SDL_PublicSurface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) | |
| 419 && _this->info.blit_hw) | |
| 420 flags = SDL_HWSURFACE; | |
| 421 else | |
| 422 flags = SDL_SWSURFACE; | |
| 423 #ifdef AUTORLE_DISPLAYFORMAT | |
| 424 flags |= (surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA)); | |
| 425 flags |= SDL_RLEACCELOK; | |
| 426 #else | |
| 427 flags |= | |
| 428 surface->flags & (SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCELOK); | |
| 429 #endif | |
| 430 return (SDL_ConvertSurface(surface, SDL_PublicSurface->format, flags)); | |
| 431 } | |
| 432 | |
| 433 SDL_Surface * | |
| 434 SDL_DisplayFormatAlpha(SDL_Surface * surface) | |
| 435 { | |
| 436 SDL_PixelFormat *vf; | |
| 437 SDL_PixelFormat *format; | |
| 438 SDL_Surface *converted; | |
| 439 Uint32 flags; | |
| 440 /* default to ARGB8888 */ | |
| 441 Uint32 amask = 0xff000000; | |
| 442 Uint32 rmask = 0x00ff0000; | |
| 443 Uint32 gmask = 0x0000ff00; | |
| 444 Uint32 bmask = 0x000000ff; | |
| 445 | |
| 446 if (!SDL_PublicSurface) { | |
| 447 SDL_SetError("No video mode has been set"); | |
| 448 return (NULL); | |
| 449 } | |
| 450 vf = SDL_PublicSurface->format; | |
| 451 | |
| 452 switch (vf->BytesPerPixel) { | |
| 453 case 2: | |
| 454 /* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}. | |
| 455 For anything else (like ARGB4444) it doesn't matter | |
| 456 since we have no special code for it anyway */ | |
| 457 if ((vf->Rmask == 0x1f) && | |
| 458 (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) { | |
| 459 rmask = 0xff; | |
| 460 bmask = 0xff0000; | |
| 461 } | |
| 462 break; | |
| 463 | |
| 464 case 3: | |
| 465 case 4: | |
| 466 /* Keep the video format, as long as the high 8 bits are | |
| 467 unused or alpha */ | |
| 468 if ((vf->Rmask == 0xff) && (vf->Bmask == 0xff0000)) { | |
| 469 rmask = 0xff; | |
| 470 bmask = 0xff0000; | |
| 471 } | |
| 472 break; | |
| 473 | |
| 474 default: | |
| 475 /* We have no other optimised formats right now. When/if a new | |
| 476 optimised alpha format is written, add the converter here */ | |
| 477 break; | |
| 478 } | |
| 479 format = SDL_AllocFormat(32, rmask, gmask, bmask, amask); | |
| 480 flags = SDL_PublicSurface->flags & SDL_HWSURFACE; | |
| 481 flags |= surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK); | |
| 482 converted = SDL_ConvertSurface(surface, format, flags); | |
| 483 SDL_FreeFormat(format); | |
| 484 return (converted); | |
| 485 } | |
| 486 | |
| 487 void | |
| 488 SDL_UpdateRect(SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h) | |
| 489 { | |
| 490 if (screen) { | |
| 491 SDL_Rect rect; | |
| 492 | |
| 493 /* Perform some checking */ | |
| 494 if (w == 0) | |
| 495 w = screen->w; | |
| 496 if (h == 0) | |
| 497 h = screen->h; | |
| 498 if ((int) (x + w) > screen->w) | |
| 499 return; | |
| 500 if ((int) (y + h) > screen->h) | |
| 501 return; | |
| 502 | |
| 503 /* Fill the rectangle */ | |
| 504 rect.x = (Sint16) x; | |
| 505 rect.y = (Sint16) y; | |
| 506 rect.w = (Uint16) w; | |
| 507 rect.h = (Uint16) h; | |
| 508 SDL_UpdateRects(screen, 1, &rect); | |
| 509 } | |
| 510 } | |
| 511 void | |
| 512 SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects) | |
| 513 { | |
| 514 int i; | |
| 515 SDL_Window *window; | |
| 516 | |
| 517 /* Find the window corresponding to this surface */ | |
| 518 window = SDL_GetWindowFromSurface(screen); | |
| 519 if (!window) { | |
| 520 SDL_SetError("Couldn't find window associated with surface"); | |
| 521 return; | |
| 522 } | |
| 523 | |
| 524 if (screen->flags & SDL_SHADOW_SURFACE) { | |
| 525 if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { | |
| 526 SDL_LockCursor(); | |
| 527 SDL_DrawCursor(screen); | |
| 528 for (i = 0; i < numrects; ++i) { | |
| 529 SDL_LowerBlit(screen, &rects[i], window->surface, &rects[i]); | |
| 530 } | |
| 531 SDL_EraseCursor(screen); | |
| 532 SDL_UnlockCursor(); | |
| 533 } else { | |
| 534 for (i = 0; i < numrects; ++i) { | |
| 535 SDL_LowerBlit(screen, &rects[i], window->surface, &rects[i]); | |
| 536 } | |
| 537 } | |
| 538 | |
| 539 /* Fall through to video surface update */ | |
| 540 screen = window->surface; | |
| 541 } | |
| 542 if ((screen->flags & SDL_SCREEN_SURFACE) && _this->UpdateWindowSurface) { | |
| 543 /* Update the video surface */ | |
| 544 if (screen->offset) { | |
| 545 int offset_y = screen->offset / screen->pitch; | |
| 546 int offset_x = screen->offset % screen->pitch; | |
| 547 for (i = 0; i < numrects; ++i) { | |
| 548 rects[i].x += offset_x; | |
| 549 rects[i].y += offset_y; | |
| 550 } | |
| 551 _this->UpdateWindowSurface(_this, window, numrects, rects); | |
| 552 for (i = 0; i < numrects; ++i) { | |
| 553 rects[i].x -= offset_x; | |
| 554 rects[i].y -= offset_y; | |
| 555 } | |
| 556 } else { | |
| 557 _this->UpdateWindowSurface(_this, window, numrects, rects); | |
| 558 } | |
| 559 } | |
| 560 } | |
| 561 | |
| 562 int | |
| 563 SDL_Flip(SDL_Surface * screen) | |
| 564 { | |
| 565 SDL_Window *window; | |
| 566 | |
| 567 /* Find the window corresponding to this surface */ | |
| 568 window = SDL_GetWindowFromSurface(screen); | |
| 569 if (!window) { | |
| 570 SDL_SetError("Couldn't find window associated with surface"); | |
| 571 return; | |
| 572 } | |
| 573 | |
| 574 /* Copy the shadow surface to the video surface */ | |
| 575 if (screen->flags & SDL_SHADOW_SURFACE) { | |
| 576 SDL_Rect rect; | |
| 577 | |
| 578 rect.x = 0; | |
| 579 rect.y = 0; | |
| 580 rect.w = screen->w; | |
| 581 rect.h = screen->h; | |
| 582 if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { | |
| 583 SDL_LockCursor(); | |
| 584 SDL_DrawCursor(screen); | |
| 585 SDL_LowerBlit(screen, &rect, window->surface, &rect); | |
| 586 SDL_EraseCursor(screen); | |
| 587 SDL_UnlockCursor(); | |
| 588 } else { | |
| 589 SDL_LowerBlit(screen, &rect, window->surface, &rect); | |
| 590 } | |
| 591 | |
| 592 /* Fall through to video surface update */ | |
| 593 screen = window->surface; | |
| 594 } | |
| 595 if (screen->flags & SDL_DOUBLEBUF) { | |
| 596 _this->FlipWindowSurface(_this, window); | |
| 597 } else { | |
| 598 SDL_UpdateRect(screen, 0, 0, 0, 0); | |
| 599 } | |
| 600 return (0); | |
| 601 } | |
| 602 | |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
603 void |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
604 SDL_WM_SetCaption(const char *title, const char *icon) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
605 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
606 if (wm_title) { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
607 SDL_free(wm_title); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
608 } else { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
609 wm_title = SDL_strdup(title); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
610 } |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
611 SDL_SetWindowTitle(window, wm_title); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
612 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
613 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
614 void |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
615 SDL_WM_GetCaption(char **title, char **icon) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
616 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
617 if (title) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
618 *title = wm_title; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
619 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
620 if (icon) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
621 *icon = ""; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
622 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
623 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
624 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
625 void |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
626 SDL_WM_SetIcon(SDL_Surface * icon, Uint8 * mask) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
627 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
628 /* FIXME */ |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
629 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
630 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
631 int |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
632 SDL_WM_IconifyWindow(void) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
633 { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
634 SDL_MinimizeWindow(window); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
635 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
636 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
637 int |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
638 SDL_WM_ToggleFullScreen(SDL_Surface * surface) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
639 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
640 return 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
641 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
642 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
643 SDL_GrabMode |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
644 SDL_WM_GrabInput(SDL_GrabMode mode) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
645 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
646 if (mode != SDL_GRAB_QUERY) { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
647 SDL_SetWindowGrab(window, mode); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
648 } |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
649 return (SDL_GrabMode) SDL_GetWindowGrab(window); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
650 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
651 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
652 Uint8 |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
653 SDL_GetAppState(void) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
654 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
655 Uint8 state = 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
656 Uint32 flags = 0; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
657 |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
658 flags = SDL_GetWindowFlags(window); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
659 if ((flags & SDL_WINDOW_SHOWN) && !(flags & SDL_WINDOW_MINIMIZED)) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
660 state |= SDL_APPACTIVE; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
661 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
662 if (flags & SDL_WINDOW_KEYBOARD_FOCUS) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
663 state |= SDL_APPINPUTFOCUS; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
664 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
665 if (flags & SDL_WINDOW_MOUSE_FOCUS) { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
666 state |= SDL_APPMOUSEFOCUS; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
667 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
668 return state; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
669 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
670 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
671 const SDL_version * |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
672 SDL_Linked_Version(void) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
673 { |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
674 static SDL_version version; |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
675 SDL_VERSION(&version); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
676 return &version; |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
677 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
678 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
679 int |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
680 SDL_SetPalette(SDL_Surface * surface, int flags, SDL_Color * colors, |
|
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
681 int firstcolor, int ncolors) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
682 { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
683 SDL_SetColors(surface, colors, firstcolor, ncolors); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
684 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
685 |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
686 int |
| 1670 | 687 SDL_SetScreenColors(SDL_Surface * screen, SDL_Color * colors, int firstcolor, |
| 688 int ncolors) | |
| 689 { | |
| 690 SDL_Window *window = NULL; | |
| 691 SDL_Palette *pal; | |
| 692 int gotall; | |
| 693 int palsize; | |
| 694 | |
| 695 /* Verify the parameters */ | |
| 696 pal = screen->format->palette; | |
| 697 if (!pal) { | |
| 698 return 0; /* not a palettized surface */ | |
| 699 } | |
| 700 gotall = 1; | |
| 701 palsize = 1 << screen->format->BitsPerPixel; | |
| 702 if (ncolors > (palsize - firstcolor)) { | |
| 703 ncolors = (palsize - firstcolor); | |
| 704 gotall = 0; | |
| 705 } | |
| 706 | |
| 707 if (screen->flags & (SDL_SHADOW_SURFACE | SDL_SCREEN_SURFACE)) { | |
| 708 window = SDL_GetWindowFromSurface(screen); | |
| 709 if (!window) { | |
| 710 return 0; | |
| 711 } | |
| 712 } | |
| 713 | |
| 714 if (screen->flags & SDL_SHADOW_SURFACE) { | |
| 715 SDL_Palette *vidpal; | |
| 716 | |
| 717 vidpal = window->surface->format->palette; | |
| 718 if (vidpal && vidpal->ncolors == pal->ncolors) { | |
| 719 /* This is a shadow surface, and the physical | |
| 720 * framebuffer is also indexed. Propagate the | |
| 721 * changes to its logical palette so that | |
| 722 * updates are always identity blits | |
| 723 */ | |
| 724 SDL_memcpy(vidpal->colors + firstcolor, colors, | |
| 725 ncolors * sizeof(*colors)); | |
| 726 } | |
| 727 if (window->surface->flags & SDL_HWPALETTE) { | |
| 728 /* Set the physical palette */ | |
| 729 screen = window->surface; | |
| 730 } else { | |
| 731 SDL_UpdateRect(screen, 0, 0, 0, 0); | |
| 732 } | |
| 733 } | |
| 734 | |
| 735 if (screen->flags & SDL_SCREEN_SURFACE) { | |
| 736 if (_this->SetWindowColors) { | |
| 737 gotall = | |
| 738 _this->SetWindowColors(_this, window, firstcolor, ncolors, | |
| 739 colors); | |
| 740 if (!gotall) { | |
| 741 /* The video flags shouldn't have SDL_HWPALETTE, and | |
| 742 the video driver is responsible for copying back the | |
| 743 correct colors into the video surface palette. | |
| 744 */ | |
| 745 ; | |
| 746 } | |
| 747 } | |
| 748 SDL_CursorPaletteChanged(); | |
| 749 } | |
| 750 | |
| 751 return gotall; | |
| 752 } | |
| 753 | |
| 754 int | |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
755 SDL_GetWMInfo(SDL_SysWMinfo * info) |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
756 { |
|
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset
|
757 return SDL_GetWindowWMInfo(window, info); |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
758 } |
|
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
759 |
| 1670 | 760 void |
| 761 SDL_MoveCursor(int x, int y) | |
| 762 { | |
| 763 SDL_VideoDevice *_this = SDL_GetVideoDevice(); | |
| 764 | |
| 765 /* Erase and update the current mouse position */ | |
| 766 if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { | |
| 767 /* Erase and redraw mouse cursor in new position */ | |
| 768 SDL_LockCursor(); | |
| 769 SDL_EraseCursor(SDL_VideoSurface); | |
| 770 SDL_cursor->area.x = (x - SDL_cursor->hot_x); | |
| 771 SDL_cursor->area.y = (y - SDL_cursor->hot_y); | |
| 772 SDL_DrawCursor(SDL_VideoSurface); | |
| 773 SDL_UnlockCursor(); | |
| 774 } else if (_this->MoveWMCursor) { | |
| 775 _this->MoveWMCursor(_this, x, y); | |
| 776 } | |
| 777 } | |
| 778 | |
| 779 /* Keep track of the current cursor colors */ | |
| 780 static int palette_changed = 1; | |
| 781 static Uint8 pixels8[2]; | |
| 782 | |
| 783 void | |
| 784 SDL_CursorPaletteChanged(void) | |
| 785 { | |
| 786 palette_changed = 1; | |
| 787 } | |
| 788 | |
| 789 void | |
| 790 SDL_MouseRect(SDL_Rect * area) | |
| 791 { | |
| 792 SDL_VideoDevice *_this = SDL_GetVideoDevice(); | |
| 793 int clip_diff; | |
| 794 | |
| 795 *area = SDL_cursor->area; | |
| 796 if (area->x < 0) { | |
| 797 area->w += area->x; | |
| 798 area->x = 0; | |
| 799 } | |
| 800 if (area->y < 0) { | |
| 801 area->h += area->y; | |
| 802 area->y = 0; | |
| 803 } | |
| 804 clip_diff = (area->x + area->w) - SDL_VideoSurface->w; | |
| 805 if (clip_diff > 0) { | |
| 806 area->w = area->w < clip_diff ? 0 : area->w - clip_diff; | |
| 807 } | |
| 808 clip_diff = (area->y + area->h) - SDL_VideoSurface->h; | |
| 809 if (clip_diff > 0) { | |
| 810 area->h = area->h < clip_diff ? 0 : area->h - clip_diff; | |
| 811 } | |
| 812 } | |
| 813 | |
| 814 static void | |
| 815 SDL_DrawCursorFast(SDL_Surface * screen, SDL_Rect * area) | |
| 816 { | |
| 817 const Uint32 pixels[2] = { 0xFFFFFFFF, 0x00000000 }; | |
| 818 int i, w, h; | |
| 819 Uint8 *data, datab; | |
| 820 Uint8 *mask, maskb; | |
| 821 | |
| 822 data = SDL_cursor->data + area->y * SDL_cursor->area.w / 8; | |
| 823 mask = SDL_cursor->mask + area->y * SDL_cursor->area.w / 8; | |
| 824 switch (screen->format->BytesPerPixel) { | |
| 825 | |
| 826 case 1: | |
| 827 { | |
| 828 Uint8 *dst; | |
| 829 int dstskip; | |
| 830 | |
| 831 if (palette_changed) { | |
| 832 pixels8[0] = | |
| 833 (Uint8) SDL_MapRGB(screen->format, 255, 255, 255); | |
| 834 pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0); | |
| 835 palette_changed = 0; | |
| 836 } | |
| 837 dst = (Uint8 *) screen->pixels + | |
| 838 (SDL_cursor->area.y + area->y) * screen->pitch + | |
| 839 SDL_cursor->area.x; | |
| 840 dstskip = screen->pitch - area->w; | |
| 841 | |
| 842 for (h = area->h; h; h--) { | |
| 843 for (w = area->w / 8; w; w--) { | |
| 844 maskb = *mask++; | |
| 845 datab = *data++; | |
| 846 for (i = 0; i < 8; ++i) { | |
| 847 if (maskb & 0x80) { | |
| 848 *dst = pixels8[datab >> 7]; | |
| 849 } | |
| 850 maskb <<= 1; | |
| 851 datab <<= 1; | |
| 852 dst++; | |
| 853 } | |
| 854 } | |
| 855 dst += dstskip; | |
| 856 } | |
| 857 } | |
| 858 break; | |
| 859 | |
| 860 case 2: | |
| 861 { | |
| 862 Uint16 *dst; | |
| 863 int dstskip; | |
| 864 | |
| 865 dst = (Uint16 *) screen->pixels + | |
| 866 (SDL_cursor->area.y + area->y) * screen->pitch / 2 + | |
| 867 SDL_cursor->area.x; | |
| 868 dstskip = (screen->pitch / 2) - area->w; | |
| 869 | |
| 870 for (h = area->h; h; h--) { | |
| 871 for (w = area->w / 8; w; w--) { | |
| 872 maskb = *mask++; | |
| 873 datab = *data++; | |
| 874 for (i = 0; i < 8; ++i) { | |
| 875 if (maskb & 0x80) { | |
| 876 *dst = (Uint16) pixels[datab >> 7]; | |
| 877 } | |
| 878 maskb <<= 1; | |
| 879 datab <<= 1; | |
| 880 dst++; | |
| 881 } | |
| 882 } | |
| 883 dst += dstskip; | |
| 884 } | |
| 885 } | |
| 886 break; | |
| 887 | |
| 888 case 3: | |
| 889 { | |
| 890 Uint8 *dst; | |
| 891 int dstskip; | |
| 892 | |
| 893 dst = (Uint8 *) screen->pixels + | |
| 894 (SDL_cursor->area.y + area->y) * screen->pitch + | |
| 895 SDL_cursor->area.x * 3; | |
| 896 dstskip = screen->pitch - area->w * 3; | |
| 897 | |
| 898 for (h = area->h; h; h--) { | |
| 899 for (w = area->w / 8; w; w--) { | |
| 900 maskb = *mask++; | |
| 901 datab = *data++; | |
| 902 for (i = 0; i < 8; ++i) { | |
| 903 if (maskb & 0x80) { | |
| 904 SDL_memset(dst, pixels[datab >> 7], 3); | |
| 905 } | |
| 906 maskb <<= 1; | |
| 907 datab <<= 1; | |
| 908 dst += 3; | |
| 909 } | |
| 910 } | |
| 911 dst += dstskip; | |
| 912 } | |
| 913 } | |
| 914 break; | |
| 915 | |
| 916 case 4: | |
| 917 { | |
| 918 Uint32 *dst; | |
| 919 int dstskip; | |
| 920 | |
| 921 dst = (Uint32 *) screen->pixels + | |
| 922 (SDL_cursor->area.y + area->y) * screen->pitch / 4 + | |
| 923 SDL_cursor->area.x; | |
| 924 dstskip = (screen->pitch / 4) - area->w; | |
| 925 | |
| 926 for (h = area->h; h; h--) { | |
| 927 for (w = area->w / 8; w; w--) { | |
| 928 maskb = *mask++; | |
| 929 datab = *data++; | |
| 930 for (i = 0; i < 8; ++i) { | |
| 931 if (maskb & 0x80) { | |
| 932 *dst = pixels[datab >> 7]; | |
| 933 } | |
| 934 maskb <<= 1; | |
| 935 datab <<= 1; | |
| 936 dst++; | |
| 937 } | |
| 938 } | |
| 939 dst += dstskip; | |
| 940 } | |
| 941 } | |
| 942 break; | |
| 943 } | |
| 944 } | |
| 945 | |
| 946 static void | |
| 947 SDL_DrawCursorSlow(SDL_Surface * screen, SDL_Rect * area) | |
| 948 { | |
| 949 const Uint32 pixels[2] = { 0xFFFFFF, 0x000000 }; | |
| 950 int h; | |
| 951 int x, minx, maxx; | |
| 952 Uint8 *data, datab = 0; | |
| 953 Uint8 *mask, maskb = 0; | |
| 954 Uint8 *dst; | |
| 955 int dstbpp, dstskip; | |
| 956 | |
| 957 data = SDL_cursor->data + area->y * SDL_cursor->area.w / 8; | |
| 958 mask = SDL_cursor->mask + area->y * SDL_cursor->area.w / 8; | |
| 959 dstbpp = screen->format->BytesPerPixel; | |
| 960 dst = (Uint8 *) screen->pixels + | |
| 961 (SDL_cursor->area.y + area->y) * screen->pitch + | |
| 962 SDL_cursor->area.x * dstbpp; | |
| 963 dstskip = screen->pitch - SDL_cursor->area.w * dstbpp; | |
| 964 | |
| 965 minx = area->x; | |
| 966 maxx = area->x + area->w; | |
| 967 if (screen->format->BytesPerPixel == 1) { | |
| 968 if (palette_changed) { | |
| 969 pixels8[0] = (Uint8) SDL_MapRGB(screen->format, 255, 255, 255); | |
| 970 pixels8[1] = (Uint8) SDL_MapRGB(screen->format, 0, 0, 0); | |
| 971 palette_changed = 0; | |
| 972 } | |
| 973 for (h = area->h; h; h--) { | |
| 974 for (x = 0; x < SDL_cursor->area.w; ++x) { | |
| 975 if ((x % 8) == 0) { | |
| 976 maskb = *mask++; | |
| 977 datab = *data++; | |
| 978 } | |
| 979 if ((x >= minx) && (x < maxx)) { | |
| 980 if (maskb & 0x80) { | |
| 981 SDL_memset(dst, pixels8[datab >> 7], dstbpp); | |
| 982 } | |
| 983 } | |
| 984 maskb <<= 1; | |
| 985 datab <<= 1; | |
| 986 dst += dstbpp; | |
| 987 } | |
| 988 dst += dstskip; | |
| 989 } | |
| 990 } else { | |
| 991 for (h = area->h; h; h--) { | |
| 992 for (x = 0; x < SDL_cursor->area.w; ++x) { | |
| 993 if ((x % 8) == 0) { | |
| 994 maskb = *mask++; | |
| 995 datab = *data++; | |
| 996 } | |
| 997 if ((x >= minx) && (x < maxx)) { | |
| 998 if (maskb & 0x80) { | |
| 999 SDL_memset(dst, pixels[datab >> 7], dstbpp); | |
| 1000 } | |
| 1001 } | |
| 1002 maskb <<= 1; | |
| 1003 datab <<= 1; | |
| 1004 dst += dstbpp; | |
| 1005 } | |
| 1006 dst += dstskip; | |
| 1007 } | |
| 1008 } | |
| 1009 } | |
| 1010 | |
| 1011 /* This handles the ugly work of converting the saved cursor background from | |
| 1012 the pixel format of the shadow surface to that of the video surface. | |
| 1013 This is only necessary when blitting from a shadow surface of a different | |
| 1014 pixel format than the video surface, and using a software rendered cursor. | |
| 1015 */ | |
| 1016 static void | |
| 1017 SDL_ConvertCursorSave(SDL_Surface * screen, int w, int h) | |
| 1018 { | |
| 1019 SDL_VideoDevice *_this = SDL_GetVideoDevice(); | |
| 1020 SDL_BlitInfo info; | |
| 1021 SDL_loblit RunBlit; | |
| 1022 | |
| 1023 /* Make sure we can steal the blit mapping */ | |
| 1024 if (screen->map->dst != SDL_VideoSurface) { | |
| 1025 return; | |
| 1026 } | |
| 1027 | |
| 1028 /* Set up the blit information */ | |
| 1029 info.s_pixels = SDL_cursor->save[1]; | |
| 1030 info.s_width = w; | |
| 1031 info.s_height = h; | |
| 1032 info.s_skip = 0; | |
| 1033 info.d_pixels = SDL_cursor->save[0]; | |
| 1034 info.d_width = w; | |
| 1035 info.d_height = h; | |
| 1036 info.d_skip = 0; | |
| 1037 info.aux_data = screen->map->sw_data->aux_data; | |
| 1038 info.src = screen->format; | |
| 1039 info.table = screen->map->table; | |
| 1040 info.dst = SDL_VideoSurface->format; | |
| 1041 RunBlit = screen->map->sw_data->blit; | |
| 1042 | |
| 1043 /* Run the actual software blit */ | |
| 1044 RunBlit(&info); | |
| 1045 } | |
| 1046 | |
| 1047 void | |
| 1048 SDL_DrawCursorNoLock(SDL_Surface * screen) | |
| 1049 { | |
| 1050 SDL_VideoDevice *_this = SDL_GetVideoDevice(); | |
| 1051 SDL_Rect area; | |
| 1052 | |
| 1053 /* Get the mouse rectangle, clipped to the screen */ | |
| 1054 SDL_MouseRect(&area); | |
| 1055 if ((area.w == 0) || (area.h == 0)) { | |
| 1056 return; | |
| 1057 } | |
| 1058 | |
| 1059 /* Copy mouse background */ | |
| 1060 { | |
| 1061 int w, h, screenbpp; | |
| 1062 Uint8 *src, *dst; | |
| 1063 | |
| 1064 /* Set up the copy pointers */ | |
| 1065 screenbpp = screen->format->BytesPerPixel; | |
| 1066 if ((screen == SDL_VideoSurface) || | |
| 1067 FORMAT_EQUAL(screen->format, SDL_VideoSurface->format)) { | |
| 1068 dst = SDL_cursor->save[0]; | |
| 1069 } else { | |
| 1070 dst = SDL_cursor->save[1]; | |
| 1071 } | |
| 1072 src = (Uint8 *) screen->pixels + area.y * screen->pitch + | |
| 1073 area.x * screenbpp; | |
| 1074 | |
| 1075 /* Perform the copy */ | |
| 1076 w = area.w * screenbpp; | |
| 1077 h = area.h; | |
| 1078 while (h--) { | |
| 1079 SDL_memcpy(dst, src, w); | |
| 1080 dst += w; | |
| 1081 src += screen->pitch; | |
| 1082 } | |
| 1083 } | |
| 1084 | |
| 1085 /* Draw the mouse cursor */ | |
| 1086 area.x -= SDL_cursor->area.x; | |
| 1087 area.y -= SDL_cursor->area.y; | |
| 1088 if ((area.x == 0) && (area.w == SDL_cursor->area.w)) { | |
| 1089 SDL_DrawCursorFast(screen, &area); | |
| 1090 } else { | |
| 1091 SDL_DrawCursorSlow(screen, &area); | |
| 1092 } | |
| 1093 } | |
| 1094 | |
| 1095 void | |
| 1096 SDL_DrawCursor(SDL_Surface * screen) | |
| 1097 { | |
| 1098 /* Lock the screen if necessary */ | |
| 1099 if (screen == NULL) { | |
| 1100 return; | |
| 1101 } | |
| 1102 if (SDL_MUSTLOCK(screen)) { | |
| 1103 if (SDL_LockSurface(screen) < 0) { | |
| 1104 return; | |
| 1105 } | |
| 1106 } | |
| 1107 | |
| 1108 SDL_DrawCursorNoLock(screen); | |
| 1109 | |
| 1110 /* Unlock the screen and update if necessary */ | |
| 1111 if (SDL_MUSTLOCK(screen)) { | |
| 1112 SDL_UnlockSurface(screen); | |
| 1113 } | |
| 1114 if ((screen->flags & SDL_SCREEN_SURFACE) && | |
| 1115 !(screen->flags & SDL_HWSURFACE)) { | |
| 1116 SDL_VideoDevice *_this = SDL_GetVideoDevice(); | |
| 1117 SDL_Window *window; | |
| 1118 SDL_Rect area; | |
| 1119 | |
| 1120 window = SDL_GetWindowFromSurface(screen); | |
| 1121 if (!window) { | |
| 1122 return; | |
| 1123 } | |
| 1124 | |
| 1125 SDL_MouseRect(&area); | |
| 1126 | |
| 1127 if (_this->UpdateWindowSurface) { | |
| 1128 _this->UpdateWindowSurface(_this, window, 1, &area); | |
| 1129 } | |
| 1130 } | |
| 1131 } | |
| 1132 | |
| 1133 void | |
| 1134 SDL_EraseCursorNoLock(SDL_Surface * screen) | |
| 1135 { | |
| 1136 SDL_VideoDevice *_this = SDL_GetVideoDevice(); | |
| 1137 SDL_Window *window; | |
| 1138 SDL_Rect area; | |
| 1139 | |
| 1140 /* Get the window associated with the surface */ | |
| 1141 window = SDL_GetWindowFromSurface(screen); | |
| 1142 if (!window || !window->surface) { | |
| 1143 return; | |
| 1144 } | |
| 1145 | |
| 1146 /* Get the mouse rectangle, clipped to the screen */ | |
| 1147 SDL_MouseRect(&area); | |
| 1148 if ((area.w == 0) || (area.h == 0)) { | |
| 1149 return; | |
| 1150 } | |
| 1151 | |
| 1152 /* Copy mouse background */ | |
| 1153 { | |
| 1154 int w, h, screenbpp; | |
| 1155 Uint8 *src, *dst; | |
| 1156 | |
| 1157 /* Set up the copy pointers */ | |
| 1158 screenbpp = screen->format->BytesPerPixel; | |
| 1159 if ((screen->flags & SDL_SCREEN_SURFACE) || | |
| 1160 FORMAT_EQUAL(screen->format, window->surface->format)) { | |
| 1161 src = SDL_cursor->save[0]; | |
| 1162 } else { | |
| 1163 src = SDL_cursor->save[1]; | |
| 1164 } | |
| 1165 dst = (Uint8 *) screen->pixels + area.y * screen->pitch + | |
| 1166 area.x * screenbpp; | |
| 1167 | |
| 1168 /* Perform the copy */ | |
| 1169 w = area.w * screenbpp; | |
| 1170 h = area.h; | |
| 1171 while (h--) { | |
| 1172 SDL_memcpy(dst, src, w); | |
| 1173 src += w; | |
| 1174 dst += screen->pitch; | |
| 1175 } | |
| 1176 | |
| 1177 /* Perform pixel conversion on cursor background */ | |
| 1178 if (src > SDL_cursor->save[1]) { | |
| 1179 SDL_ConvertCursorSave(screen, area.w, area.h); | |
| 1180 } | |
| 1181 } | |
| 1182 } | |
| 1183 | |
| 1184 void | |
| 1185 SDL_EraseCursor(SDL_Surface * screen) | |
| 1186 { | |
| 1187 /* Lock the screen if necessary */ | |
| 1188 if (screen == NULL) { | |
| 1189 return; | |
| 1190 } | |
| 1191 if (SDL_MUSTLOCK(screen)) { | |
| 1192 if (SDL_LockSurface(screen) < 0) { | |
| 1193 return; | |
| 1194 } | |
| 1195 } | |
| 1196 | |
| 1197 SDL_EraseCursorNoLock(screen); | |
| 1198 | |
| 1199 /* Unlock the screen and update if necessary */ | |
| 1200 if (SDL_MUSTLOCK(screen)) { | |
| 1201 SDL_UnlockSurface(screen); | |
| 1202 } | |
| 1203 if ((screen->flags & SDL_SCREEN_SURFACE) && | |
| 1204 !(screen->flags & SDL_HWSURFACE)) { | |
| 1205 SDL_VideoDevice *_this = SDL_GetVideoDevice(); | |
| 1206 SDL_Window *window; | |
| 1207 SDL_Rect area; | |
| 1208 | |
| 1209 window = SDL_GetWindowFromSurface(screen); | |
| 1210 if (!window) { | |
| 1211 return; | |
| 1212 } | |
| 1213 | |
| 1214 SDL_MouseRect(&area); | |
| 1215 | |
| 1216 if (_this->UpdateWindowSurface) { | |
| 1217 _this->UpdateWindowSurface(_this, window, 1, &area); | |
| 1218 } | |
| 1219 } | |
| 1220 } | |
| 1221 | |
| 1222 /* Reset the cursor on video mode change | |
| 1223 FIXME: Keep track of all cursors, and reset them all. | |
| 1224 */ | |
| 1225 void | |
| 1226 SDL_ResetCursor(void) | |
| 1227 { | |
| 1228 int savelen; | |
| 1229 | |
| 1230 if (SDL_cursor) { | |
| 1231 savelen = SDL_cursor->area.w * 4 * SDL_cursor->area.h; | |
| 1232 SDL_cursor->area.x = 0; | |
| 1233 SDL_cursor->area.y = 0; | |
| 1234 SDL_memset(SDL_cursor->save[0], 0, savelen); | |
| 1235 } | |
| 1236 } | |
| 1237 | |
|
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset
|
1238 /* vi: set ts=4 sw=4 expandtab: */ |