author  Sam Lantinga <slouken@libsdl.org> 
Tue, 20 Jun 2006 05:40:57 +0000  
branch  SDL1.3 
changeset 1691  c901fd2a42da 
parent 1687  d36048e8e302 
child 1712  931d111e737a 
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 

1686
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

153 
static int (*orig_eventfilter) (SDL_Event * event); 
1669
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 
1686
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

156 
SDL_CompatEventFilter(SDL_Event * event) 
1669
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 
} 
1686
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

206 
case SDL_KEYDOWN: 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

207 
case SDL_KEYUP: 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

208 
{ 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

209 
Uint32 unicode = 0; 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

210 
if (event>key.type == SDL_KEYDOWN && event>key.keysym.sym < 256) { 
1687
d36048e8e302
This trick only works for English
Sam Lantinga <slouken@libsdl.org>
parents:
1686
diff
changeset

211 
unicode = event>key.keysym.sym; 
1691
c901fd2a42da
I think this fixes bug #244
Sam Lantinga <slouken@libsdl.org>
parents:
1687
diff
changeset

212 
if (unicode >= 'a' && unicode <= 'z') { 
1687
d36048e8e302
This trick only works for English
Sam Lantinga <slouken@libsdl.org>
parents:
1686
diff
changeset

213 
int shifted = !!(event>key.keysym.mod & KMOD_SHIFT); 
d36048e8e302
This trick only works for English
Sam Lantinga <slouken@libsdl.org>
parents:
1686
diff
changeset

214 
int capslock = !!(event>key.keysym.mod & KMOD_CAPS); 
d36048e8e302
This trick only works for English
Sam Lantinga <slouken@libsdl.org>
parents:
1686
diff
changeset

215 
if ((shifted ^ capslock) != 0) { 
d36048e8e302
This trick only works for English
Sam Lantinga <slouken@libsdl.org>
parents:
1686
diff
changeset

216 
unicode = SDL_toupper(unicode); 
d36048e8e302
This trick only works for English
Sam Lantinga <slouken@libsdl.org>
parents:
1686
diff
changeset

217 
} 
1686
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

218 
} 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

219 
} 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

220 
if (unicode) { 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

221 
event>key.keysym.unicode = unicode; 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

222 
} 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

223 
break; 
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

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

225 
} 
1683
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

226 
if (orig_eventfilter) { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

227 
return orig_eventfilter(event); 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

228 
} else { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

229 
return 1; 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

230 
} 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

231 
} 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

232 

396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

233 
static int 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

234 
SDL_VideoPaletteChanged(void *userdata, SDL_Palette * palette) 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

235 
{ 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

236 
if (userdata == SDL_ShadowSurface) { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

237 
/* If the shadow palette changed, make the changes visible */ 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

238 
if (!SDL_VideoSurface>format>palette) { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

239 
SDL_UpdateRect(SDL_ShadowSurface, 0, 0, 0, 0); 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

240 
} 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

241 
} 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

242 
if (userdata == SDL_VideoSurface) { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

243 
return SDL_SetDisplayPalette(palette>colors, 0, palette>ncolors); 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

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

245 
} 
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 
SDL_Surface * 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

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

249 
{ 
1686
8d7fecceb9ef
Added the unicode keysym memory again for backwards compatibility.
Sam Lantinga <slouken@libsdl.org>
parents:
1685
diff
changeset

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

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

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

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

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

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

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

257 
Uint32 texture_format; 
1682
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

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

259 

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

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

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

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

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

264 
} 
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 
/* Destroy existing window */ 
1678
90bf530ced8e
SDL_SetVideoMode() compiles now...
Sam Lantinga <slouken@libsdl.org>
parents:
1675
diff
changeset

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

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

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

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

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

272 
if (SDL_VideoSurface) { 
1683
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

273 
SDL_DelPaletteWatch(SDL_VideoSurface>format>palette, 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

274 
SDL_VideoPaletteChanged, NULL); 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

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

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

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

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

279 

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

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

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

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

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

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

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

286 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

306 

1682
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

307 
window_flags = SDL_GetWindowFlags(SDL_VideoWindow); 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

308 
surface_flags = SDL_SCREEN_SURFACE; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

309 
if (window_flags & SDL_WINDOW_FULLSCREEN) { 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

310 
surface_flags = SDL_FULLSCREEN; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

311 
} 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

312 
if (window_flags & SDL_WINDOW_OPENGL) { 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

313 
surface_flags = SDL_OPENGL; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

314 
} 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

315 
if (window_flags & SDL_WINDOW_RESIZABLE) { 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

316 
surface_flags = SDL_RESIZABLE; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

317 
} 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

318 
if (window_flags & SDL_WINDOW_BORDERLESS) { 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

319 
surface_flags = SDL_NOFRAME; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

320 
} 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

321 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

361 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

380 

1682
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

381 
/* If we're in OpenGL mode, just create a stub surface and we're done! */ 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

382 
if (flags & SDL_OPENGL) { 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

383 
SDL_VideoSurface = 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

384 
SDL_CreateRGBSurfaceFrom(NULL, width, height, bpp, 0, 0, 0, 0, 0); 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

385 
if (!SDL_VideoSurface) { 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

386 
return NULL; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

387 
} 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

388 
SDL_VideoSurface>flags = surface_flags; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

389 
SDL_PublicSurface = SDL_VideoSurface; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

390 
return SDL_PublicSurface; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

391 
} 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

392 

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

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

394 
if (SDL_CreateRenderer(SDL_VideoWindow, 1, 0) < 0) { 
1670  395 
return NULL; 
396 
} 

397 

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

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

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

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

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

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

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

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

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

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

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

408 
} 
1670  409 

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

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

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

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

413 
return NULL; 
1670  414 
} 
1682
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

415 
SDL_VideoSurface>flags = surface_flags; 
1670  416 

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

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

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

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

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

421 
SDL_VideoSurface>format>BitsPerPixel); 
1683
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

422 
SDL_AddPaletteWatch(SDL_VideoSurface>format>palette, 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

423 
SDL_VideoPaletteChanged, NULL); 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

424 
SDL_SetPaletteColors(SDL_VideoSurface>format>palette, 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

425 
SDL_VideoSurface>format>palette>colors, 0, 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

426 
SDL_VideoSurface>format>palette>ncolors); 
1670  427 
} 
428 

429 
/* Create a shadow surface if necessary */ 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

447 
if (!SDL_ShadowSurface) { 
1670  448 
return NULL; 
449 
} 

1682
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

450 
surface_flags &= ~SDL_SCREEN_SURFACE; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

451 
surface_flags = SDL_SHADOW_SURFACE; 
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

452 
SDL_ShadowSurface>flags = surface_flags; 
1670  453 

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

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

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

456 
SDL_ShadowSurface>flags = SDL_HWPALETTE; 
1683
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

457 
if (SDL_VideoSurface>format>palette) { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

458 
SDL_SetSurfacePalette(SDL_ShadowSurface, 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

459 
SDL_VideoSurface>format>palette); 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

460 
} else { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

461 
SDL_DitherColors(SDL_ShadowSurface>format>palette>colors, 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

462 
SDL_ShadowSurface>format>BitsPerPixel); 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

463 
} 
1670  464 
} 
465 
} 

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

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

467 
(SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface); 
1670  468 

469 
/* Clear the surface for display */ 

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

470 
SDL_FillRect(SDL_PublicSurface, NULL, 0); 
1670  471 

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

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

473 
return SDL_PublicSurface; 
1670  474 
} 
475 

476 
SDL_Surface * 

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

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

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

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

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

481 

1670  482 
SDL_Surface * 
483 
SDL_DisplayFormat(SDL_Surface * surface) 

484 
{ 

485 
Uint32 flags; 

486 

487 
if (!SDL_PublicSurface) { 

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

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

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

491 

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

493 
flags = SDL_SWSURFACE; 
1670  494 
#ifdef AUTORLE_DISPLAYFORMAT 
495 
flags = (surface>flags & (SDL_SRCCOLORKEY  SDL_SRCALPHA)); 

496 
flags = SDL_RLEACCELOK; 

497 
#else 

498 
flags = 

499 
surface>flags & (SDL_SRCCOLORKEY  SDL_SRCALPHA  SDL_RLEACCELOK); 

500 
#endif 

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

501 
return SDL_ConvertSurface(surface, SDL_PublicSurface>format, flags); 
1670  502 
} 
503 

504 
SDL_Surface * 

505 
SDL_DisplayFormatAlpha(SDL_Surface * surface) 

506 
{ 

507 
SDL_PixelFormat *vf; 

508 
SDL_PixelFormat *format; 

509 
SDL_Surface *converted; 

510 
Uint32 flags; 

511 
/* default to ARGB8888 */ 

512 
Uint32 amask = 0xff000000; 

513 
Uint32 rmask = 0x00ff0000; 

514 
Uint32 gmask = 0x0000ff00; 

515 
Uint32 bmask = 0x000000ff; 

516 

517 
if (!SDL_PublicSurface) { 

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

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

519 
return NULL; 
1670  520 
} 
521 
vf = SDL_PublicSurface>format; 

522 

523 
switch (vf>BytesPerPixel) { 

524 
case 2: 

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

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

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

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

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

530 
rmask = 0xff; 

531 
bmask = 0xff0000; 

532 
} 

533 
break; 

534 

535 
case 3: 

536 
case 4: 

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

538 
unused or alpha */ 

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

540 
rmask = 0xff; 

541 
bmask = 0xff0000; 

542 
} 

543 
break; 

544 

545 
default: 

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

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

548 
break; 

549 
} 

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

551 
flags = SDL_PublicSurface>flags & SDL_HWSURFACE; 

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

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

554 
SDL_FreeFormat(format); 

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

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

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

557 

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

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

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

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

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

562 
return 0; 
1670  563 
} 
564 

565 
void 

566 
SDL_UpdateRect(SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h) 

567 
{ 

568 
if (screen) { 

569 
SDL_Rect rect; 

570 

571 
/* Perform some checking */ 

572 
if (w == 0) 

573 
w = screen>w; 

574 
if (h == 0) 

575 
h = screen>h; 

576 
if ((int) (x + w) > screen>w) 

577 
return; 

578 
if ((int) (y + h) > screen>h) 

579 
return; 

580 

581 
/* Fill the rectangle */ 

582 
rect.x = (Sint16) x; 

583 
rect.y = (Sint16) y; 

584 
rect.w = (Uint16) w; 

585 
rect.h = (Uint16) h; 

586 
SDL_UpdateRects(screen, 1, &rect); 

587 
} 

588 
} 

589 
void 

590 
SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects) 

591 
{ 

592 
int i; 

593 

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

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

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

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

597 
&rects[i]); 
1670  598 
} 
599 

600 
/* Fall through to video surface update */ 

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

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

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

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

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

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

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

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

609 
SDL_RenderPresent(); 
1670  610 
} 
611 
} 

612 

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

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

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

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

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

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

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

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

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

621 
SDL_SetWindowTitle(SDL_VideoWindow, wm_title); 
1667
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 
void 
1668
4da1ee79c9af
more tweaking indent options
Sam Lantinga <slouken@libsdl.org>
parents:
1667
diff
changeset

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

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

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

628 
*title = wm_title; 
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 
if (icon) { 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

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

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

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

634 

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

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

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

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

638 
/* FIXME */ 
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 

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

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

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

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

644 
SDL_MinimizeWindow(SDL_VideoWindow); 
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 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

661 

1680
9488fca10677
Dummy video driver works again in high color video modes. Yay!
Sam Lantinga <slouken@libsdl.org>
parents:
1678
diff
changeset

662 
void 
9488fca10677
Dummy video driver works again in high color video modes. Yay!
Sam Lantinga <slouken@libsdl.org>
parents:
1678
diff
changeset

663 
SDL_WarpMouse(Uint16 x, Uint16 y) 
9488fca10677
Dummy video driver works again in high color video modes. Yay!
Sam Lantinga <slouken@libsdl.org>
parents:
1678
diff
changeset

664 
{ 
9488fca10677
Dummy video driver works again in high color video modes. Yay!
Sam Lantinga <slouken@libsdl.org>
parents:
1678
diff
changeset

665 
SDL_WarpMouseInWindow(SDL_VideoWindow, x, y); 
9488fca10677
Dummy video driver works again in high color video modes. Yay!
Sam Lantinga <slouken@libsdl.org>
parents:
1678
diff
changeset

666 
} 
9488fca10677
Dummy video driver works again in high color video modes. Yay!
Sam Lantinga <slouken@libsdl.org>
parents:
1678
diff
changeset

667 

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

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

669 
SDL_GetAppState(void) 
1667
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 
Uint8 state = 0; 
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

672 
Uint32 flags = 0; 
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 
flags = SDL_GetWindowFlags(SDL_VideoWindow); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

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

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

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

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

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

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

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

684 
return state; 
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 

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

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

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

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

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

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

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

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

694 

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

695 
int 
1682
7ae8018b2e5d
Default palette entries to white, instead of black.
Sam Lantinga <slouken@libsdl.org>
parents:
1681
diff
changeset

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

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

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

699 
SDL_SetColors(surface, colors, firstcolor, ncolors); 
1667
1fddae038bc8
Implemented many compatibility functions
Sam Lantinga <slouken@libsdl.org>
parents:
diff
changeset

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

701 

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

702 
int 
1683
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

703 
SDL_SetColors(SDL_Surface * surface, const SDL_Color * colors, int firstcolor, 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

704 
int ncolors) 
1670  705 
{ 
1683
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

706 
if (SDL_SetPaletteColors 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

707 
(surface>format>palette, colors, firstcolor, ncolors) == 0) { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

708 
return 1; 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

709 
} else { 
396a35389351
Finished palettized display handling.
Sam Lantinga <slouken@libsdl.org>
parents:
1682
diff
changeset

710 
return 0; 
1670  711 
} 
712 
} 

713 

714 
int 

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

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

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

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

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

719 

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

720 
#if 0 
1670  721 
void 
722 
SDL_MoveCursor(int x, int y) 

723 
{ 

724 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

725 

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

727 
if (SHOULD_DRAWCURSOR(SDL_cursorstate)) { 

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

729 
SDL_LockCursor(); 

730 
SDL_EraseCursor(SDL_VideoSurface); 

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

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

733 
SDL_DrawCursor(SDL_VideoSurface); 

734 
SDL_UnlockCursor(); 

735 
} else if (_this>MoveWMCursor) { 

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

737 
} 

738 
} 

739 

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

741 
static int palette_changed = 1; 

742 
static Uint8 pixels8[2]; 

743 

744 
void 

745 
SDL_CursorPaletteChanged(void) 

746 
{ 

747 
palette_changed = 1; 

748 
} 

749 

750 
void 

751 
SDL_MouseRect(SDL_Rect * area) 

752 
{ 

753 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

754 
int clip_diff; 

755 

756 
*area = SDL_cursor>area; 

757 
if (area>x < 0) { 

758 
area>w += area>x; 

759 
area>x = 0; 

760 
} 

761 
if (area>y < 0) { 

762 
area>h += area>y; 

763 
area>y = 0; 

764 
} 

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

766 
if (clip_diff > 0) { 

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

768 
} 

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

770 
if (clip_diff > 0) { 

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

772 
} 

773 
} 

774 

775 
static void 

776 
SDL_DrawCursorFast(SDL_Surface * screen, SDL_Rect * area) 

777 
{ 

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

779 
int i, w, h; 

780 
Uint8 *data, datab; 

781 
Uint8 *mask, maskb; 

782 

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

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

785 
switch (screen>format>BytesPerPixel) { 

786 

787 
case 1: 

788 
{ 

789 
Uint8 *dst; 

790 
int dstskip; 

791 

792 
if (palette_changed) { 

793 
pixels8[0] = 

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

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

796 
palette_changed = 0; 

797 
} 

798 
dst = (Uint8 *) screen>pixels + 

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

800 
SDL_cursor>area.x; 

801 
dstskip = screen>pitch  area>w; 

802 

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

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

805 
maskb = *mask++; 

806 
datab = *data++; 

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

808 
if (maskb & 0x80) { 

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

810 
} 

811 
maskb <<= 1; 

812 
datab <<= 1; 

813 
dst++; 

814 
} 

815 
} 

816 
dst += dstskip; 

817 
} 

818 
} 

819 
break; 

820 

821 
case 2: 

822 
{ 

823 
Uint16 *dst; 

824 
int dstskip; 

825 

826 
dst = (Uint16 *) screen>pixels + 

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

828 
SDL_cursor>area.x; 

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

830 

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

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

833 
maskb = *mask++; 

834 
datab = *data++; 

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

836 
if (maskb & 0x80) { 

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

838 
} 

839 
maskb <<= 1; 

840 
datab <<= 1; 

841 
dst++; 

842 
} 

843 
} 

844 
dst += dstskip; 

845 
} 

846 
} 

847 
break; 

848 

849 
case 3: 

850 
{ 

851 
Uint8 *dst; 

852 
int dstskip; 

853 

854 
dst = (Uint8 *) screen>pixels + 

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

856 
SDL_cursor>area.x * 3; 

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

858 

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

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

861 
maskb = *mask++; 

862 
datab = *data++; 

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

864 
if (maskb & 0x80) { 

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

866 
} 

867 
maskb <<= 1; 

868 
datab <<= 1; 

869 
dst += 3; 

870 
} 

871 
} 

872 
dst += dstskip; 

873 
} 

874 
} 

875 
break; 

876 

877 
case 4: 

878 
{ 

879 
Uint32 *dst; 

880 
int dstskip; 

881 

882 
dst = (Uint32 *) screen>pixels + 

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

884 
SDL_cursor>area.x; 

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

886 

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

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

889 
maskb = *mask++; 

890 
datab = *data++; 

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

892 
if (maskb & 0x80) { 

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

894 
} 

895 
maskb <<= 1; 

896 
datab <<= 1; 

897 
dst++; 

898 
} 

899 
} 

900 
dst += dstskip; 

901 
} 

902 
} 

903 
break; 

904 
} 

905 
} 

906 

907 
static void 

908 
SDL_DrawCursorSlow(SDL_Surface * screen, SDL_Rect * area) 

909 
{ 

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

911 
int h; 

912 
int x, minx, maxx; 

913 
Uint8 *data, datab = 0; 

914 
Uint8 *mask, maskb = 0; 

915 
Uint8 *dst; 

916 
int dstbpp, dstskip; 

917 

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

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

920 
dstbpp = screen>format>BytesPerPixel; 

921 
dst = (Uint8 *) screen>pixels + 

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

923 
SDL_cursor>area.x * dstbpp; 

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

925 

926 
minx = area>x; 

927 
maxx = area>x + area>w; 

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

929 
if (palette_changed) { 

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

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

932 
palette_changed = 0; 

933 
} 

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

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

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

937 
maskb = *mask++; 

938 
datab = *data++; 

939 
} 

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

941 
if (maskb & 0x80) { 

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

943 
} 

944 
} 

945 
maskb <<= 1; 

946 
datab <<= 1; 

947 
dst += dstbpp; 

948 
} 

949 
dst += dstskip; 

950 
} 

951 
} else { 

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

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

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

955 
maskb = *mask++; 

956 
datab = *data++; 

957 
} 

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

959 
if (maskb & 0x80) { 

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

961 
} 

962 
} 

963 
maskb <<= 1; 

964 
datab <<= 1; 

965 
dst += dstbpp; 

966 
} 

967 
dst += dstskip; 

968 
} 

969 
} 

970 
} 

971 

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

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

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

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

976 
*/ 

977 
static void 

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

979 
{ 

980 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

981 
SDL_BlitInfo info; 

982 
SDL_loblit RunBlit; 

983 

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

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

986 
return; 

987 
} 

988 

989 
/* Set up the blit information */ 

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

991 
info.s_width = w; 

992 
info.s_height = h; 

993 
info.s_skip = 0; 

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

995 
info.d_width = w; 

996 
info.d_height = h; 

997 
info.d_skip = 0; 

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

999 
info.src = screen>format; 

1000 
info.table = screen>map>table; 

1001 
info.dst = SDL_VideoSurface>format; 

1002 
RunBlit = screen>map>sw_data>blit; 

1003 

1004 
/* Run the actual software blit */ 

1005 
RunBlit(&info); 

1006 
} 

1007 

1008 
void 

1009 
SDL_DrawCursorNoLock(SDL_Surface * screen) 

1010 
{ 

1011 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

1012 
SDL_Rect area; 

1013 

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

1015 
SDL_MouseRect(&area); 

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

1017 
return; 

1018 
} 

1019 

1020 
/* Copy mouse background */ 

1021 
{ 

1022 
int w, h, screenbpp; 

1023 
Uint8 *src, *dst; 

1024 

1025 
/* Set up the copy pointers */ 

1026 
screenbpp = screen>format>BytesPerPixel; 

1027 
if ((screen == SDL_VideoSurface)  

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

1029 
dst = SDL_cursor>save[0]; 

1030 
} else { 

1031 
dst = SDL_cursor>save[1]; 

1032 
} 

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

1034 
area.x * screenbpp; 

1035 

1036 
/* Perform the copy */ 

1037 
w = area.w * screenbpp; 

1038 
h = area.h; 

1039 
while (h) { 

1040 
SDL_memcpy(dst, src, w); 

1041 
dst += w; 

1042 
src += screen>pitch; 

1043 
} 

1044 
} 

1045 

1046 
/* Draw the mouse cursor */ 

1047 
area.x = SDL_cursor>area.x; 

1048 
area.y = SDL_cursor>area.y; 

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

1050 
SDL_DrawCursorFast(screen, &area); 

1051 
} else { 

1052 
SDL_DrawCursorSlow(screen, &area); 

1053 
} 

1054 
} 

1055 

1056 
void 

1057 
SDL_DrawCursor(SDL_Surface * screen) 

1058 
{ 

1059 
/* Lock the screen if necessary */ 

1060 
if (screen == NULL) { 

1061 
return; 

1062 
} 

1063 
if (SDL_MUSTLOCK(screen)) { 

1064 
if (SDL_LockSurface(screen) < 0) { 

1065 
return; 

1066 
} 

1067 
} 

1068 

1069 
SDL_DrawCursorNoLock(screen); 

1070 

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

1072 
if (SDL_MUSTLOCK(screen)) { 

1073 
SDL_UnlockSurface(screen); 

1074 
} 

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

1076 
!(screen>flags & SDL_HWSURFACE)) { 

1077 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

1078 
SDL_Window *window; 

1079 
SDL_Rect area; 

1080 

1081 
window = SDL_GetWindowFromSurface(screen); 

1082 
if (!window) { 

1083 
return; 

1084 
} 

1085 

1086 
SDL_MouseRect(&area); 

1087 

1088 
if (_this>UpdateWindowSurface) { 

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

1090 
} 

1091 
} 

1092 
} 

1093 

1094 
void 

1095 
SDL_EraseCursorNoLock(SDL_Surface * screen) 

1096 
{ 

1097 
SDL_VideoDevice *_this = SDL_GetVideoDevice(); 

1098 
SDL_Window *window; 

1099 
SDL_Rect area; 

1100 

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

1102 
window = SDL_GetWindowFromSurface(screen); 

1103 
if (!window  !window>surface) { 

1104 
return; 

1105 
} 

1106 

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

1108 
SDL_MouseRect(&area); 

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

1110 
return; 

1111 
} 

1112 

1113 
/* Copy mouse background */ 

1114 
{ 

1115 
int w, h, screenbpp; 

1116 
Uint8 *src, *dst; 

1117 

1118 
/* Set up the copy pointers */ 

1119 
screenbpp = screen>format>BytesPerPixel; 

1120 
if ((screen>flags & SDL_SCREEN_SURFACE)  

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

1122 
src = SDL_cursor>save[0]; 

1123 
} else { 

1124 
src = SDL_cursor>save[1]; 

1125 
} 

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

1127 
area.x * screenbpp; 

1128 

1129 
/* Perform the copy */ 

1130 
w = area.w * screenbpp; 

1131 
h = area.h; 

1132 
while (h) { 

1133 
SDL_memcpy(dst, src, w); 

1134 
src += w; 

1135 
dst += screen>pitch; 

1136 
} 

1137 

1138 
/* Perform pixel conversion on cursor background */ 
