author  Sam Lantinga <slouken@libsdl.org> 
Wed, 14 Jun 2006 06:14:26 +0000  
branch  SDL1.3 
changeset 1678  90bf530ced8e 
parent 1675  d33dcfc3fde7 
child 1680  9488fca10677 
permissions  rwrr 
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) 19972006 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 021101301 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 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

28 
#include "video/SDL_pixels_c.h" 
1667
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 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

31 
static SDL_WindowID SDL_VideoWindow; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

32 
static SDL_TextureID SDL_VideoTexture; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

33 
static SDL_Surface *SDL_VideoSurface; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

34 
static SDL_Surface *SDL_ShadowSurface; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

35 
static SDL_Surface *SDL_PublicSurface; 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

36 
static char *wm_title; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

37 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

38 
char * 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

39 
SDL_AudioDriverName(char *namebuf, int maxlen) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

40 
{ 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

41 
const char *name = SDL_GetCurrentAudioDriver(); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

42 
if (name) { 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

43 
SDL_strlcpy(namebuf, name, maxlen); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

44 
return namebuf; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

45 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

46 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

47 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

48 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

49 
char * 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

50 
SDL_VideoDriverName(char *namebuf, int maxlen) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

51 
{ 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

52 
const char *name = SDL_GetCurrentVideoDriver(); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

53 
if (name) { 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

54 
SDL_strlcpy(namebuf, name, maxlen); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

55 
return namebuf; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

56 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

57 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

58 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

59 

1670  60 
const SDL_VideoInfo * 
61 
SDL_GetVideoInfo(void) 

62 
{ 

63 
static SDL_VideoInfo info; 

64 

65 
/* Memory leak, compatibility code, who cares? */ 

66 
if (!info.vfmt && SDL_GetDesktopDisplayMode()) { 

67 
int bpp; 

68 
Uint32 Rmask, Gmask, Bmask, Amask; 

69 

70 
SDL_PixelFormatEnumToMasks(SDL_GetDesktopDisplayMode()>format, &bpp, 

71 
&Rmask, &Gmask, &Bmask, &Amask); 

72 
info.vfmt = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); 

73 
} 

74 
return &info; 

75 
} 

76 

1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

77 
int 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

78 
SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

79 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

80 
int i, actual_bpp = 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

81 

1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

82 
if (!SDL_GetVideoDevice()) { 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

83 
return 0; 
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 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

86 
if (!(flags & SDL_FULLSCREEN)) { 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

87 
return SDL_BITSPERPIXEL(SDL_GetDesktopDisplayMode()>format); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

88 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

89 

1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

90 
for (i = 0; i < SDL_GetNumDisplayModes(); ++i) { 
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

91 
const SDL_DisplayMode *mode = SDL_GetDisplayMode(i); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

92 
if (!mode>w  !mode>h  (width == mode>w && height == mode>h)) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

93 
if (!mode>format) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

94 
return bpp; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

95 
} 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

96 
if (SDL_BITSPERPIXEL(mode>format) >= bpp) { 
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

97 
actual_bpp = SDL_BITSPERPIXEL(mode>format); 
1667
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 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

101 
return actual_bpp; 
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 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

104 
SDL_Rect ** 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

105 
SDL_ListModes(SDL_PixelFormat * format, Uint32 flags) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

106 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

107 
int i, nmodes; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

108 
SDL_Rect **modes; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

109 

1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

110 
if (!SDL_GetVideoDevice()) { 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

111 
return NULL; 
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 
if (!(flags & SDL_FULLSCREEN)) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

115 
return (SDL_Rect **) (1); 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

116 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

117 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

118 
/* Memory leak, but this is a compatibility function, who cares? */ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

119 
nmodes = 0; 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

120 
for (i = 0; i < SDL_GetNumDisplayModes(); ++i) { 
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

121 
const SDL_DisplayMode *mode = SDL_GetDisplayMode(i); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

122 
if (!mode>w  !mode>h) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

123 
return (SDL_Rect **) (1); 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

124 
} 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

125 
if (SDL_BITSPERPIXEL(mode>format) != format>BitsPerPixel) { 
1667
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 
if (nmodes > 0 && modes[nmodes  1]>w == mode>w 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

129 
&& modes[nmodes  1]>h == mode>h) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

130 
continue; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

131 
} 
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 = SDL_realloc(modes, (nmodes + 2) * sizeof(*modes)); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

134 
if (!modes) { 
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 
} 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

137 
modes[nmodes] = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect)); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

138 
if (!modes[nmodes]) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

139 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

140 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

141 
modes[nmodes]>x = 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

142 
modes[nmodes]>y = 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

143 
modes[nmodes]>w = mode>w; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

144 
modes[nmodes]>h = mode>h; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

145 
++nmodes; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

146 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

147 
if (modes) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

148 
modes[nmodes] = NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

149 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

150 
return modes; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

151 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

152 

1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

153 
static int (*orig_eventfilter) (const SDL_Event * event); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

154 

9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

155 
static int 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

156 
SDL_CompatEventFilter(const SDL_Event * event) 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

157 
{ 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

158 
SDL_Event fake; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

159 

9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

160 
switch (event>type) { 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

161 
case SDL_WINDOWEVENT: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

162 
switch (event>window.event) { 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

163 
case SDL_WINDOWEVENT_RESIZED: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

164 
fake.type = SDL_VIDEORESIZE; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

165 
fake.resize.w = event>window.data1; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

166 
fake.resize.h = event>window.data2; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

167 
SDL_PushEvent(&fake); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

168 
break; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

169 
case SDL_WINDOWEVENT_MINIMIZED: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

170 
fake.type = SDL_ACTIVEEVENT; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

171 
fake.active.gain = 0; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

172 
fake.active.state = SDL_APPACTIVE; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

173 
SDL_PushEvent(&fake); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

174 
break; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

175 
case SDL_WINDOWEVENT_RESTORED: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

176 
fake.type = SDL_ACTIVEEVENT; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

177 
fake.active.gain = 1; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

178 
fake.active.state = SDL_APPACTIVE; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

179 
SDL_PushEvent(&fake); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

180 
break; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

181 
case SDL_WINDOWEVENT_ENTER: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

182 
fake.type = SDL_ACTIVEEVENT; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

183 
fake.active.gain = 1; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

184 
fake.active.state = SDL_APPMOUSEFOCUS; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

185 
SDL_PushEvent(&fake); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

186 
break; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

187 
case SDL_WINDOWEVENT_LEAVE: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

188 
fake.type = SDL_ACTIVEEVENT; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

189 
fake.active.gain = 0; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

190 
fake.active.state = SDL_APPMOUSEFOCUS; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

191 
SDL_PushEvent(&fake); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

192 
break; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

193 
case SDL_WINDOWEVENT_FOCUS_GAINED: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

194 
fake.type = SDL_ACTIVEEVENT; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

195 
fake.active.gain = 1; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

196 
fake.active.state = SDL_APPINPUTFOCUS; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

197 
SDL_PushEvent(&fake); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

198 
break; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

199 
case SDL_WINDOWEVENT_FOCUS_LOST: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

200 
fake.type = SDL_ACTIVEEVENT; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

201 
fake.active.gain = 1; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

202 
fake.active.state = SDL_APPINPUTFOCUS; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

203 
SDL_PushEvent(&fake); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

204 
break; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

205 
} 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

206 
} 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

207 
return orig_eventfilter(event); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

208 
} 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

209 

1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

210 
SDL_Surface * 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

211 
SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

212 
{ 
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

213 
int (*filter) (const SDL_Event * event); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

214 
const SDL_DisplayMode *desktop_mode; 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

215 
SDL_DisplayMode mode; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

216 
int i; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

217 
Uint32 window_flags; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

218 
Uint32 desktop_format; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

219 
Uint32 desired_format; 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

220 
Uint32 texture_format; 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

221 

1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

222 
if (!SDL_GetVideoDevice()) { 
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

223 
if (SDL_Init(SDL_INIT_VIDEO  SDL_INIT_NOPARACHUTE) < 0) { 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

224 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

225 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

226 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

227 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

228 
/* Destroy existing window */ 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

229 
SDL_PublicSurface = NULL; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

230 
if (SDL_ShadowSurface) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

231 
SDL_FreeSurface(SDL_ShadowSurface); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

232 
SDL_ShadowSurface = NULL; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

233 
} 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

234 
if (SDL_VideoSurface) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

235 
SDL_FreeSurface(SDL_ShadowSurface); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

236 
SDL_VideoSurface = NULL; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

237 
} 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

238 
SDL_DestroyWindow(SDL_VideoWindow); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

239 

1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

240 
/* Set up the event filter */ 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

241 
filter = SDL_GetEventFilter(); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

242 
if (filter != SDL_CompatEventFilter) { 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

243 
orig_eventfilter = filter; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

244 
} 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

245 
SDL_SetEventFilter(SDL_CompatEventFilter); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

246 

1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

247 
/* Create a new window */ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

248 
window_flags = SDL_WINDOW_SHOWN; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

249 
if (flags & SDL_FULLSCREEN) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

250 
window_flags = SDL_WINDOW_FULLSCREEN; 
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 
if (flags & SDL_OPENGL) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

253 
window_flags = SDL_WINDOW_OPENGL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

254 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

255 
if (flags & SDL_RESIZABLE) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

256 
window_flags = SDL_WINDOW_RESIZABLE; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

257 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

258 
if (flags & SDL_NOFRAME) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

259 
window_flags = SDL_WINDOW_BORDERLESS; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

260 
} 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

261 
SDL_VideoWindow = 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

262 
SDL_CreateWindow(wm_title, 0, 0, width, height, window_flags); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

263 
if (!SDL_VideoWindow) { 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

264 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

265 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

266 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

267 
/* Set up the desired display mode */ 
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

268 
desktop_mode = SDL_GetDesktopDisplayMode(); 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

269 
desktop_format = desktop_mode>format; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

270 
if (desktop_format && ((flags & SDL_ANYFORMAT) 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

271 
 (bpp == SDL_BITSPERPIXEL(desktop_format)))) { 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

272 
desired_format = desktop_format; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

273 
} else { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

274 
switch (bpp) { 
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

275 
case 0: 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

276 
if (desktop_format) { 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

277 
desired_format = desktop_format; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

278 
} else { 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

279 
desired_format = SDL_PixelFormat_RGB888; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

280 
} 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

281 
break; 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

282 
case 8: 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

283 
desired_format = SDL_PixelFormat_Index8; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

284 
break; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

285 
case 15: 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

286 
desired_format = SDL_PixelFormat_RGB555; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

287 
break; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

288 
case 16: 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

289 
desired_format = SDL_PixelFormat_RGB565; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

290 
break; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

291 
case 24: 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

292 
desired_format = SDL_PixelFormat_RGB24; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

293 
break; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

294 
case 32: 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

295 
desired_format = SDL_PixelFormat_RGB888; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

296 
break; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

297 
default: 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

298 
SDL_SetError("Unsupported bpp in SDL_SetVideoMode()"); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

299 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

300 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

301 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

302 
mode.format = desired_format; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

303 
mode.w = width; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

304 
mode.h = height; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

305 
mode.refresh_rate = 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

306 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

307 
/* Set the desired display mode */ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

308 
if (flags & SDL_FULLSCREEN) { 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

309 
if (!SDL_GetClosestDisplayMode(&mode, &mode)) { 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

310 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

311 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

312 
} else { 
1669
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

313 
if (desktop_format) { 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

314 
mode.format = desktop_format; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

315 
} 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

316 
if (desktop_mode>w && desktop_mode>h) { 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

317 
mode.w = desktop_mode>w; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

318 
mode.h = desktop_mode>h; 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

319 
} 
9857d21967bb
The test programs compile again.
Sam Lantinga <slouken@libsdl.org>
parents:
1668
diff
changeset

320 
mode.refresh_rate = desktop_mode>refresh_rate; 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

321 
} 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

322 
if (SDL_SetDisplayMode(&mode) < 0) { 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

323 
return NULL; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

324 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

325 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

326 
/* Create a renderer for the window */ 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

327 
if (SDL_CreateRenderer(SDL_VideoWindow, 1, 0) < 0) { 
1670  328 
return NULL; 
329 
} 

330 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

331 
/* Create a texture for the screen surface */ 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

332 
SDL_VideoTexture = 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

333 
SDL_CreateTexture(desired_format, SDL_TextureAccess_Local, width, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

334 
height); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

335 
if (!SDL_VideoTexture) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

336 
SDL_VideoTexture = 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

337 
SDL_CreateTexture(0, SDL_TextureAccess_Local, width, height); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

338 
} 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

339 
if (!SDL_VideoTexture) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

340 
return NULL; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

341 
} 
1670  342 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

343 
/* Create the screen surface */ 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

344 
SDL_VideoSurface = SDL_CreateRGBSurfaceFromTexture(SDL_VideoTexture); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

345 
if (!SDL_VideoSurface) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

346 
return NULL; 
1670  347 
} 
348 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

349 
/* Set a default screen palette */ 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

350 
if (SDL_VideoSurface>format>palette) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

351 
SDL_VideoSurface>flags = SDL_HWPALETTE; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

352 
SDL_DitherColors(SDL_VideoSurface>format>palette>colors, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

353 
SDL_VideoSurface>format>BitsPerPixel); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

354 
SDL_SetTexturePalette(SDL_VideoTexture, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

355 
SDL_VideoSurface>format>palette>colors, 0, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

356 
SDL_VideoSurface>format>palette>ncolors); 
1670  357 
} 
358 

359 
/* Create a shadow surface if necessary */ 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

360 
if (((bpp != SDL_VideoSurface>format>BitsPerPixel) 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

361 
&& !(flags & SDL_ANYFORMAT)) 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

362 
 ((SDL_VideoSurface>flags & SDL_HWSURFACE) 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

363 
&& !(flags & SDL_HWSURFACE))) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

364 
if ((bpp == SDL_VideoSurface>format>BitsPerPixel) 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

365 
 (flags & SDL_ANYFORMAT)) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

366 
SDL_ShadowSurface = 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

367 
SDL_CreateRGBSurface(0, width, height, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

368 
SDL_VideoSurface>format>BitsPerPixel, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

369 
SDL_VideoSurface>format>Rmask, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

370 
SDL_VideoSurface>format>Gmask, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

371 
SDL_VideoSurface>format>Bmask, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

372 
SDL_VideoSurface>format>Amask); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

373 
} else { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

374 
SDL_ShadowSurface = 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

375 
SDL_CreateRGBSurface(0, width, height, bpp, 0, 0, 0, 0); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

376 
} 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

377 
if (!SDL_ShadowSurface) { 
1670  378 
return NULL; 
379 
} 

380 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

381 
/* 8bit SDL_ShadowSurface surfaces report that they have exclusive palette */ 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

382 
if (SDL_ShadowSurface>format>palette) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

383 
SDL_ShadowSurface>flags = SDL_HWPALETTE; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

384 
SDL_DitherColors(SDL_ShadowSurface>format>palette>colors, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

385 
SDL_ShadowSurface>format>BitsPerPixel); 
1670  386 
} 
387 
} 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

388 
SDL_PublicSurface = 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

389 
(SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface); 
1670  390 

391 
/* Clear the surface for display */ 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

392 
SDL_FillRect(SDL_PublicSurface, NULL, 0); 
1670  393 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

394 
/* We're finally done! */ 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

395 
return SDL_PublicSurface; 
1670  396 
} 
397 

398 
SDL_Surface * 

1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

399 
SDL_GetVideoSurface(void) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

400 
{ 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

401 
return SDL_PublicSurface; 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

402 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

403 

1670  404 
SDL_Surface * 
405 
SDL_DisplayFormat(SDL_Surface * surface) 

406 
{ 

407 
Uint32 flags; 

408 

409 
if (!SDL_PublicSurface) { 

410 
SDL_SetError("No video mode has been set"); 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

411 
return NULL; 
1670  412 
} 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

413 

1670  414 
/* Set the flags appropriate for copying to display surface */ 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

415 
flags = SDL_SWSURFACE; 
1670  416 
#ifdef AUTORLE_DISPLAYFORMAT 
417 
flags = (surface>flags & (SDL_SRCCOLORKEY  SDL_SRCALPHA)); 

418 
flags = SDL_RLEACCELOK; 

419 
#else 

420 
flags = 

421 
surface>flags & (SDL_SRCCOLORKEY  SDL_SRCALPHA  SDL_RLEACCELOK); 

422 
#endif 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

423 
return SDL_ConvertSurface(surface, SDL_PublicSurface>format, flags); 
1670  424 
} 
425 

426 
SDL_Surface * 

427 
SDL_DisplayFormatAlpha(SDL_Surface * surface) 

428 
{ 

429 
SDL_PixelFormat *vf; 

430 
SDL_PixelFormat *format; 

431 
SDL_Surface *converted; 

432 
Uint32 flags; 

433 
/* default to ARGB8888 */ 

434 
Uint32 amask = 0xff000000; 

435 
Uint32 rmask = 0x00ff0000; 

436 
Uint32 gmask = 0x0000ff00; 

437 
Uint32 bmask = 0x000000ff; 

438 

439 
if (!SDL_PublicSurface) { 

440 
SDL_SetError("No video mode has been set"); 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

441 
return NULL; 
1670  442 
} 
443 
vf = SDL_PublicSurface>format; 

444 

445 
switch (vf>BytesPerPixel) { 

446 
case 2: 

447 
/* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}. 

448 
For anything else (like ARGB4444) it doesn't matter 

449 
since we have no special code for it anyway */ 

450 
if ((vf>Rmask == 0x1f) && 

451 
(vf>Bmask == 0xf800  vf>Bmask == 0x7c00)) { 

452 
rmask = 0xff; 

453 
bmask = 0xff0000; 

454 
} 

455 
break; 

456 

457 
case 3: 

458 
case 4: 

459 
/* Keep the video format, as long as the high 8 bits are 

460 
unused or alpha */ 

461 
if ((vf>Rmask == 0xff) && (vf>Bmask == 0xff0000)) { 

462 
rmask = 0xff; 

463 
bmask = 0xff0000; 

464 
} 

465 
break; 

466 

467 
default: 

468 
/* We have no other optimised formats right now. When/if a new 

469 
optimised alpha format is written, add the converter here */ 

470 
break; 

471 
} 

472 
format = SDL_AllocFormat(32, rmask, gmask, bmask, amask); 

473 
flags = SDL_PublicSurface>flags & SDL_HWSURFACE; 

474 
flags = surface>flags & (SDL_SRCALPHA  SDL_RLEACCELOK); 

475 
converted = SDL_ConvertSurface(surface, format, flags); 

476 
SDL_FreeFormat(format); 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

477 
return converted; 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

478 
} 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

479 

90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

480 
int 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

481 
SDL_Flip(SDL_Surface * screen) 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

482 
{ 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

483 
SDL_UpdateRect(screen, 0, 0, 0, 0); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

484 
return 0; 
1670  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 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

516 
if (screen == SDL_ShadowSurface) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

517 
for (i = 0; i < numrects; ++i) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

518 
SDL_LowerBlit(SDL_ShadowSurface, &rects[i], SDL_VideoSurface, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

519 
&rects[i]); 
1670  520 
} 
521 

522 
/* Fall through to video surface update */ 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

523 
screen = SDL_VideoSurface; 
1670  524 
} 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

525 
if (screen == SDL_VideoSurface) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

526 
for (i = 0; i < numrects; ++i) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

527 
SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i], 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

528 
SDL_TextureBlendMode_None, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

529 
SDL_TextureScaleMode_None); 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

530 
} 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

531 
SDL_RenderPresent(); 
1670  532 
} 
533 
} 

534 

1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

535 
void 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

536 
SDL_WM_SetCaption(const char *title, const char *icon) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

537 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

538 
if (wm_title) { 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

539 
SDL_free(wm_title); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

540 
} else { 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

541 
wm_title = SDL_strdup(title); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

542 
} 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

543 
SDL_SetWindowTitle(SDL_VideoWindow, wm_title); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

544 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

545 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

546 
void 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

547 
SDL_WM_GetCaption(char **title, char **icon) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

548 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

549 
if (title) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

550 
*title = wm_title; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

551 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

552 
if (icon) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

553 
*icon = ""; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

554 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

555 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

556 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

557 
void 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

558 
SDL_WM_SetIcon(SDL_Surface * icon, Uint8 * mask) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

559 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

560 
/* FIXME */ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

561 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

562 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

563 
int 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

564 
SDL_WM_IconifyWindow(void) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

565 
{ 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

566 
SDL_MinimizeWindow(SDL_VideoWindow); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

567 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

568 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

569 
int 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

570 
SDL_WM_ToggleFullScreen(SDL_Surface * surface) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

571 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

572 
return 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

573 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

574 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

575 
SDL_GrabMode 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

576 
SDL_WM_GrabInput(SDL_GrabMode mode) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

577 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

578 
if (mode != SDL_GRAB_QUERY) { 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

579 
SDL_SetWindowGrab(SDL_VideoWindow, mode); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

580 
} 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

581 
return (SDL_GrabMode) SDL_GetWindowGrab(SDL_VideoWindow); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

582 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

583 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

584 
Uint8 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

585 
SDL_GetAppState(void) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

586 
{ 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

587 
Uint8 state = 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

588 
Uint32 flags = 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

589 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

590 
flags = SDL_GetWindowFlags(SDL_VideoWindow); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

591 
if ((flags & SDL_WINDOW_SHOWN) && !(flags & SDL_WINDOW_MINIMIZED)) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

592 
state = SDL_APPACTIVE; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

593 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

594 
if (flags & SDL_WINDOW_KEYBOARD_FOCUS) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

595 
state = SDL_APPINPUTFOCUS; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

596 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

597 
if (flags & SDL_WINDOW_MOUSE_FOCUS) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

598 
state = SDL_APPMOUSEFOCUS; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

599 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

600 
return state; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

601 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

602 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

603 
const SDL_version * 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

604 
SDL_Linked_Version(void) 
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 
static SDL_version version; 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

607 
SDL_VERSION(&version); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

608 
return &version; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

609 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

610 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

611 
int 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

612 
SDL_SetPalette(SDL_Surface * surface, int flags, SDL_Color * colors, 
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

613 
int firstcolor, int ncolors) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

614 
{ 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

615 
SDL_SetColors(surface, colors, firstcolor, ncolors); 
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 

1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

618 
int 
1670  619 
SDL_SetScreenColors(SDL_Surface * screen, SDL_Color * colors, int firstcolor, 
620 
int ncolors) 

621 
{ 

622 
SDL_Palette *pal; 

623 
int gotall; 

624 
int palsize; 

625 

626 
/* Verify the parameters */ 

627 
pal = screen>format>palette; 

628 
if (!pal) { 

629 
return 0; /* not a palettized surface */ 

630 
} 

631 
gotall = 1; 

632 
palsize = 1 << screen>format>BitsPerPixel; 

633 
if (ncolors > (palsize  firstcolor)) { 

634 
ncolors = (palsize  firstcolor); 

635 
gotall = 0; 

636 
} 

637 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

638 
if (screen == SDL_ShadowSurface) { 
1670  639 
SDL_Palette *vidpal; 
640 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

641 
vidpal = SDL_VideoSurface>format>palette; 
1670  642 
if (vidpal && vidpal>ncolors == pal>ncolors) { 
643 
/* This is a shadow surface, and the physical 

644 
* framebuffer is also indexed. Propagate the 

645 
* changes to its logical palette so that 

646 
* updates are always identity blits 

647 
*/ 

648 
SDL_memcpy(vidpal>colors + firstcolor, colors, 

649 
ncolors * sizeof(*colors)); 

650 
} 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

651 
if (SDL_VideoSurface>flags & SDL_HWPALETTE) { 
1670  652 
/* Set the physical palette */ 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

653 
screen = SDL_VideoSurface; 
1670  654 
} else { 
655 
SDL_UpdateRect(screen, 0, 0, 0, 0); 

656 
} 

657 
} 

658 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

659 
if (screen == SDL_VideoSurface) { 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

660 
SDL_SetTexturePalette(SDL_VideoTexture, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

661 
SDL_VideoSurface>format>palette>colors, 0, 
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

662 
SDL_VideoSurface>format>palette>ncolors); 
1670  663 
} 
664 

665 
return gotall; 

666 
} 

667 

668 
int 

1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

669 
SDL_GetWMInfo(SDL_SysWMinfo * info) 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

670 
{ 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

671 
return SDL_GetWindowWMInfo(SDL_VideoWindow, info); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

672 
} 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

673 

1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

674 
#if 0 
1670  675 
void 
676 
SDL_MoveCursor(int x, int y) 

677 
{ 

678 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

679 

680 
/* Erase and update the current mouse position */ 

681 
if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { 

682 
/* Erase and redraw mouse cursor in new position */ 

683 
SDL_LockCursor(); 

684 
SDL_EraseCursor(SDL_VideoSurface); 

685 
SDL_cursor>area.x = (x  SDL_cursor>hot_x); 

686 
SDL_cursor>area.y = (y  SDL_cursor>hot_y); 

687 
SDL_DrawCursor(SDL_VideoSurface); 

688 
SDL_UnlockCursor(); 

689 
} else if (_this>MoveWMCursor) { 

690 
_this>MoveWMCursor(_this, x, y); 

691 
} 

692 
} 

693 

694 
/* Keep track of the current cursor colors */ 

695 
static int palette_changed = 1; 

696 
static Uint8 pixels8[2]; 

697 

698 
void 

699 
SDL_CursorPaletteChanged(void) 

700 
{ 

701 
palette_changed = 1; 

702 
} 

703 

704 
void 

705 
SDL_MouseRect(SDL_Rect * area) 

706 
{ 

707 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

708 
int clip_diff; 

709 

710 
*area = SDL_cursor>area; 

711 
if (area>x < 0) { 

712 
area>w += area>x; 

713 
area>x = 0; 

714 
} 

715 
if (area>y < 0) { 

716 
area>h += area>y; 

717 
area>y = 0; 

718 
} 

719 
clip_diff = (area>x + area>w)  SDL_VideoSurface>w; 

720 
if (clip_diff > 0) { 

721 
area>w = area>w < clip_diff ? 0 : area>w  clip_diff; 

722 
} 

723 
clip_diff = (area>y + area>h)  SDL_VideoSurface>h; 

724 
if (clip_diff > 0) { 

725 
area>h = area>h < clip_diff ? 0 : area>h  clip_diff; 

726 
} 

727 
} 

728 

729 
static void 

730 
SDL_DrawCursorFast(SDL_Surface * screen, SDL_Rect * area) 

731 
{ 

732 
const Uint32 pixels[2] = { 0xFFFFFFFF, 0x00000000 }; 

733 
int i, w, h; 

734 
Uint8 *data, datab; 

735 
Uint8 *mask, maskb; 

736 

737 
data = SDL_cursor>data + area>y * SDL_cursor>area.w / 8; 

738 
mask = SDL_cursor>mask + area>y * SDL_cursor>area.w / 8; 

739 
switch (screen>format>BytesPerPixel) { 

740 

741 
case 1: 

742 
{ 

743 
Uint8 *dst; 

744 
int dstskip; 

745 

746 
if (palette_changed) { 

747 
pixels8[0] = 

748 
(Uint8) SDL_MapRGB(screen>format, 255, 255, 255); 

749 
pixels8[1] = (Uint8) SDL_MapRGB(screen>format, 0, 0, 0); 

750 
palette_changed = 0; 

751 
} 

752 
dst = (Uint8 *) screen>pixels + 

753 
(SDL_cursor>area.y + area>y) * screen>pitch + 

754 
SDL_cursor>area.x; 

755 
dstskip = screen>pitch  area>w; 

756 

757 
for (h = area>h; h; h) { 

758 
for (w = area>w / 8; w; w) { 

759 
maskb = *mask++; 

760 
datab = *data++; 

761 
for (i = 0; i < 8; ++i) { 

762 
if (maskb & 0x80) { 

763 
*dst = pixels8[datab >> 7]; 

764 
} 

765 
maskb <<= 1; 

766 
datab <<= 1; 

767 
dst++; 

768 
} 

769 
} 

770 
dst += dstskip; 

771 
} 

772 
} 

773 
break; 

774 

775 
case 2: 

776 
{ 

777 
Uint16 *dst; 

778 
int dstskip; 

779 

780 
dst = (Uint16 *) screen>pixels + 

781 
(SDL_cursor>area.y + area>y) * screen>pitch / 2 + 

782 
SDL_cursor>area.x; 

783 
dstskip = (screen>pitch / 2)  area>w; 

784 

785 
for (h = area>h; h; h) { 

786 
for (w = area>w / 8; w; w) { 

787 
maskb = *mask++; 

788 
datab = *data++; 

789 
for (i = 0; i < 8; ++i) { 

790 
if (maskb & 0x80) { 

791 
*dst = (Uint16) pixels[datab >> 7]; 

792 
} 

793 
maskb <<= 1; 

794 
datab <<= 1; 

795 
dst++; 

796 
} 

797 
} 

798 
dst += dstskip; 

799 
} 

800 
} 

801 
break; 

802 

803 
case 3: 

804 
{ 

805 
Uint8 *dst; 

806 
int dstskip; 

807 

808 
dst = (Uint8 *) screen>pixels + 

809 
(SDL_cursor>area.y + area>y) * screen>pitch + 

810 
SDL_cursor>area.x * 3; 

811 
dstskip = screen>pitch  area>w * 3; 

812 

813 
for (h = area>h; h; h) { 

814 
for (w = area>w / 8; w; w) { 

815 
maskb = *mask++; 

816 
datab = *data++; 

817 
for (i = 0; i < 8; ++i) { 

818 
if (maskb & 0x80) { 

819 
SDL_memset(dst, pixels[datab >> 7], 3); 

820 
} 

821 
maskb <<= 1; 

822 
datab <<= 1; 

823 
dst += 3; 

824 
} 

825 
} 

826 
dst += dstskip; 

827 
} 

828 
} 

829 
break; 

830 

831 
case 4: 

832 
{ 

833 
Uint32 *dst; 

834 
int dstskip; 

835 

836 
dst = (Uint32 *) screen>pixels + 

837 
(SDL_cursor>area.y + area>y) * screen>pitch / 4 + 

838 
SDL_cursor>area.x; 

839 
dstskip = (screen>pitch / 4)  area>w; 

840 

841 
for (h = area>h; h; h) { 

842 
for (w = area>w / 8; w; w) { 

843 
maskb = *mask++; 

844 
datab = *data++; 

845 
for (i = 0; i < 8; ++i) { 

846 
if (maskb & 0x80) { 

847 
*dst = pixels[datab >> 7]; 

848 
} 

849 
maskb <<= 1; 

850 
datab <<= 1; 

851 
dst++; 

852 
} 

853 
} 

854 
dst += dstskip; 

855 
} 

856 
} 

857 
break; 

858 
} 

859 
} 

860 

861 
static void 

862 
SDL_DrawCursorSlow(SDL_Surface * screen, SDL_Rect * area) 

863 
{ 

864 
const Uint32 pixels[2] = { 0xFFFFFF, 0x000000 }; 

865 
int h; 

866 
int x, minx, maxx; 

867 
Uint8 *data, datab = 0; 

868 
Uint8 *mask, maskb = 0; 

869 
Uint8 *dst; 

870 
int dstbpp, dstskip; 

871 

872 
data = SDL_cursor>data + area>y * SDL_cursor>area.w / 8; 

873 
mask = SDL_cursor>mask + area>y * SDL_cursor>area.w / 8; 

874 
dstbpp = screen>format>BytesPerPixel; 

875 
dst = (Uint8 *) screen>pixels + 

876 
(SDL_cursor>area.y + area>y) * screen>pitch + 

877 
SDL_cursor>area.x * dstbpp; 

878 
dstskip = screen>pitch  SDL_cursor>area.w * dstbpp; 

879 

880 
minx = area>x; 

881 
maxx = area>x + area>w; 

882 
if (screen>format>BytesPerPixel == 1) { 

883 
if (palette_changed) { 

884 
pixels8[0] = (Uint8) SDL_MapRGB(screen>format, 255, 255, 255); 

885 
pixels8[1] = (Uint8) SDL_MapRGB(screen>format, 0, 0, 0); 

886 
palette_changed = 0; 

887 
} 

888 
for (h = area>h; h; h) { 

889 
for (x = 0; x < SDL_cursor>area.w; ++x) { 

890 
if ((x % 8) == 0) { 

891 
maskb = *mask++; 

892 
datab = *data++; 

893 
} 

894 
if ((x >= minx) && (x < maxx)) { 

895 
if (maskb & 0x80) { 

896 
SDL_memset(dst, pixels8[datab >> 7], dstbpp); 

897 
} 

898 
} 

899 
maskb <<= 1; 

900 
datab <<= 1; 

901 
dst += dstbpp; 

902 
} 

903 
dst += dstskip; 

904 
} 

905 
} else { 

906 
for (h = area>h; h; h) { 

907 
for (x = 0; x < SDL_cursor>area.w; ++x) { 

908 
if ((x % 8) == 0) { 

909 
maskb = *mask++; 

910 
datab = *data++; 

911 
} 

912 
if ((x >= minx) && (x < maxx)) { 

913 
if (maskb & 0x80) { 

914 
SDL_memset(dst, pixels[datab >> 7], dstbpp); 

915 
} 

916 
} 

917 
maskb <<= 1; 

918 
datab <<= 1; 

919 
dst += dstbpp; 

920 
} 

921 
dst += dstskip; 

922 
} 

923 
} 

924 
} 

925 

926 
/* This handles the ugly work of converting the saved cursor background from 

927 
the pixel format of the shadow surface to that of the video surface. 

928 
This is only necessary when blitting from a shadow surface of a different 

929 
pixel format than the video surface, and using a software rendered cursor. 

930 
*/ 

931 
static void 

932 
SDL_ConvertCursorSave(SDL_Surface * screen, int w, int h) 

933 
{ 

934 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

935 
SDL_BlitInfo info; 

936 
SDL_loblit RunBlit; 

937 

938 
/* Make sure we can steal the blit mapping */ 

939 
if (screen>map>dst != SDL_VideoSurface) { 

940 
return; 

941 
} 

942 

943 
/* Set up the blit information */ 

944 
info.s_pixels = SDL_cursor>save[1]; 

945 
info.s_width = w; 

946 
info.s_height = h; 

947 
info.s_skip = 0; 

948 
info.d_pixels = SDL_cursor>save[0]; 

949 
info.d_width = w; 

950 
info.d_height = h; 

951 
info.d_skip = 0; 

952 
info.aux_data = screen>map>sw_data>aux_data; 

953 
info.src = screen>format; 

954 
info.table = screen>map>table; 

955 
info.dst = SDL_VideoSurface>format; 

956 
RunBlit = screen>map>sw_data>blit; 

957 

958 
/* Run the actual software blit */ 

959 
RunBlit(&info); 

960 
} 

961 

962 
void 

963 
SDL_DrawCursorNoLock(SDL_Surface * screen) 

964 
{ 

965 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

966 
SDL_Rect area; 

967 

968 
/* Get the mouse rectangle, clipped to the screen */ 

969 
SDL_MouseRect(&area); 

970 
if ((area.w == 0)  (area.h == 0)) { 

971 
return; 

972 
} 

973 

974 
/* Copy mouse background */ 

975 
{ 

976 
int w, h, screenbpp; 

977 
Uint8 *src, *dst; 

978 

979 
/* Set up the copy pointers */ 

980 
screenbpp = screen>format>BytesPerPixel; 

981 
if ((screen == SDL_VideoSurface)  

982 
FORMAT_EQUAL(screen>format, SDL_VideoSurface>format)) { 

983 
dst = SDL_cursor>save[0]; 

984 
} else { 

985 
dst = SDL_cursor>save[1]; 

986 
} 

987 
src = (Uint8 *) screen>pixels + area.y * screen>pitch + 

988 
area.x * screenbpp; 

989 

990 
/* Perform the copy */ 

991 
w = area.w * screenbpp; 

992 
h = area.h; 

993 
while (h) { 

994 
SDL_memcpy(dst, src, w); 

995 
dst += w; 

996 
src += screen>pitch; 

997 
} 

998 
} 

999 

1000 
/* Draw the mouse cursor */ 

1001 
area.x = SDL_cursor>area.x; 

1002 
area.y = SDL_cursor>area.y; 

1003 
if ((area.x == 0) && (area.w == SDL_cursor>area.w)) { 

1004 
SDL_DrawCursorFast(screen, &area); 

1005 
} else { 

1006 
SDL_DrawCursorSlow(screen, &area); 

1007 
} 

1008 
} 

1009 

1010 
void 

1011 
SDL_DrawCursor(SDL_Surface * screen) 

1012 
{ 

1013 
/* Lock the screen if necessary */ 

1014 
if (screen == NULL) { 

1015 
return; 

1016 
} 

1017 
if (SDL_MUSTLOCK(screen)) { 

1018 
if (SDL_LockSurface(screen) < 0) { 

1019 
return; 

1020 
} 

1021 
} 

1022 

1023 
SDL_DrawCursorNoLock(screen); 

1024 

1025 
/* Unlock the screen and update if necessary */ 

1026 
if (SDL_MUSTLOCK(screen)) { 

1027 
SDL_UnlockSurface(screen); 

1028 
} 

1029 
if ((screen>flags & SDL_SCREEN_SURFACE) && 

1030 
!(screen>flags & SDL_HWSURFACE)) { 

1031 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

1032 
SDL_Window *window; 

1033 
SDL_Rect area; 

1034 

1035 
window = SDL_GetWindowFromSurface(screen); 

1036 
if (!window) { 

1037 
return; 

1038 
} 

1039 

1040 
SDL_MouseRect(&area); 

1041 

1042 
if (_this>UpdateWindowSurface) { 

1043 
_this>UpdateWindowSurface(_this, window, 1, &area); 

1044 
} 

1045 
} 

1046 
} 

1047 

1048 
void 

1049 
SDL_EraseCursorNoLock(SDL_Surface * screen) 

1050 
{ 

1051 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

1052 
SDL_Window *window; 

1053 
SDL_Rect area; 

1054 

1055 
/* Get the window associated with the surface */ 

1056 
window = SDL_GetWindowFromSurface(screen); 

1057 
if (!window  !window>surface) { 

1058 
return; 

1059 
} 

1060 

1061 
/* Get the mouse rectangle, clipped to the screen */ 

1062 
SDL_MouseRect(&area); 

1063 
if ((area.w == 0)  (area.h == 0)) { 

1064 
return; 

1065 
} 

1066 

1067 
/* Copy mouse background */ 

1068 
{ 

1069 
int w, h, screenbpp; 

1070 
Uint8 *src, *dst; 

1071 

1072 
/* Set up the copy pointers */ 

1073 
screenbpp = screen>format>BytesPerPixel; 

1074 
if ((screen>flags & SDL_SCREEN_SURFACE)  

1075 
FORMAT_EQUAL(screen>format, window>surface>format)) { 

1076 
src = SDL_cursor>save[0]; 

1077 
} else { 

1078 
src = SDL_cursor>save[1]; 

1079 
} 

1080 
dst = (Uint8 *) screen>pixels + area.y * screen>pitch + 

1081 
area.x * screenbpp; 

1082 

1083 
/* Perform the copy */ 

1084 
w = area.w * screenbpp; 

1085 
h = area.h; 

1086 
while (h) { 

1087 
SDL_memcpy(dst, src, w); 

1088 
src += w; 

1089 
dst += screen>pitch; 

1090 
} 

1091 

1092 
/* Perform pixel conversion on cursor background */ 

1093 
if (src > SDL_cursor>save[1]) { 

1094 
SDL_ConvertCursorSave(screen, area.w, area.h); 

1095 
} 

1096 
} 

1097 
} 

1098 

1099 
void 

1100 
SDL_EraseCursor(SDL_Surface * screen) 

1101 
{ 

1102 
/* Lock the screen if necessary */ 

1103 
if (screen == NULL) { 

1104 
return; 

1105 
} 

1106 
if (SDL_MUSTLOCK(screen)) { 

1107 
if (SDL_LockSurface(screen) < 0) { 

1108 
return; 

1109 
} 

1110 
} 

1111 

1112 
SDL_EraseCursorNoLock(screen); 

1113 

1114 
/* Unlock the screen and update if necessary */ 

1115 
if (SDL_MUSTLOCK(screen)) { 

1116 
SDL_UnlockSurface(screen); 

1117 
} 

1118 
if ((screen>flags & SDL_SCREEN_SURFACE) && 

1119 
!(screen>flags & SDL_HWSURFACE)) { 

1120 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

1121 
SDL_Window *window; 

1122 
SDL_Rect area; 

1123 

1124 
window = SDL_GetWindowFromSurface(screen); 

1125 
if (!window) { 

1126 
return; 

1127 
} 

1128 

1129 
SDL_MouseRect(&area); 

1130 

1131 
if (_this>UpdateWindowSurface) { 

1132 
_this>UpdateWindowSurface(_this, window, 1, &area); 

1133 
} 

1134 
} 

1135 
} 

1136 

1137 
/* Reset the cursor on video mode change 

1138 
FIXME: Keep track of all cursors, and reset them all. 

1139 
*/ 

1140 
void 

1141 
SDL_ResetCursor(void) 

1142 
{ 

1143 