Mercurial > sdl-ios-xcode

comparison src/video/windx5/SDL_dx5video.c @ 1662:782fd950bd46 SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.
author Sam Lantinga <slouken@libsdl.org>
date Sun, 28 May 2006 13:04:16 +0000
parents 281d3f4870e5
children 4da1ee79c9af
comparison
equal deleted inserted replaced
1661:281d3f4870e5 1662:782fd950bd46
54 #define PC_NOCOLLAPSE 0 54 #define PC_NOCOLLAPSE 0
55 #endif 55 #endif
56 56
57 57
58 /* DirectX function pointers for video and events */ 58 /* DirectX function pointers for video and events */
59 HRESULT (WINAPI *DDrawCreate)( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter ); 59 HRESULT (WINAPI * DDrawCreate) (GUID FAR * lpGUID, LPDIRECTDRAW FAR * lplpDD,
60 HRESULT (WINAPI *DInputCreate)(HINSTANCE hinst, DWORD dwVersion, LPDIRECTINPUT *ppDI, LPUNKNOWN punkOuter); 60 IUnknown FAR * pUnkOuter);
61 HRESULT (WINAPI * DInputCreate) (HINSTANCE hinst, DWORD dwVersion,
62 LPDIRECTINPUT * ppDI, LPUNKNOWN punkOuter);
61 63
62 /* This is the rect EnumModes2 uses */ 64 /* This is the rect EnumModes2 uses */
63 struct DX5EnumRect { 65 struct DX5EnumRect
64 SDL_Rect r; 66 {
65 int refreshRate; 67 SDL_Rect r;
66 struct DX5EnumRect* next; 68 int refreshRate;
69 struct DX5EnumRect *next;
67 }; 70 };
68 static struct DX5EnumRect *enumlists[NUM_MODELISTS]; 71 static struct DX5EnumRect *enumlists[NUM_MODELISTS];
69 72
70 /* 73 /*
71 * Experimentally determined values for c_cfDI* constants used in DirectX 5.0 74 * Experimentally determined values for c_cfDI* constants used in DirectX 5.0
72 */ 75 */
73 76
74 /* Keyboard */ 77 /* Keyboard */
75 78
76 static DIOBJECTDATAFORMAT KBD_fmt[] = { 79 static DIOBJECTDATAFORMAT KBD_fmt[] = {
77 { &GUID_Key, 0, 0x8000000C, 0x00000000 }, 80 {&GUID_Key, 0, 0x8000000C, 0x00000000},
78 { &GUID_Key, 1, 0x8000010C, 0x00000000 }, 81 {&GUID_Key, 1, 0x8000010C, 0x00000000},
79 { &GUID_Key, 2, 0x8000020C, 0x00000000 }, 82 {&GUID_Key, 2, 0x8000020C, 0x00000000},
80 { &GUID_Key, 3, 0x8000030C, 0x00000000 }, 83 {&GUID_Key, 3, 0x8000030C, 0x00000000},
81 { &GUID_Key, 4, 0x8000040C, 0x00000000 }, 84 {&GUID_Key, 4, 0x8000040C, 0x00000000},
82 { &GUID_Key, 5, 0x8000050C, 0x00000000 }, 85 {&GUID_Key, 5, 0x8000050C, 0x00000000},
83 { &GUID_Key, 6, 0x8000060C, 0x00000000 }, 86 {&GUID_Key, 6, 0x8000060C, 0x00000000},
84 { &GUID_Key, 7, 0x8000070C, 0x00000000 }, 87 {&GUID_Key, 7, 0x8000070C, 0x00000000},
85 { &GUID_Key, 8, 0x8000080C, 0x00000000 }, 88 {&GUID_Key, 8, 0x8000080C, 0x00000000},
86 { &GUID_Key, 9, 0x8000090C, 0x00000000 }, 89 {&GUID_Key, 9, 0x8000090C, 0x00000000},
87 { &GUID_Key, 10, 0x80000A0C, 0x00000000 }, 90 {&GUID_Key, 10, 0x80000A0C, 0x00000000},
88 { &GUID_Key, 11, 0x80000B0C, 0x00000000 }, 91 {&GUID_Key, 11, 0x80000B0C, 0x00000000},
89 { &GUID_Key, 12, 0x80000C0C, 0x00000000 }, 92 {&GUID_Key, 12, 0x80000C0C, 0x00000000},
90 { &GUID_Key, 13, 0x80000D0C, 0x00000000 }, 93 {&GUID_Key, 13, 0x80000D0C, 0x00000000},
91 { &GUID_Key, 14, 0x80000E0C, 0x00000000 }, 94 {&GUID_Key, 14, 0x80000E0C, 0x00000000},
92 { &GUID_Key, 15, 0x80000F0C, 0x00000000 }, 95 {&GUID_Key, 15, 0x80000F0C, 0x00000000},
93 { &GUID_Key, 16, 0x8000100C, 0x00000000 }, 96 {&GUID_Key, 16, 0x8000100C, 0x00000000},
94 { &GUID_Key, 17, 0x8000110C, 0x00000000 }, 97 {&GUID_Key, 17, 0x8000110C, 0x00000000},
95 { &GUID_Key, 18, 0x8000120C, 0x00000000 }, 98 {&GUID_Key, 18, 0x8000120C, 0x00000000},
96 { &GUID_Key, 19, 0x8000130C, 0x00000000 }, 99 {&GUID_Key, 19, 0x8000130C, 0x00000000},
97 { &GUID_Key, 20, 0x8000140C, 0x00000000 }, 100 {&GUID_Key, 20, 0x8000140C, 0x00000000},
98 { &GUID_Key, 21, 0x8000150C, 0x00000000 }, 101 {&GUID_Key, 21, 0x8000150C, 0x00000000},
99 { &GUID_Key, 22, 0x8000160C, 0x00000000 }, 102 {&GUID_Key, 22, 0x8000160C, 0x00000000},
100 { &GUID_Key, 23, 0x8000170C, 0x00000000 }, 103 {&GUID_Key, 23, 0x8000170C, 0x00000000},
101 { &GUID_Key, 24, 0x8000180C, 0x00000000 }, 104 {&GUID_Key, 24, 0x8000180C, 0x00000000},
102 { &GUID_Key, 25, 0x8000190C, 0x00000000 }, 105 {&GUID_Key, 25, 0x8000190C, 0x00000000},
103 { &GUID_Key, 26, 0x80001A0C, 0x00000000 }, 106 {&GUID_Key, 26, 0x80001A0C, 0x00000000},
104 { &GUID_Key, 27, 0x80001B0C, 0x00000000 }, 107 {&GUID_Key, 27, 0x80001B0C, 0x00000000},
105 { &GUID_Key, 28, 0x80001C0C, 0x00000000 }, 108 {&GUID_Key, 28, 0x80001C0C, 0x00000000},
106 { &GUID_Key, 29, 0x80001D0C, 0x00000000 }, 109 {&GUID_Key, 29, 0x80001D0C, 0x00000000},
107 { &GUID_Key, 30, 0x80001E0C, 0x00000000 }, 110 {&GUID_Key, 30, 0x80001E0C, 0x00000000},
108 { &GUID_Key, 31, 0x80001F0C, 0x00000000 }, 111 {&GUID_Key, 31, 0x80001F0C, 0x00000000},
109 { &GUID_Key, 32, 0x8000200C, 0x00000000 }, 112 {&GUID_Key, 32, 0x8000200C, 0x00000000},
110 { &GUID_Key, 33, 0x8000210C, 0x00000000 }, 113 {&GUID_Key, 33, 0x8000210C, 0x00000000},
111 { &GUID_Key, 34, 0x8000220C, 0x00000000 }, 114 {&GUID_Key, 34, 0x8000220C, 0x00000000},
112 { &GUID_Key, 35, 0x8000230C, 0x00000000 }, 115 {&GUID_Key, 35, 0x8000230C, 0x00000000},
113 { &GUID_Key, 36, 0x8000240C, 0x00000000 }, 116 {&GUID_Key, 36, 0x8000240C, 0x00000000},
114 { &GUID_Key, 37, 0x8000250C, 0x00000000 }, 117 {&GUID_Key, 37, 0x8000250C, 0x00000000},
115 { &GUID_Key, 38, 0x8000260C, 0x00000000 }, 118 {&GUID_Key, 38, 0x8000260C, 0x00000000},
116 { &GUID_Key, 39, 0x8000270C, 0x00000000 }, 119 {&GUID_Key, 39, 0x8000270C, 0x00000000},
117 { &GUID_Key, 40, 0x8000280C, 0x00000000 }, 120 {&GUID_Key, 40, 0x8000280C, 0x00000000},
118 { &GUID_Key, 41, 0x8000290C, 0x00000000 }, 121 {&GUID_Key, 41, 0x8000290C, 0x00000000},
119 { &GUID_Key, 42, 0x80002A0C, 0x00000000 }, 122 {&GUID_Key, 42, 0x80002A0C, 0x00000000},
120 { &GUID_Key, 43, 0x80002B0C, 0x00000000 }, 123 {&GUID_Key, 43, 0x80002B0C, 0x00000000},
121 { &GUID_Key, 44, 0x80002C0C, 0x00000000 }, 124 {&GUID_Key, 44, 0x80002C0C, 0x00000000},
122 { &GUID_Key, 45, 0x80002D0C, 0x00000000 }, 125 {&GUID_Key, 45, 0x80002D0C, 0x00000000},
123 { &GUID_Key, 46, 0x80002E0C, 0x00000000 }, 126 {&GUID_Key, 46, 0x80002E0C, 0x00000000},
124 { &GUID_Key, 47, 0x80002F0C, 0x00000000 }, 127 {&GUID_Key, 47, 0x80002F0C, 0x00000000},
125 { &GUID_Key, 48, 0x8000300C, 0x00000000 }, 128 {&GUID_Key, 48, 0x8000300C, 0x00000000},
126 { &GUID_Key, 49, 0x8000310C, 0x00000000 }, 129 {&GUID_Key, 49, 0x8000310C, 0x00000000},
127 { &GUID_Key, 50, 0x8000320C, 0x00000000 }, 130 {&GUID_Key, 50, 0x8000320C, 0x00000000},
128 { &GUID_Key, 51, 0x8000330C, 0x00000000 }, 131 {&GUID_Key, 51, 0x8000330C, 0x00000000},
129 { &GUID_Key, 52, 0x8000340C, 0x00000000 }, 132 {&GUID_Key, 52, 0x8000340C, 0x00000000},
130 { &GUID_Key, 53, 0x8000350C, 0x00000000 }, 133 {&GUID_Key, 53, 0x8000350C, 0x00000000},
131 { &GUID_Key, 54, 0x8000360C, 0x00000000 }, 134 {&GUID_Key, 54, 0x8000360C, 0x00000000},
132 { &GUID_Key, 55, 0x8000370C, 0x00000000 }, 135 {&GUID_Key, 55, 0x8000370C, 0x00000000},
133 { &GUID_Key, 56, 0x8000380C, 0x00000000 }, 136 {&GUID_Key, 56, 0x8000380C, 0x00000000},
134 { &GUID_Key, 57, 0x8000390C, 0x00000000 }, 137 {&GUID_Key, 57, 0x8000390C, 0x00000000},
135 { &GUID_Key, 58, 0x80003A0C, 0x00000000 }, 138 {&GUID_Key, 58, 0x80003A0C, 0x00000000},
136 { &GUID_Key, 59, 0x80003B0C, 0x00000000 }, 139 {&GUID_Key, 59, 0x80003B0C, 0x00000000},
137 { &GUID_Key, 60, 0x80003C0C, 0x00000000 }, 140 {&GUID_Key, 60, 0x80003C0C, 0x00000000},
138 { &GUID_Key, 61, 0x80003D0C, 0x00000000 }, 141 {&GUID_Key, 61, 0x80003D0C, 0x00000000},
139 { &GUID_Key, 62, 0x80003E0C, 0x00000000 }, 142 {&GUID_Key, 62, 0x80003E0C, 0x00000000},
140 { &GUID_Key, 63, 0x80003F0C, 0x00000000 }, 143 {&GUID_Key, 63, 0x80003F0C, 0x00000000},
141 { &GUID_Key, 64, 0x8000400C, 0x00000000 }, 144 {&GUID_Key, 64, 0x8000400C, 0x00000000},
142 { &GUID_Key, 65, 0x8000410C, 0x00000000 }, 145 {&GUID_Key, 65, 0x8000410C, 0x00000000},
143 { &GUID_Key, 66, 0x8000420C, 0x00000000 }, 146 {&GUID_Key, 66, 0x8000420C, 0x00000000},
144 { &GUID_Key, 67, 0x8000430C, 0x00000000 }, 147 {&GUID_Key, 67, 0x8000430C, 0x00000000},
145 { &GUID_Key, 68, 0x8000440C, 0x00000000 }, 148 {&GUID_Key, 68, 0x8000440C, 0x00000000},
146 { &GUID_Key, 69, 0x8000450C, 0x00000000 }, 149 {&GUID_Key, 69, 0x8000450C, 0x00000000},
147 { &GUID_Key, 70, 0x8000460C, 0x00000000 }, 150 {&GUID_Key, 70, 0x8000460C, 0x00000000},
148 { &GUID_Key, 71, 0x8000470C, 0x00000000 }, 151 {&GUID_Key, 71, 0x8000470C, 0x00000000},
149 { &GUID_Key, 72, 0x8000480C, 0x00000000 }, 152 {&GUID_Key, 72, 0x8000480C, 0x00000000},
150 { &GUID_Key, 73, 0x8000490C, 0x00000000 }, 153 {&GUID_Key, 73, 0x8000490C, 0x00000000},
151 { &GUID_Key, 74, 0x80004A0C, 0x00000000 }, 154 {&GUID_Key, 74, 0x80004A0C, 0x00000000},
152 { &GUID_Key, 75, 0x80004B0C, 0x00000000 }, 155 {&GUID_Key, 75, 0x80004B0C, 0x00000000},
153 { &GUID_Key, 76, 0x80004C0C, 0x00000000 }, 156 {&GUID_Key, 76, 0x80004C0C, 0x00000000},
154 { &GUID_Key, 77, 0x80004D0C, 0x00000000 }, 157 {&GUID_Key, 77, 0x80004D0C, 0x00000000},
155 { &GUID_Key, 78, 0x80004E0C, 0x00000000 }, 158 {&GUID_Key, 78, 0x80004E0C, 0x00000000},
156 { &GUID_Key, 79, 0x80004F0C, 0x00000000 }, 159 {&GUID_Key, 79, 0x80004F0C, 0x00000000},
157 { &GUID_Key, 80, 0x8000500C, 0x00000000 }, 160 {&GUID_Key, 80, 0x8000500C, 0x00000000},
158 { &GUID_Key, 81, 0x8000510C, 0x00000000 }, 161 {&GUID_Key, 81, 0x8000510C, 0x00000000},
159 { &GUID_Key, 82, 0x8000520C, 0x00000000 }, 162 {&GUID_Key, 82, 0x8000520C, 0x00000000},
160 { &GUID_Key, 83, 0x8000530C, 0x00000000 }, 163 {&GUID_Key, 83, 0x8000530C, 0x00000000},
161 { &GUID_Key, 84, 0x8000540C, 0x00000000 }, 164 {&GUID_Key, 84, 0x8000540C, 0x00000000},
162 { &GUID_Key, 85, 0x8000550C, 0x00000000 }, 165 {&GUID_Key, 85, 0x8000550C, 0x00000000},
163 { &GUID_Key, 86, 0x8000560C, 0x00000000 }, 166 {&GUID_Key, 86, 0x8000560C, 0x00000000},
164 { &GUID_Key, 87, 0x8000570C, 0x00000000 }, 167 {&GUID_Key, 87, 0x8000570C, 0x00000000},
165 { &GUID_Key, 88, 0x8000580C, 0x00000000 }, 168 {&GUID_Key, 88, 0x8000580C, 0x00000000},
166 { &GUID_Key, 89, 0x8000590C, 0x00000000 }, 169 {&GUID_Key, 89, 0x8000590C, 0x00000000},
167 { &GUID_Key, 90, 0x80005A0C, 0x00000000 }, 170 {&GUID_Key, 90, 0x80005A0C, 0x00000000},
168 { &GUID_Key, 91, 0x80005B0C, 0x00000000 }, 171 {&GUID_Key, 91, 0x80005B0C, 0x00000000},
169 { &GUID_Key, 92, 0x80005C0C, 0x00000000 }, 172 {&GUID_Key, 92, 0x80005C0C, 0x00000000},
170 { &GUID_Key, 93, 0x80005D0C, 0x00000000 }, 173 {&GUID_Key, 93, 0x80005D0C, 0x00000000},
171 { &GUID_Key, 94, 0x80005E0C, 0x00000000 }, 174 {&GUID_Key, 94, 0x80005E0C, 0x00000000},
172 { &GUID_Key, 95, 0x80005F0C, 0x00000000 }, 175 {&GUID_Key, 95, 0x80005F0C, 0x00000000},
173 { &GUID_Key, 96, 0x8000600C, 0x00000000 }, 176 {&GUID_Key, 96, 0x8000600C, 0x00000000},
174 { &GUID_Key, 97, 0x8000610C, 0x00000000 }, 177 {&GUID_Key, 97, 0x8000610C, 0x00000000},
175 { &GUID_Key, 98, 0x8000620C, 0x00000000 }, 178 {&GUID_Key, 98, 0x8000620C, 0x00000000},
176 { &GUID_Key, 99, 0x8000630C, 0x00000000 }, 179 {&GUID_Key, 99, 0x8000630C, 0x00000000},
177 { &GUID_Key, 100, 0x8000640C, 0x00000000 }, 180 {&GUID_Key, 100, 0x8000640C, 0x00000000},
178 { &GUID_Key, 101, 0x8000650C, 0x00000000 }, 181 {&GUID_Key, 101, 0x8000650C, 0x00000000},
179 { &GUID_Key, 102, 0x8000660C, 0x00000000 }, 182 {&GUID_Key, 102, 0x8000660C, 0x00000000},
180 { &GUID_Key, 103, 0x8000670C, 0x00000000 }, 183 {&GUID_Key, 103, 0x8000670C, 0x00000000},
181 { &GUID_Key, 104, 0x8000680C, 0x00000000 }, 184 {&GUID_Key, 104, 0x8000680C, 0x00000000},
182 { &GUID_Key, 105, 0x8000690C, 0x00000000 }, 185 {&GUID_Key, 105, 0x8000690C, 0x00000000},
183 { &GUID_Key, 106, 0x80006A0C, 0x00000000 }, 186 {&GUID_Key, 106, 0x80006A0C, 0x00000000},
184 { &GUID_Key, 107, 0x80006B0C, 0x00000000 }, 187 {&GUID_Key, 107, 0x80006B0C, 0x00000000},
185 { &GUID_Key, 108, 0x80006C0C, 0x00000000 }, 188 {&GUID_Key, 108, 0x80006C0C, 0x00000000},
186 { &GUID_Key, 109, 0x80006D0C, 0x00000000 }, 189 {&GUID_Key, 109, 0x80006D0C, 0x00000000},
187 { &GUID_Key, 110, 0x80006E0C, 0x00000000 }, 190 {&GUID_Key, 110, 0x80006E0C, 0x00000000},
188 { &GUID_Key, 111, 0x80006F0C, 0x00000000 }, 191 {&GUID_Key, 111, 0x80006F0C, 0x00000000},
189 { &GUID_Key, 112, 0x8000700C, 0x00000000 }, 192 {&GUID_Key, 112, 0x8000700C, 0x00000000},
190 { &GUID_Key, 113, 0x8000710C, 0x00000000 }, 193 {&GUID_Key, 113, 0x8000710C, 0x00000000},
191 { &GUID_Key, 114, 0x8000720C, 0x00000000 }, 194 {&GUID_Key, 114, 0x8000720C, 0x00000000},
192 { &GUID_Key, 115, 0x8000730C, 0x00000000 }, 195 {&GUID_Key, 115, 0x8000730C, 0x00000000},
193 { &GUID_Key, 116, 0x8000740C, 0x00000000 }, 196 {&GUID_Key, 116, 0x8000740C, 0x00000000},
194 { &GUID_Key, 117, 0x8000750C, 0x00000000 }, 197 {&GUID_Key, 117, 0x8000750C, 0x00000000},
195 { &GUID_Key, 118, 0x8000760C, 0x00000000 }, 198 {&GUID_Key, 118, 0x8000760C, 0x00000000},
196 { &GUID_Key, 119, 0x8000770C, 0x00000000 }, 199 {&GUID_Key, 119, 0x8000770C, 0x00000000},
197 { &GUID_Key, 120, 0x8000780C, 0x00000000 }, 200 {&GUID_Key, 120, 0x8000780C, 0x00000000},
198 { &GUID_Key, 121, 0x8000790C, 0x00000000 }, 201 {&GUID_Key, 121, 0x8000790C, 0x00000000},
199 { &GUID_Key, 122, 0x80007A0C, 0x00000000 }, 202 {&GUID_Key, 122, 0x80007A0C, 0x00000000},
200 { &GUID_Key, 123, 0x80007B0C, 0x00000000 }, 203 {&GUID_Key, 123, 0x80007B0C, 0x00000000},
201 { &GUID_Key, 124, 0x80007C0C, 0x00000000 }, 204 {&GUID_Key, 124, 0x80007C0C, 0x00000000},
202 { &GUID_Key, 125, 0x80007D0C, 0x00000000 }, 205 {&GUID_Key, 125, 0x80007D0C, 0x00000000},
203 { &GUID_Key, 126, 0x80007E0C, 0x00000000 }, 206 {&GUID_Key, 126, 0x80007E0C, 0x00000000},
204 { &GUID_Key, 127, 0x80007F0C, 0x00000000 }, 207 {&GUID_Key, 127, 0x80007F0C, 0x00000000},
205 { &GUID_Key, 128, 0x8000800C, 0x00000000 }, 208 {&GUID_Key, 128, 0x8000800C, 0x00000000},
206 { &GUID_Key, 129, 0x8000810C, 0x00000000 }, 209 {&GUID_Key, 129, 0x8000810C, 0x00000000},
207 { &GUID_Key, 130, 0x8000820C, 0x00000000 }, 210 {&GUID_Key, 130, 0x8000820C, 0x00000000},
208 { &GUID_Key, 131, 0x8000830C, 0x00000000 }, 211 {&GUID_Key, 131, 0x8000830C, 0x00000000},
209 { &GUID_Key, 132, 0x8000840C, 0x00000000 }, 212 {&GUID_Key, 132, 0x8000840C, 0x00000000},
210 { &GUID_Key, 133, 0x8000850C, 0x00000000 }, 213 {&GUID_Key, 133, 0x8000850C, 0x00000000},
211 { &GUID_Key, 134, 0x8000860C, 0x00000000 }, 214 {&GUID_Key, 134, 0x8000860C, 0x00000000},
212 { &GUID_Key, 135, 0x8000870C, 0x00000000 }, 215 {&GUID_Key, 135, 0x8000870C, 0x00000000},
213 { &GUID_Key, 136, 0x8000880C, 0x00000000 }, 216 {&GUID_Key, 136, 0x8000880C, 0x00000000},
214 { &GUID_Key, 137, 0x8000890C, 0x00000000 }, 217 {&GUID_Key, 137, 0x8000890C, 0x00000000},
215 { &GUID_Key, 138, 0x80008A0C, 0x00000000 }, 218 {&GUID_Key, 138, 0x80008A0C, 0x00000000},
216 { &GUID_Key, 139, 0x80008B0C, 0x00000000 }, 219 {&GUID_Key, 139, 0x80008B0C, 0x00000000},
217 { &GUID_Key, 140, 0x80008C0C, 0x00000000 }, 220 {&GUID_Key, 140, 0x80008C0C, 0x00000000},
218 { &GUID_Key, 141, 0x80008D0C, 0x00000000 }, 221 {&GUID_Key, 141, 0x80008D0C, 0x00000000},
219 { &GUID_Key, 142, 0x80008E0C, 0x00000000 }, 222 {&GUID_Key, 142, 0x80008E0C, 0x00000000},
220 { &GUID_Key, 143, 0x80008F0C, 0x00000000 }, 223 {&GUID_Key, 143, 0x80008F0C, 0x00000000},
221 { &GUID_Key, 144, 0x8000900C, 0x00000000 }, 224 {&GUID_Key, 144, 0x8000900C, 0x00000000},
222 { &GUID_Key, 145, 0x8000910C, 0x00000000 }, 225 {&GUID_Key, 145, 0x8000910C, 0x00000000},
223 { &GUID_Key, 146, 0x8000920C, 0x00000000 }, 226 {&GUID_Key, 146, 0x8000920C, 0x00000000},
224 { &GUID_Key, 147, 0x8000930C, 0x00000000 }, 227 {&GUID_Key, 147, 0x8000930C, 0x00000000},
225 { &GUID_Key, 148, 0x8000940C, 0x00000000 }, 228 {&GUID_Key, 148, 0x8000940C, 0x00000000},
226 { &GUID_Key, 149, 0x8000950C, 0x00000000 }, 229 {&GUID_Key, 149, 0x8000950C, 0x00000000},
227 { &GUID_Key, 150, 0x8000960C, 0x00000000 }, 230 {&GUID_Key, 150, 0x8000960C, 0x00000000},
228 { &GUID_Key, 151, 0x8000970C, 0x00000000 }, 231 {&GUID_Key, 151, 0x8000970C, 0x00000000},
229 { &GUID_Key, 152, 0x8000980C, 0x00000000 }, 232 {&GUID_Key, 152, 0x8000980C, 0x00000000},
230 { &GUID_Key, 153, 0x8000990C, 0x00000000 }, 233 {&GUID_Key, 153, 0x8000990C, 0x00000000},
231 { &GUID_Key, 154, 0x80009A0C, 0x00000000 }, 234 {&GUID_Key, 154, 0x80009A0C, 0x00000000},
232 { &GUID_Key, 155, 0x80009B0C, 0x00000000 }, 235 {&GUID_Key, 155, 0x80009B0C, 0x00000000},
233 { &GUID_Key, 156, 0x80009C0C, 0x00000000 }, 236 {&GUID_Key, 156, 0x80009C0C, 0x00000000},
234 { &GUID_Key, 157, 0x80009D0C, 0x00000000 }, 237 {&GUID_Key, 157, 0x80009D0C, 0x00000000},
235 { &GUID_Key, 158, 0x80009E0C, 0x00000000 }, 238 {&GUID_Key, 158, 0x80009E0C, 0x00000000},
236 { &GUID_Key, 159, 0x80009F0C, 0x00000000 }, 239 {&GUID_Key, 159, 0x80009F0C, 0x00000000},
237 { &GUID_Key, 160, 0x8000A00C, 0x00000000 }, 240 {&GUID_Key, 160, 0x8000A00C, 0x00000000},
238 { &GUID_Key, 161, 0x8000A10C, 0x00000000 }, 241 {&GUID_Key, 161, 0x8000A10C, 0x00000000},
239 { &GUID_Key, 162, 0x8000A20C, 0x00000000 }, 242 {&GUID_Key, 162, 0x8000A20C, 0x00000000},
240 { &GUID_Key, 163, 0x8000A30C, 0x00000000 }, 243 {&GUID_Key, 163, 0x8000A30C, 0x00000000},
241 { &GUID_Key, 164, 0x8000A40C, 0x00000000 }, 244 {&GUID_Key, 164, 0x8000A40C, 0x00000000},
242 { &GUID_Key, 165, 0x8000A50C, 0x00000000 }, 245 {&GUID_Key, 165, 0x8000A50C, 0x00000000},
243 { &GUID_Key, 166, 0x8000A60C, 0x00000000 }, 246 {&GUID_Key, 166, 0x8000A60C, 0x00000000},
244 { &GUID_Key, 167, 0x8000A70C, 0x00000000 }, 247 {&GUID_Key, 167, 0x8000A70C, 0x00000000},
245 { &GUID_Key, 168, 0x8000A80C, 0x00000000 }, 248 {&GUID_Key, 168, 0x8000A80C, 0x00000000},
246 { &GUID_Key, 169, 0x8000A90C, 0x00000000 }, 249 {&GUID_Key, 169, 0x8000A90C, 0x00000000},
247 { &GUID_Key, 170, 0x8000AA0C, 0x00000000 }, 250 {&GUID_Key, 170, 0x8000AA0C, 0x00000000},
248 { &GUID_Key, 171, 0x8000AB0C, 0x00000000 }, 251 {&GUID_Key, 171, 0x8000AB0C, 0x00000000},
249 { &GUID_Key, 172, 0x8000AC0C, 0x00000000 }, 252 {&GUID_Key, 172, 0x8000AC0C, 0x00000000},
250 { &GUID_Key, 173, 0x8000AD0C, 0x00000000 }, 253 {&GUID_Key, 173, 0x8000AD0C, 0x00000000},
251 { &GUID_Key, 174, 0x8000AE0C, 0x00000000 }, 254 {&GUID_Key, 174, 0x8000AE0C, 0x00000000},
252 { &GUID_Key, 175, 0x8000AF0C, 0x00000000 }, 255 {&GUID_Key, 175, 0x8000AF0C, 0x00000000},
253 { &GUID_Key, 176, 0x8000B00C, 0x00000000 }, 256 {&GUID_Key, 176, 0x8000B00C, 0x00000000},
254 { &GUID_Key, 177, 0x8000B10C, 0x00000000 }, 257 {&GUID_Key, 177, 0x8000B10C, 0x00000000},
255 { &GUID_Key, 178, 0x8000B20C, 0x00000000 }, 258 {&GUID_Key, 178, 0x8000B20C, 0x00000000},
256 { &GUID_Key, 179, 0x8000B30C, 0x00000000 }, 259 {&GUID_Key, 179, 0x8000B30C, 0x00000000},
257 { &GUID_Key, 180, 0x8000B40C, 0x00000000 }, 260 {&GUID_Key, 180, 0x8000B40C, 0x00000000},
258 { &GUID_Key, 181, 0x8000B50C, 0x00000000 }, 261 {&GUID_Key, 181, 0x8000B50C, 0x00000000},
259 { &GUID_Key, 182, 0x8000B60C, 0x00000000 }, 262 {&GUID_Key, 182, 0x8000B60C, 0x00000000},
260 { &GUID_Key, 183, 0x8000B70C, 0x00000000 }, 263 {&GUID_Key, 183, 0x8000B70C, 0x00000000},
261 { &GUID_Key, 184, 0x8000B80C, 0x00000000 }, 264 {&GUID_Key, 184, 0x8000B80C, 0x00000000},
262 { &GUID_Key, 185, 0x8000B90C, 0x00000000 }, 265 {&GUID_Key, 185, 0x8000B90C, 0x00000000},
263 { &GUID_Key, 186, 0x8000BA0C, 0x00000000 }, 266 {&GUID_Key, 186, 0x8000BA0C, 0x00000000},
264 { &GUID_Key, 187, 0x8000BB0C, 0x00000000 }, 267 {&GUID_Key, 187, 0x8000BB0C, 0x00000000},
265 { &GUID_Key, 188, 0x8000BC0C, 0x00000000 }, 268 {&GUID_Key, 188, 0x8000BC0C, 0x00000000},
266 { &GUID_Key, 189, 0x8000BD0C, 0x00000000 }, 269 {&GUID_Key, 189, 0x8000BD0C, 0x00000000},
267 { &GUID_Key, 190, 0x8000BE0C, 0x00000000 }, 270 {&GUID_Key, 190, 0x8000BE0C, 0x00000000},
268 { &GUID_Key, 191, 0x8000BF0C, 0x00000000 }, 271 {&GUID_Key, 191, 0x8000BF0C, 0x00000000},
269 { &GUID_Key, 192, 0x8000C00C, 0x00000000 }, 272 {&GUID_Key, 192, 0x8000C00C, 0x00000000},
270 { &GUID_Key, 193, 0x8000C10C, 0x00000000 }, 273 {&GUID_Key, 193, 0x8000C10C, 0x00000000},
271 { &GUID_Key, 194, 0x8000C20C, 0x00000000 }, 274 {&GUID_Key, 194, 0x8000C20C, 0x00000000},
272 { &GUID_Key, 195, 0x8000C30C, 0x00000000 }, 275 {&GUID_Key, 195, 0x8000C30C, 0x00000000},
273 { &GUID_Key, 196, 0x8000C40C, 0x00000000 }, 276 {&GUID_Key, 196, 0x8000C40C, 0x00000000},
274 { &GUID_Key, 197, 0x8000C50C, 0x00000000 }, 277 {&GUID_Key, 197, 0x8000C50C, 0x00000000},
275 { &GUID_Key, 198, 0x8000C60C, 0x00000000 }, 278 {&GUID_Key, 198, 0x8000C60C, 0x00000000},
276 { &GUID_Key, 199, 0x8000C70C, 0x00000000 }, 279 {&GUID_Key, 199, 0x8000C70C, 0x00000000},
277 { &GUID_Key, 200, 0x8000C80C, 0x00000000 }, 280 {&GUID_Key, 200, 0x8000C80C, 0x00000000},
278 { &GUID_Key, 201, 0x8000C90C, 0x00000000 }, 281 {&GUID_Key, 201, 0x8000C90C, 0x00000000},
279 { &GUID_Key, 202, 0x8000CA0C, 0x00000000 }, 282 {&GUID_Key, 202, 0x8000CA0C, 0x00000000},
280 { &GUID_Key, 203, 0x8000CB0C, 0x00000000 }, 283 {&GUID_Key, 203, 0x8000CB0C, 0x00000000},
281 { &GUID_Key, 204, 0x8000CC0C, 0x00000000 }, 284 {&GUID_Key, 204, 0x8000CC0C, 0x00000000},
282 { &GUID_Key, 205, 0x8000CD0C, 0x00000000 }, 285 {&GUID_Key, 205, 0x8000CD0C, 0x00000000},
283 { &GUID_Key, 206, 0x8000CE0C, 0x00000000 }, 286 {&GUID_Key, 206, 0x8000CE0C, 0x00000000},
284 { &GUID_Key, 207, 0x8000CF0C, 0x00000000 }, 287 {&GUID_Key, 207, 0x8000CF0C, 0x00000000},
285 { &GUID_Key, 208, 0x8000D00C, 0x00000000 }, 288 {&GUID_Key, 208, 0x8000D00C, 0x00000000},
286 { &GUID_Key, 209, 0x8000D10C, 0x00000000 }, 289 {&GUID_Key, 209, 0x8000D10C, 0x00000000},
287 { &GUID_Key, 210, 0x8000D20C, 0x00000000 }, 290 {&GUID_Key, 210, 0x8000D20C, 0x00000000},
288 { &GUID_Key, 211, 0x8000D30C, 0x00000000 }, 291 {&GUID_Key, 211, 0x8000D30C, 0x00000000},
289 { &GUID_Key, 212, 0x8000D40C, 0x00000000 }, 292 {&GUID_Key, 212, 0x8000D40C, 0x00000000},
290 { &GUID_Key, 213, 0x8000D50C, 0x00000000 }, 293 {&GUID_Key, 213, 0x8000D50C, 0x00000000},
291 { &GUID_Key, 214, 0x8000D60C, 0x00000000 }, 294 {&GUID_Key, 214, 0x8000D60C, 0x00000000},
292 { &GUID_Key, 215, 0x8000D70C, 0x00000000 }, 295 {&GUID_Key, 215, 0x8000D70C, 0x00000000},
293 { &GUID_Key, 216, 0x8000D80C, 0x00000000 }, 296 {&GUID_Key, 216, 0x8000D80C, 0x00000000},
294 { &GUID_Key, 217, 0x8000D90C, 0x00000000 }, 297 {&GUID_Key, 217, 0x8000D90C, 0x00000000},
295 { &GUID_Key, 218, 0x8000DA0C, 0x00000000 }, 298 {&GUID_Key, 218, 0x8000DA0C, 0x00000000},
296 { &GUID_Key, 219, 0x8000DB0C, 0x00000000 }, 299 {&GUID_Key, 219, 0x8000DB0C, 0x00000000},
297 { &GUID_Key, 220, 0x8000DC0C, 0x00000000 }, 300 {&GUID_Key, 220, 0x8000DC0C, 0x00000000},
298 { &GUID_Key, 221, 0x8000DD0C, 0x00000000 }, 301 {&GUID_Key, 221, 0x8000DD0C, 0x00000000},
299 { &GUID_Key, 222, 0x8000DE0C, 0x00000000 }, 302 {&GUID_Key, 222, 0x8000DE0C, 0x00000000},
300 { &GUID_Key, 223, 0x8000DF0C, 0x00000000 }, 303 {&GUID_Key, 223, 0x8000DF0C, 0x00000000},
301 { &GUID_Key, 224, 0x8000E00C, 0x00000000 }, 304 {&GUID_Key, 224, 0x8000E00C, 0x00000000},
302 { &GUID_Key, 225, 0x8000E10C, 0x00000000 }, 305 {&GUID_Key, 225, 0x8000E10C, 0x00000000},
303 { &GUID_Key, 226, 0x8000E20C, 0x00000000 }, 306 {&GUID_Key, 226, 0x8000E20C, 0x00000000},
304 { &GUID_Key, 227, 0x8000E30C, 0x00000000 }, 307 {&GUID_Key, 227, 0x8000E30C, 0x00000000},
305 { &GUID_Key, 228, 0x8000E40C, 0x00000000 }, 308 {&GUID_Key, 228, 0x8000E40C, 0x00000000},
306 { &GUID_Key, 229, 0x8000E50C, 0x00000000 }, 309 {&GUID_Key, 229, 0x8000E50C, 0x00000000},
307 { &GUID_Key, 230, 0x8000E60C, 0x00000000 }, 310 {&GUID_Key, 230, 0x8000E60C, 0x00000000},
308 { &GUID_Key, 231, 0x8000E70C, 0x00000000 }, 311 {&GUID_Key, 231, 0x8000E70C, 0x00000000},
309 { &GUID_Key, 232, 0x8000E80C, 0x00000000 }, 312 {&GUID_Key, 232, 0x8000E80C, 0x00000000},
310 { &GUID_Key, 233, 0x8000E90C, 0x00000000 }, 313 {&GUID_Key, 233, 0x8000E90C, 0x00000000},
311 { &GUID_Key, 234, 0x8000EA0C, 0x00000000 }, 314 {&GUID_Key, 234, 0x8000EA0C, 0x00000000},
312 { &GUID_Key, 235, 0x8000EB0C, 0x00000000 }, 315 {&GUID_Key, 235, 0x8000EB0C, 0x00000000},
313 { &GUID_Key, 236, 0x8000EC0C, 0x00000000 }, 316 {&GUID_Key, 236, 0x8000EC0C, 0x00000000},
314 { &GUID_Key, 237, 0x8000ED0C, 0x00000000 }, 317 {&GUID_Key, 237, 0x8000ED0C, 0x00000000},
315 { &GUID_Key, 238, 0x8000EE0C, 0x00000000 }, 318 {&GUID_Key, 238, 0x8000EE0C, 0x00000000},
316 { &GUID_Key, 239, 0x8000EF0C, 0x00000000 }, 319 {&GUID_Key, 239, 0x8000EF0C, 0x00000000},
317 { &GUID_Key, 240, 0x8000F00C, 0x00000000 }, 320 {&GUID_Key, 240, 0x8000F00C, 0x00000000},
318 { &GUID_Key, 241, 0x8000F10C, 0x00000000 }, 321 {&GUID_Key, 241, 0x8000F10C, 0x00000000},
319 { &GUID_Key, 242, 0x8000F20C, 0x00000000 }, 322 {&GUID_Key, 242, 0x8000F20C, 0x00000000},
320 { &GUID_Key, 243, 0x8000F30C, 0x00000000 }, 323 {&GUID_Key, 243, 0x8000F30C, 0x00000000},
321 { &GUID_Key, 244, 0x8000F40C, 0x00000000 }, 324 {&GUID_Key, 244, 0x8000F40C, 0x00000000},
322 { &GUID_Key, 245, 0x8000F50C, 0x00000000 }, 325 {&GUID_Key, 245, 0x8000F50C, 0x00000000},
323 { &GUID_Key, 246, 0x8000F60C, 0x00000000 }, 326 {&GUID_Key, 246, 0x8000F60C, 0x00000000},
324 { &GUID_Key, 247, 0x8000F70C, 0x00000000 }, 327 {&GUID_Key, 247, 0x8000F70C, 0x00000000},
325 { &GUID_Key, 248, 0x8000F80C, 0x00000000 }, 328 {&GUID_Key, 248, 0x8000F80C, 0x00000000},
326 { &GUID_Key, 249, 0x8000F90C, 0x00000000 }, 329 {&GUID_Key, 249, 0x8000F90C, 0x00000000},
327 { &GUID_Key, 250, 0x8000FA0C, 0x00000000 }, 330 {&GUID_Key, 250, 0x8000FA0C, 0x00000000},
328 { &GUID_Key, 251, 0x8000FB0C, 0x00000000 }, 331 {&GUID_Key, 251, 0x8000FB0C, 0x00000000},
329 { &GUID_Key, 252, 0x8000FC0C, 0x00000000 }, 332 {&GUID_Key, 252, 0x8000FC0C, 0x00000000},
330 { &GUID_Key, 253, 0x8000FD0C, 0x00000000 }, 333 {&GUID_Key, 253, 0x8000FD0C, 0x00000000},
331 { &GUID_Key, 254, 0x8000FE0C, 0x00000000 }, 334 {&GUID_Key, 254, 0x8000FE0C, 0x00000000},
332 { &GUID_Key, 255, 0x8000FF0C, 0x00000000 }, 335 {&GUID_Key, 255, 0x8000FF0C, 0x00000000},
333 }; 336 };
334 337
335 const DIDATAFORMAT c_dfDIKeyboard = { 24, 16, 0x00000002, 256, 256, KBD_fmt }; 338 const DIDATAFORMAT c_dfDIKeyboard = { 24, 16, 0x00000002, 256, 256, KBD_fmt };
336 339
337 340
338 /* Mouse */ 341 /* Mouse */
339 342
340 static DIOBJECTDATAFORMAT PTR_fmt[] = { 343 static DIOBJECTDATAFORMAT PTR_fmt[] = {
341 { &GUID_XAxis, 0, 0x00FFFF03, 0x00000000 }, 344 {&GUID_XAxis, 0, 0x00FFFF03, 0x00000000},
342 { &GUID_YAxis, 4, 0x00FFFF03, 0x00000000 }, 345 {&GUID_YAxis, 4, 0x00FFFF03, 0x00000000},
343 { &GUID_ZAxis, 8, 0x80FFFF03, 0x00000000 }, 346 {&GUID_ZAxis, 8, 0x80FFFF03, 0x00000000},
344 { NULL, 12, 0x00FFFF0C, 0x00000000 }, 347 {NULL, 12, 0x00FFFF0C, 0x00000000},
345 { NULL, 13, 0x00FFFF0C, 0x00000000 }, 348 {NULL, 13, 0x00FFFF0C, 0x00000000},
346 { NULL, 14, 0x80FFFF0C, 0x00000000 }, 349 {NULL, 14, 0x80FFFF0C, 0x00000000},
347 { NULL, 15, 0x80FFFF0C, 0x00000000 }, 350 {NULL, 15, 0x80FFFF0C, 0x00000000},
348 }; 351 };
349 352
350 const DIDATAFORMAT c_dfDIMouse = { 24, 16, 0x00000002, 16, 7, PTR_fmt }; 353 const DIDATAFORMAT c_dfDIMouse = { 24, 16, 0x00000002, 16, 7, PTR_fmt };
351 354
352 355
353 /* Joystick */ 356 /* Joystick */
354 357
355 static DIOBJECTDATAFORMAT JOY_fmt[] = { 358 static DIOBJECTDATAFORMAT JOY_fmt[] = {
356 { &GUID_XAxis, 0, 0x80FFFF03, 0x00000100 }, 359 {&GUID_XAxis, 0, 0x80FFFF03, 0x00000100},
357 { &GUID_YAxis, 4, 0x80FFFF03, 0x00000100 }, 360 {&GUID_YAxis, 4, 0x80FFFF03, 0x00000100},
358 { &GUID_ZAxis, 8, 0x80FFFF03, 0x00000100 }, 361 {&GUID_ZAxis, 8, 0x80FFFF03, 0x00000100},
359 { &GUID_RxAxis, 12, 0x80FFFF03, 0x00000100 }, 362 {&GUID_RxAxis, 12, 0x80FFFF03, 0x00000100},
360 { &GUID_RyAxis, 16, 0x80FFFF03, 0x00000100 }, 363 {&GUID_RyAxis, 16, 0x80FFFF03, 0x00000100},
361 { &GUID_RzAxis, 20, 0x80FFFF03, 0x00000100 }, 364 {&GUID_RzAxis, 20, 0x80FFFF03, 0x00000100},
362 { &GUID_Slider, 24, 0x80FFFF03, 0x00000100 }, 365 {&GUID_Slider, 24, 0x80FFFF03, 0x00000100},
363 { &GUID_Slider, 28, 0x80FFFF03, 0x00000100 }, 366 {&GUID_Slider, 28, 0x80FFFF03, 0x00000100},
364 { &GUID_POV, 32, 0x80FFFF10, 0x00000000 }, 367 {&GUID_POV, 32, 0x80FFFF10, 0x00000000},
365 { &GUID_POV, 36, 0x80FFFF10, 0x00000000 }, 368 {&GUID_POV, 36, 0x80FFFF10, 0x00000000},
366 { &GUID_POV, 40, 0x80FFFF10, 0x00000000 }, 369 {&GUID_POV, 40, 0x80FFFF10, 0x00000000},
367 { &GUID_POV, 44, 0x80FFFF10, 0x00000000 }, 370 {&GUID_POV, 44, 0x80FFFF10, 0x00000000},
368 { NULL, 48, 0x80FFFF0C, 0x00000000 }, 371 {NULL, 48, 0x80FFFF0C, 0x00000000},
369 { NULL, 49, 0x80FFFF0C, 0x00000000 }, 372 {NULL, 49, 0x80FFFF0C, 0x00000000},
370 { NULL, 50, 0x80FFFF0C, 0x00000000 }, 373 {NULL, 50, 0x80FFFF0C, 0x00000000},
371 { NULL, 51, 0x80FFFF0C, 0x00000000 }, 374 {NULL, 51, 0x80FFFF0C, 0x00000000},
372 { NULL, 52, 0x80FFFF0C, 0x00000000 }, 375 {NULL, 52, 0x80FFFF0C, 0x00000000},
373 { NULL, 53, 0x80FFFF0C, 0x00000000 }, 376 {NULL, 53, 0x80FFFF0C, 0x00000000},
374 { NULL, 54, 0x80FFFF0C, 0x00000000 }, 377 {NULL, 54, 0x80FFFF0C, 0x00000000},
375 { NULL, 55, 0x80FFFF0C, 0x00000000 }, 378 {NULL, 55, 0x80FFFF0C, 0x00000000},
376 { NULL, 56, 0x80FFFF0C, 0x00000000 }, 379 {NULL, 56, 0x80FFFF0C, 0x00000000},
377 { NULL, 57, 0x80FFFF0C, 0x00000000 }, 380 {NULL, 57, 0x80FFFF0C, 0x00000000},
378 { NULL, 58, 0x80FFFF0C, 0x00000000 }, 381 {NULL, 58, 0x80FFFF0C, 0x00000000},
379 { NULL, 59, 0x80FFFF0C, 0x00000000 }, 382 {NULL, 59, 0x80FFFF0C, 0x00000000},
380 { NULL, 60, 0x80FFFF0C, 0x00000000 }, 383 {NULL, 60, 0x80FFFF0C, 0x00000000},
381 { NULL, 61, 0x80FFFF0C, 0x00000000 }, 384 {NULL, 61, 0x80FFFF0C, 0x00000000},
382 { NULL, 62, 0x80FFFF0C, 0x00000000 }, 385 {NULL, 62, 0x80FFFF0C, 0x00000000},
383 { NULL, 63, 0x80FFFF0C, 0x00000000 }, 386 {NULL, 63, 0x80FFFF0C, 0x00000000},
384 { NULL, 64, 0x80FFFF0C, 0x00000000 }, 387 {NULL, 64, 0x80FFFF0C, 0x00000000},
385 { NULL, 65, 0x80FFFF0C, 0x00000000 }, 388 {NULL, 65, 0x80FFFF0C, 0x00000000},
386 { NULL, 66, 0x80FFFF0C, 0x00000000 }, 389 {NULL, 66, 0x80FFFF0C, 0x00000000},
387 { NULL, 67, 0x80FFFF0C, 0x00000000 }, 390 {NULL, 67, 0x80FFFF0C, 0x00000000},
388 { NULL, 68, 0x80FFFF0C, 0x00000000 }, 391 {NULL, 68, 0x80FFFF0C, 0x00000000},
389 { NULL, 69, 0x80FFFF0C, 0x00000000 }, 392 {NULL, 69, 0x80FFFF0C, 0x00000000},
390 { NULL, 70, 0x80FFFF0C, 0x00000000 }, 393 {NULL, 70, 0x80FFFF0C, 0x00000000},
391 { NULL, 71, 0x80FFFF0C, 0x00000000 }, 394 {NULL, 71, 0x80FFFF0C, 0x00000000},
392 { NULL, 72, 0x80FFFF0C, 0x00000000 }, 395 {NULL, 72, 0x80FFFF0C, 0x00000000},
393 { NULL, 73, 0x80FFFF0C, 0x00000000 }, 396 {NULL, 73, 0x80FFFF0C, 0x00000000},
394 { NULL, 74, 0x80FFFF0C, 0x00000000 }, 397 {NULL, 74, 0x80FFFF0C, 0x00000000},
395 { NULL, 75, 0x80FFFF0C, 0x00000000 }, 398 {NULL, 75, 0x80FFFF0C, 0x00000000},
396 { NULL, 76, 0x80FFFF0C, 0x00000000 }, 399 {NULL, 76, 0x80FFFF0C, 0x00000000},
397 { NULL, 77, 0x80FFFF0C, 0x00000000 }, 400 {NULL, 77, 0x80FFFF0C, 0x00000000},
398 { NULL, 78, 0x80FFFF0C, 0x00000000 }, 401 {NULL, 78, 0x80FFFF0C, 0x00000000},
399 { NULL, 79, 0x80FFFF0C, 0x00000000 }, 402 {NULL, 79, 0x80FFFF0C, 0x00000000},
400 }; 403 };
401 404
402 const DIDATAFORMAT c_dfDIJoystick = { 24, 16, 0x00000001, 80, 44, JOY_fmt }; 405 const DIDATAFORMAT c_dfDIJoystick = { 24, 16, 0x00000001, 80, 44, JOY_fmt };
403 406
404 407
405 /* Initialization/Query functions */ 408 /* Initialization/Query functions */
406 static int DX5_VideoInit(_THIS, SDL_PixelFormat *vformat); 409 static int DX5_VideoInit (_THIS, SDL_PixelFormat * vformat);
407 static SDL_Rect **DX5_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); 410 static SDL_Rect **DX5_ListModes (_THIS, SDL_PixelFormat * format,
408 static SDL_Surface *DX5_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); 411 Uint32 flags);
409 static int DX5_SetColors(_THIS, int firstcolor, int ncolors, 412 static SDL_Surface *DX5_SetVideoMode (_THIS, SDL_Surface * current, int width,
410 SDL_Color *colors); 413 int height, int bpp, Uint32 flags);
411 static int DX5_SetGammaRamp(_THIS, Uint16 *ramp); 414 static int DX5_SetColors (_THIS, int firstcolor, int ncolors,
412 static int DX5_GetGammaRamp(_THIS, Uint16 *ramp); 415 SDL_Color * colors);
413 static void DX5_VideoQuit(_THIS); 416 static int DX5_SetGammaRamp (_THIS, Uint16 * ramp);
417 static int DX5_GetGammaRamp (_THIS, Uint16 * ramp);
418 static void DX5_VideoQuit (_THIS);
414 419
415 /* Hardware surface functions */ 420 /* Hardware surface functions */
416 static int DX5_AllocHWSurface(_THIS, SDL_Surface *surface); 421 static int DX5_AllocHWSurface (_THIS, SDL_Surface * surface);
417 static int DX5_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst); 422 static int DX5_CheckHWBlit (_THIS, SDL_Surface * src, SDL_Surface * dst);
418 static int DX5_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color); 423 static int DX5_FillHWRect (_THIS, SDL_Surface * dst, SDL_Rect * dstrect,
419 static int DX5_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key); 424 Uint32 color);
420 static int DX5_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha); 425 static int DX5_SetHWColorKey (_THIS, SDL_Surface * surface, Uint32 key);
421 static int DX5_LockHWSurface(_THIS, SDL_Surface *surface); 426 static int DX5_SetHWAlpha (_THIS, SDL_Surface * surface, Uint8 alpha);
422 static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface); 427 static int DX5_LockHWSurface (_THIS, SDL_Surface * surface);
423 static int DX5_FlipHWSurface(_THIS, SDL_Surface *surface); 428 static void DX5_UnlockHWSurface (_THIS, SDL_Surface * surface);
424 static void DX5_FreeHWSurface(_THIS, SDL_Surface *surface); 429 static int DX5_FlipHWSurface (_THIS, SDL_Surface * surface);
425 430 static void DX5_FreeHWSurface (_THIS, SDL_Surface * surface);
426 static int DX5_AllocDDSurface(_THIS, SDL_Surface *surface, 431
427 LPDIRECTDRAWSURFACE3 requested, Uint32 flag); 432 static int DX5_AllocDDSurface (_THIS, SDL_Surface * surface,
433 LPDIRECTDRAWSURFACE3 requested, Uint32 flag);
428 434
429 /* Windows message handling functions */ 435 /* Windows message handling functions */
430 static void DX5_RealizePalette(_THIS); 436 static void DX5_RealizePalette (_THIS);
431 static void DX5_PaletteChanged(_THIS, HWND window); 437 static void DX5_PaletteChanged (_THIS, HWND window);
432 static void DX5_WinPAINT(_THIS, HDC hdc); 438 static void DX5_WinPAINT (_THIS, HDC hdc);
433 439
434 /* WinDIB driver functions for manipulating gamma ramps */ 440 /* WinDIB driver functions for manipulating gamma ramps */
435 extern int DIB_SetGammaRamp(_THIS, Uint16 *ramp); 441 extern int DIB_SetGammaRamp (_THIS, Uint16 * ramp);
436 extern int DIB_GetGammaRamp(_THIS, Uint16 *ramp); 442 extern int DIB_GetGammaRamp (_THIS, Uint16 * ramp);
437 extern void DIB_QuitGamma(_THIS); 443 extern void DIB_QuitGamma (_THIS);
438 444
439 /* Functions for loading the DirectX functions dynamically */ 445 /* Functions for loading the DirectX functions dynamically */
440 static int DX5_loaded = 0; 446 static int DX5_loaded = 0;
441 static HINSTANCE DDrawDLL = NULL; 447 static HINSTANCE DDrawDLL = NULL;
442 static HINSTANCE DInputDLL = NULL; 448 static HINSTANCE DInputDLL = NULL;
443 449
444 void DX5_Unload(void) 450 void
445 { 451 DX5_Unload (void)
446 if ( --DX5_loaded == 0 ) { 452 {
447 if ( DDrawDLL != NULL ) { 453 if (--DX5_loaded == 0) {
448 FreeLibrary(DDrawDLL); 454 if (DDrawDLL != NULL) {
449 DDrawCreate = NULL; 455 FreeLibrary (DDrawDLL);
450 DDrawDLL = NULL; 456 DDrawCreate = NULL;
451 } 457 DDrawDLL = NULL;
452 if ( DInputDLL != NULL ) { 458 }
453 FreeLibrary(DInputDLL); 459 if (DInputDLL != NULL) {
454 DInputCreate = NULL; 460 FreeLibrary (DInputDLL);
455 DInputDLL = NULL; 461 DInputCreate = NULL;
456 } 462 DInputDLL = NULL;
457 } 463 }
458 } 464 }
459 int DX5_Load(void) 465 }
460 { 466 int
461 int status = 0; 467 DX5_Load (void)
462 468 {
463 if ( ++DX5_loaded == 1 ) { 469 int status = 0;
464 DDrawDLL = LoadLibrary(TEXT("DDRAW.DLL")); 470
465 if ( DDrawDLL != NULL ) { 471 if (++DX5_loaded == 1) {
466 DDrawCreate = (void *)GetProcAddress(DDrawDLL, 472 DDrawDLL = LoadLibrary (TEXT ("DDRAW.DLL"));
467 TEXT("DirectDrawCreate")); 473 if (DDrawDLL != NULL) {
468 } 474 DDrawCreate = (void *) GetProcAddress (DDrawDLL,
469 DInputDLL = LoadLibrary(TEXT("DINPUT.DLL")); 475 TEXT ("DirectDrawCreate"));
470 if ( DInputDLL != NULL ) { 476 }
471 DInputCreate = (void *)GetProcAddress(DInputDLL, 477 DInputDLL = LoadLibrary (TEXT ("DINPUT.DLL"));
472 TEXT("DirectInputCreateA")); 478 if (DInputDLL != NULL) {
473 } 479 DInputCreate = (void *) GetProcAddress (DInputDLL,
474 if ( DDrawDLL && DDrawCreate && DInputDLL && DInputCreate ) { 480 TEXT
475 status = 0; 481 ("DirectInputCreateA"));
476 } else { 482 }
477 DX5_Unload(); 483 if (DDrawDLL && DDrawCreate && DInputDLL && DInputCreate) {
478 status = -1; 484 status = 0;
479 } 485 } else {
480 } 486 DX5_Unload ();
481 return status; 487 status = -1;
488 }
489 }
490 return status;
482 } 491 }
483 492
484 /* DX5 driver bootstrap functions */ 493 /* DX5 driver bootstrap functions */
485 494
486 static int DX5_Available(void) 495 static int
487 { 496 DX5_Available (void)
488 int ddraw_ok = 0; 497 {
489 HRESULT (WINAPI *DDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *); 498 int ddraw_ok = 0;
490 LPDIRECTDRAW DDraw; 499 HRESULT (WINAPI * DDrawCreate) (GUID *, LPDIRECTDRAW *, IUnknown *);
491 500 LPDIRECTDRAW DDraw;
492 /* Version check DINPUT.DLL and DDRAW.DLL (Is DirectX okay?) */ 501
493 if ( DX5_Load() < 0 ) { 502 /* Version check DINPUT.DLL and DDRAW.DLL (Is DirectX okay?) */
494 return -1; 503 if (DX5_Load () < 0) {
495 } 504 return -1;
496 505 }
497 /* Try to create a valid DirectDraw object */ 506
498 DDrawCreate = (void *)GetProcAddress(DDrawDLL, TEXT("DirectDrawCreate")); 507 /* Try to create a valid DirectDraw object */
499 if ( (DDrawCreate != NULL) 508 DDrawCreate =
500 && !FAILED(DDrawCreate(NULL, &DDraw, NULL)) ) { 509 (void *) GetProcAddress (DDrawDLL, TEXT ("DirectDrawCreate"));
501 if ( !FAILED(IDirectDraw_SetCooperativeLevel(DDraw, 510 if ((DDrawCreate != NULL) && !FAILED (DDrawCreate (NULL, &DDraw, NULL))) {
502 NULL, DDSCL_NORMAL)) ) { 511 if (!FAILED (IDirectDraw_SetCooperativeLevel (DDraw,
503 DDSURFACEDESC desc; 512 NULL, DDSCL_NORMAL))) {
504 LPDIRECTDRAWSURFACE DDrawSurf; 513 DDSURFACEDESC desc;
505 LPDIRECTDRAWSURFACE3 DDrawSurf3; 514 LPDIRECTDRAWSURFACE DDrawSurf;
506 515 LPDIRECTDRAWSURFACE3 DDrawSurf3;
507 /* Try to create a DirectDrawSurface3 object */ 516
508 SDL_memset(&desc, 0, sizeof(desc)); 517 /* Try to create a DirectDrawSurface3 object */
509 desc.dwSize = sizeof(desc); 518 SDL_memset (&desc, 0, sizeof (desc));
510 desc.dwFlags = DDSD_CAPS; 519 desc.dwSize = sizeof (desc);
511 desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE|DDSCAPS_VIDEOMEMORY; 520 desc.dwFlags = DDSD_CAPS;
512 if ( !FAILED(IDirectDraw_CreateSurface(DDraw, &desc, 521 desc.ddsCaps.dwCaps =
513 &DDrawSurf, NULL)) ) { 522 DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY;
514 if ( !FAILED(IDirectDrawSurface_QueryInterface(DDrawSurf, 523 if (!FAILED
515 &IID_IDirectDrawSurface3, (LPVOID *)&DDrawSurf3)) ) { 524 (IDirectDraw_CreateSurface
516 /* Yay! */ 525 (DDraw, &desc, &DDrawSurf, NULL))) {
517 ddraw_ok = 1; 526 if (!FAILED
518 527 (IDirectDrawSurface_QueryInterface
519 /* Clean up.. */ 528 (DDrawSurf, &IID_IDirectDrawSurface3,
520 IDirectDrawSurface3_Release(DDrawSurf3); 529 (LPVOID *) & DDrawSurf3))) {
521 } 530 /* Yay! */
522 IDirectDrawSurface_Release(DDrawSurf); 531 ddraw_ok = 1;
523 } 532
524 } 533 /* Clean up.. */
525 IDirectDraw_Release(DDraw); 534 IDirectDrawSurface3_Release (DDrawSurf3);
526 } 535 }
527 536 IDirectDrawSurface_Release (DDrawSurf);
528 DX5_Unload(); 537 }
529 538 }
530 return ddraw_ok; 539 IDirectDraw_Release (DDraw);
531 } 540 }
532 541
533 static void DX5_DeleteDevice(SDL_VideoDevice *this) 542 DX5_Unload ();
534 { 543
535 /* Free DirectDraw object */ 544 return ddraw_ok;
536 if ( ddraw2 != NULL ) { 545 }
537 IDirectDraw2_Release(ddraw2); 546
538 } 547 static void
539 DX5_Unload(); 548 DX5_DeleteDevice (SDL_VideoDevice * this)
540 549 {
541 if ( this ) { 550 /* Free DirectDraw object */
542 if ( this->hidden ) { 551 if (ddraw2 != NULL) {
543 SDL_free(this->hidden); 552 IDirectDraw2_Release (ddraw2);
544 } 553 }
545 if ( this->gl_data ) { 554 DX5_Unload ();
546 SDL_free(this->gl_data); 555
547 } 556 if (this) {
548 SDL_free(this); 557 if (this->hidden) {
549 } 558 SDL_free (this->hidden);
550 } 559 }
551 560 if (this->gl_data) {
552 static SDL_VideoDevice *DX5_CreateDevice(int devindex) 561 SDL_free (this->gl_data);
553 { 562 }
554 SDL_VideoDevice *device; 563 SDL_free (this);
555 564 }
556 /* Load DirectX */ 565 }
557 if ( DX5_Load() < 0 ) { 566
558 return(NULL); 567 static SDL_VideoDevice *
559 } 568 DX5_CreateDevice (int devindex)
560 569 {
561 /* Initialize all variables that we clean on shutdown */ 570 SDL_VideoDevice *device;
562 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); 571
563 if ( device ) { 572 /* Load DirectX */
564 SDL_memset(device, 0, (sizeof *device)); 573 if (DX5_Load () < 0) {
565 device->hidden = (struct SDL_PrivateVideoData *) 574 return (NULL);
566 SDL_malloc((sizeof *device->hidden)); 575 }
567 device->gl_data = (struct SDL_PrivateGLData *) 576
568 SDL_malloc((sizeof *device->gl_data)); 577 /* Initialize all variables that we clean on shutdown */
569 } 578 device = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice));
570 if ( (device == NULL) || (device->hidden == NULL) || 579 if (device) {
571 (device->gl_data == NULL) ) { 580 SDL_memset (device, 0, (sizeof *device));
572 SDL_OutOfMemory(); 581 device->hidden = (struct SDL_PrivateVideoData *)
573 DX5_DeleteDevice(device); 582 SDL_malloc ((sizeof *device->hidden));
574 return(NULL); 583 device->gl_data = (struct SDL_PrivateGLData *)
575 } 584 SDL_malloc ((sizeof *device->gl_data));
576 SDL_memset(device->hidden, 0, (sizeof *device->hidden)); 585 }
577 SDL_memset(device->gl_data, 0, (sizeof *device->gl_data)); 586 if ((device == NULL) || (device->hidden == NULL) ||
578 587 (device->gl_data == NULL)) {
579 /* Set the function pointers */ 588 SDL_OutOfMemory ();
580 device->VideoInit = DX5_VideoInit; 589 DX5_DeleteDevice (device);
581 device->ListModes = DX5_ListModes; 590 return (NULL);
582 device->SetVideoMode = DX5_SetVideoMode; 591 }
583 device->UpdateMouse = WIN_UpdateMouse; 592 SDL_memset (device->hidden, 0, (sizeof *device->hidden));
584 device->CreateYUVOverlay = DX5_CreateYUVOverlay; 593 SDL_memset (device->gl_data, 0, (sizeof *device->gl_data));
585 device->SetColors = DX5_SetColors; 594
586 device->UpdateRects = NULL; 595 /* Set the function pointers */
587 device->VideoQuit = DX5_VideoQuit; 596 device->VideoInit = DX5_VideoInit;
588 device->AllocHWSurface = DX5_AllocHWSurface; 597 device->ListModes = DX5_ListModes;
589 device->CheckHWBlit = DX5_CheckHWBlit; 598 device->SetVideoMode = DX5_SetVideoMode;
590 device->FillHWRect = DX5_FillHWRect; 599 device->UpdateMouse = WIN_UpdateMouse;
591 device->SetHWColorKey = DX5_SetHWColorKey; 600 device->CreateYUVOverlay = DX5_CreateYUVOverlay;
592 device->SetHWAlpha = DX5_SetHWAlpha; 601 device->SetColors = DX5_SetColors;
593 device->LockHWSurface = DX5_LockHWSurface; 602 device->UpdateRects = NULL;
594 device->UnlockHWSurface = DX5_UnlockHWSurface; 603 device->VideoQuit = DX5_VideoQuit;
595 device->FlipHWSurface = DX5_FlipHWSurface; 604 device->AllocHWSurface = DX5_AllocHWSurface;
596 device->FreeHWSurface = DX5_FreeHWSurface; 605 device->CheckHWBlit = DX5_CheckHWBlit;
597 device->SetGammaRamp = DX5_SetGammaRamp; 606 device->FillHWRect = DX5_FillHWRect;
598 device->GetGammaRamp = DX5_GetGammaRamp; 607 device->SetHWColorKey = DX5_SetHWColorKey;
608 device->SetHWAlpha = DX5_SetHWAlpha;
609 device->LockHWSurface = DX5_LockHWSurface;
610 device->UnlockHWSurface = DX5_UnlockHWSurface;
611 device->FlipHWSurface = DX5_FlipHWSurface;
612 device->FreeHWSurface = DX5_FreeHWSurface;
613 device->SetGammaRamp = DX5_SetGammaRamp;
614 device->GetGammaRamp = DX5_GetGammaRamp;
599 #if SDL_VIDEO_OPENGL 615 #if SDL_VIDEO_OPENGL
600 device->GL_LoadLibrary = WIN_GL_LoadLibrary; 616 device->GL_LoadLibrary = WIN_GL_LoadLibrary;
601 device->GL_GetProcAddress = WIN_GL_GetProcAddress; 617 device->GL_GetProcAddress = WIN_GL_GetProcAddress;
602 device->GL_GetAttribute = WIN_GL_GetAttribute; 618 device->GL_GetAttribute = WIN_GL_GetAttribute;
603 device->GL_MakeCurrent = WIN_GL_MakeCurrent; 619 device->GL_MakeCurrent = WIN_GL_MakeCurrent;
604 device->GL_SwapBuffers = WIN_GL_SwapBuffers; 620 device->GL_SwapBuffers = WIN_GL_SwapBuffers;
605 #endif 621 #endif
606 device->SetCaption = WIN_SetWMCaption; 622 device->SetCaption = WIN_SetWMCaption;
607 device->SetIcon = WIN_SetWMIcon; 623 device->SetIcon = WIN_SetWMIcon;
608 device->IconifyWindow = WIN_IconifyWindow; 624 device->IconifyWindow = WIN_IconifyWindow;
609 device->GrabInput = WIN_GrabInput; 625 device->GrabInput = WIN_GrabInput;
610 device->GetWMInfo = WIN_GetWMInfo; 626 device->GetWMInfo = WIN_GetWMInfo;
611 device->FreeWMCursor = WIN_FreeWMCursor; 627 device->FreeWMCursor = WIN_FreeWMCursor;
612 device->CreateWMCursor = WIN_CreateWMCursor; 628 device->CreateWMCursor = WIN_CreateWMCursor;
613 device->ShowWMCursor = WIN_ShowWMCursor; 629 device->ShowWMCursor = WIN_ShowWMCursor;
614 device->WarpWMCursor = WIN_WarpWMCursor; 630 device->WarpWMCursor = WIN_WarpWMCursor;
615 device->CheckMouseMode = WIN_CheckMouseMode; 631 device->CheckMouseMode = WIN_CheckMouseMode;
616 device->InitOSKeymap = DX5_InitOSKeymap; 632 device->InitOSKeymap = DX5_InitOSKeymap;
617 device->PumpEvents = DX5_PumpEvents; 633 device->PumpEvents = DX5_PumpEvents;
618 634
619 /* Set up the windows message handling functions */ 635 /* Set up the windows message handling functions */
620 WIN_RealizePalette = DX5_RealizePalette; 636 WIN_RealizePalette = DX5_RealizePalette;
621 WIN_PaletteChanged = DX5_PaletteChanged; 637 WIN_PaletteChanged = DX5_PaletteChanged;
622 WIN_WinPAINT = DX5_WinPAINT; 638 WIN_WinPAINT = DX5_WinPAINT;
623 HandleMessage = DX5_HandleMessage; 639 HandleMessage = DX5_HandleMessage;
624 640
625 device->free = DX5_DeleteDevice; 641 device->free = DX5_DeleteDevice;
626 642
627 /* We're finally ready */ 643 /* We're finally ready */
628 return device; 644 return device;
629 } 645 }
630 646
631 VideoBootStrap DIRECTX_bootstrap = { 647 VideoBootStrap DIRECTX_bootstrap = {
632 "directx", "Win95/98/2000 DirectX", 648 "directx", "Win95/98/2000 DirectX",
633 DX5_Available, DX5_CreateDevice 649 DX5_Available, DX5_CreateDevice
634 }; 650 };
635 651
636 static int cmpmodes(const void *va, const void *vb) 652 static int
637 { 653 cmpmodes (const void *va, const void *vb)
638 SDL_Rect *a = *(SDL_Rect **)va; 654 {
639 SDL_Rect *b = *(SDL_Rect **)vb; 655 SDL_Rect *a = *(SDL_Rect **) va;
640 if ( a->w == b->w ) 656 SDL_Rect *b = *(SDL_Rect **) vb;
657 if (a->w == b->w)
641 return b->h - a->h; 658 return b->h - a->h;
642 else 659 else
643 return b->w - a->w; 660 return b->w - a->w;
644 } 661 }
645 662
646 static HRESULT WINAPI EnumModes2(DDSURFACEDESC *desc, VOID *udata) 663 static HRESULT WINAPI
647 { 664 EnumModes2 (DDSURFACEDESC * desc, VOID * udata)
648 SDL_VideoDevice *this = (SDL_VideoDevice *)udata; 665 {
649 struct DX5EnumRect *enumrect; 666 SDL_VideoDevice *this = (SDL_VideoDevice *) udata;
667 struct DX5EnumRect *enumrect;
650 #if defined(NONAMELESSUNION) 668 #if defined(NONAMELESSUNION)
651 int bpp = desc->ddpfPixelFormat.u1.dwRGBBitCount; 669 int bpp = desc->ddpfPixelFormat.u1.dwRGBBitCount;
652 int refreshRate = desc->u2.dwRefreshRate; 670 int refreshRate = desc->u2.dwRefreshRate;
653 #else 671 #else
654 int bpp = desc->ddpfPixelFormat.dwRGBBitCount; 672 int bpp = desc->ddpfPixelFormat.dwRGBBitCount;
655 int refreshRate = desc->dwRefreshRate; 673 int refreshRate = desc->dwRefreshRate;
656 #endif 674 #endif
657 int maxRefreshRate; 675 int maxRefreshRate;
658 676
659 if ( desc->dwWidth <= SDL_desktop_mode.dmPelsWidth && 677 if (desc->dwWidth <= SDL_desktop_mode.dmPelsWidth &&
660 desc->dwHeight <= SDL_desktop_mode.dmPelsHeight ) { 678 desc->dwHeight <= SDL_desktop_mode.dmPelsHeight) {
661 maxRefreshRate = SDL_desktop_mode.dmDisplayFrequency; 679 maxRefreshRate = SDL_desktop_mode.dmDisplayFrequency;
662 } else { 680 } else {
663 maxRefreshRate = 85; /* safe value? */ 681 maxRefreshRate = 85; /* safe value? */
664 } 682 }
665 683
666 switch (bpp) { 684 switch (bpp) {
667 case 8: 685 case 8:
668 case 16: 686 case 16:
669 case 24: 687 case 24:
670 case 32: 688 case 32:
671 bpp /= 8; --bpp; 689 bpp /= 8;
672 if ( enumlists[bpp] && 690 --bpp;
673 enumlists[bpp]->r.w == (Uint16)desc->dwWidth && 691 if (enumlists[bpp] &&
674 enumlists[bpp]->r.h == (Uint16)desc->dwHeight ) { 692 enumlists[bpp]->r.w == (Uint16) desc->dwWidth &&
675 if ( refreshRate > enumlists[bpp]->refreshRate && 693 enumlists[bpp]->r.h == (Uint16) desc->dwHeight) {
676 refreshRate <= maxRefreshRate ) { 694 if (refreshRate > enumlists[bpp]->refreshRate &&
677 enumlists[bpp]->refreshRate = refreshRate; 695 refreshRate <= maxRefreshRate) {
696 enumlists[bpp]->refreshRate = refreshRate;
678 #ifdef DDRAW_DEBUG 697 #ifdef DDRAW_DEBUG
679 fprintf(stderr, "New refresh rate for %d bpp: %dx%d at %d Hz\n", (bpp+1)*8, (int)desc->dwWidth, (int)desc->dwHeight, refreshRate); 698 fprintf (stderr,
680 #endif 699 "New refresh rate for %d bpp: %dx%d at %d Hz\n",
681 } 700 (bpp + 1) * 8, (int) desc->dwWidth,
682 break; 701 (int) desc->dwHeight, refreshRate);
683 } 702 #endif
684 ++SDL_nummodes[bpp]; 703 }
685 enumrect = (struct DX5EnumRect*)SDL_malloc(sizeof(struct DX5EnumRect)); 704 break;
686 if ( !enumrect ) { 705 }
687 SDL_OutOfMemory(); 706 ++SDL_nummodes[bpp];
688 return(DDENUMRET_CANCEL); 707 enumrect =
689 } 708 (struct DX5EnumRect *) SDL_malloc (sizeof (struct DX5EnumRect));
690 enumrect->refreshRate = refreshRate; 709 if (!enumrect) {
691 enumrect->r.x = 0; 710 SDL_OutOfMemory ();
692 enumrect->r.y = 0; 711 return (DDENUMRET_CANCEL);
693 enumrect->r.w = (Uint16)desc->dwWidth; 712 }
694 enumrect->r.h = (Uint16)desc->dwHeight; 713 enumrect->refreshRate = refreshRate;
695 enumrect->next = enumlists[bpp]; 714 enumrect->r.x = 0;
696 enumlists[bpp] = enumrect; 715 enumrect->r.y = 0;
716 enumrect->r.w = (Uint16) desc->dwWidth;
717 enumrect->r.h = (Uint16) desc->dwHeight;
718 enumrect->next = enumlists[bpp];
719 enumlists[bpp] = enumrect;
697 #ifdef DDRAW_DEBUG 720 #ifdef DDRAW_DEBUG
698 fprintf(stderr, "New mode for %d bpp: %dx%d at %d Hz\n", (bpp+1)*8, (int)desc->dwWidth, (int)desc->dwHeight, refreshRate); 721 fprintf (stderr, "New mode for %d bpp: %dx%d at %d Hz\n",
699 #endif 722 (bpp + 1) * 8, (int) desc->dwWidth, (int) desc->dwHeight,
700 break; 723 refreshRate);
701 } 724 #endif
702 725 break;
703 return(DDENUMRET_OK); 726 }
704 } 727
705 728 return (DDENUMRET_OK);
706 void SetDDerror(const char *function, int code) 729 }
707 { 730
708 static char *error; 731 void
709 static char errbuf[1024]; 732 SetDDerror (const char *function, int code)
710 733 {
711 errbuf[0] = 0; 734 static char *error;
712 switch (code) { 735 static char errbuf[1024];
713 case DDERR_GENERIC: 736
714 error = "Undefined error!"; 737 errbuf[0] = 0;
715 break; 738 switch (code) {
716 case DDERR_EXCEPTION: 739 case DDERR_GENERIC:
717 error = "Exception encountered"; 740 error = "Undefined error!";
718 break; 741 break;
719 case DDERR_INVALIDOBJECT: 742 case DDERR_EXCEPTION:
720 error = "Invalid object"; 743 error = "Exception encountered";
721 break; 744 break;
722 case DDERR_INVALIDPARAMS: 745 case DDERR_INVALIDOBJECT:
723 error = "Invalid parameters"; 746 error = "Invalid object";
724 break; 747 break;
725 case DDERR_NOTFOUND: 748 case DDERR_INVALIDPARAMS:
726 error = "Object not found"; 749 error = "Invalid parameters";
727 break; 750 break;
728 case DDERR_INVALIDRECT: 751 case DDERR_NOTFOUND:
729 error = "Invalid rectangle"; 752 error = "Object not found";
730 break; 753 break;
731 case DDERR_INVALIDCAPS: 754 case DDERR_INVALIDRECT:
732 error = "Invalid caps member"; 755 error = "Invalid rectangle";
733 break; 756 break;
734 case DDERR_INVALIDPIXELFORMAT: 757 case DDERR_INVALIDCAPS:
735 error = "Invalid pixel format"; 758 error = "Invalid caps member";
736 break; 759 break;
737 case DDERR_OUTOFMEMORY: 760 case DDERR_INVALIDPIXELFORMAT:
738 error = "Out of memory"; 761 error = "Invalid pixel format";
739 break; 762 break;
740 case DDERR_OUTOFVIDEOMEMORY: 763 case DDERR_OUTOFMEMORY:
741 error = "Out of video memory"; 764 error = "Out of memory";
742 break; 765 break;
743 case DDERR_SURFACEBUSY: 766 case DDERR_OUTOFVIDEOMEMORY:
744 error = "Surface busy"; 767 error = "Out of video memory";
745 break; 768 break;
746 case DDERR_SURFACELOST: 769 case DDERR_SURFACEBUSY:
747 error = "Surface was lost"; 770 error = "Surface busy";
748 break; 771 break;
749 case DDERR_WASSTILLDRAWING: 772 case DDERR_SURFACELOST:
750 error = "DirectDraw is still drawing"; 773 error = "Surface was lost";
751 break; 774 break;
752 case DDERR_INVALIDSURFACETYPE: 775 case DDERR_WASSTILLDRAWING:
753 error = "Invalid surface type"; 776 error = "DirectDraw is still drawing";
754 break; 777 break;
755 case DDERR_NOEXCLUSIVEMODE: 778 case DDERR_INVALIDSURFACETYPE:
756 error = "Not in exclusive access mode"; 779 error = "Invalid surface type";
757 break; 780 break;
758 case DDERR_NOPALETTEATTACHED: 781 case DDERR_NOEXCLUSIVEMODE:
759 error = "No palette attached"; 782 error = "Not in exclusive access mode";
760 break; 783 break;
761 case DDERR_NOPALETTEHW: 784 case DDERR_NOPALETTEATTACHED:
762 error = "No palette hardware"; 785 error = "No palette attached";
763 break; 786 break;
764 case DDERR_NOT8BITCOLOR: 787 case DDERR_NOPALETTEHW:
765 error = "Not 8-bit color"; 788 error = "No palette hardware";
766 break; 789 break;
767 case DDERR_EXCLUSIVEMODEALREADYSET: 790 case DDERR_NOT8BITCOLOR:
768 error = "Exclusive mode was already set"; 791 error = "Not 8-bit color";
769 break; 792 break;
770 case DDERR_HWNDALREADYSET: 793 case DDERR_EXCLUSIVEMODEALREADYSET:
771 error = "Window handle already set"; 794 error = "Exclusive mode was already set";
772 break; 795 break;
773 case DDERR_HWNDSUBCLASSED: 796 case DDERR_HWNDALREADYSET:
774 error = "Window handle is subclassed"; 797 error = "Window handle already set";
775 break; 798 break;
776 case DDERR_NOBLTHW: 799 case DDERR_HWNDSUBCLASSED:
777 error = "No blit hardware"; 800 error = "Window handle is subclassed";
778 break; 801 break;
779 case DDERR_IMPLICITLYCREATED: 802 case DDERR_NOBLTHW:
780 error = "Surface was implicitly created"; 803 error = "No blit hardware";
781 break; 804 break;
782 case DDERR_INCOMPATIBLEPRIMARY: 805 case DDERR_IMPLICITLYCREATED:
783 error = "Incompatible primary surface"; 806 error = "Surface was implicitly created";
784 break; 807 break;
785 case DDERR_NOCOOPERATIVELEVELSET: 808 case DDERR_INCOMPATIBLEPRIMARY:
786 error = "No cooperative level set"; 809 error = "Incompatible primary surface";
787 break; 810 break;
788 case DDERR_NODIRECTDRAWHW: 811 case DDERR_NOCOOPERATIVELEVELSET:
789 error = "No DirectDraw hardware"; 812 error = "No cooperative level set";
790 break; 813 break;
791 case DDERR_NOEMULATION: 814 case DDERR_NODIRECTDRAWHW:
792 error = "No emulation available"; 815 error = "No DirectDraw hardware";
793 break; 816 break;
794 case DDERR_NOFLIPHW: 817 case DDERR_NOEMULATION:
795 error = "No flip hardware"; 818 error = "No emulation available";
796 break; 819 break;
797 case DDERR_NOTFLIPPABLE: 820 case DDERR_NOFLIPHW:
798 error = "Surface not flippable"; 821 error = "No flip hardware";
799 break; 822 break;
800 case DDERR_PRIMARYSURFACEALREADYEXISTS: 823 case DDERR_NOTFLIPPABLE:
801 error = "Primary surface already exists"; 824 error = "Surface not flippable";
802 break; 825 break;
803 case DDERR_UNSUPPORTEDMODE: 826 case DDERR_PRIMARYSURFACEALREADYEXISTS:
804 error = "Unsupported mode"; 827 error = "Primary surface already exists";
805 break; 828 break;
806 case DDERR_WRONGMODE: 829 case DDERR_UNSUPPORTEDMODE:
807 error = "Surface created in different mode"; 830 error = "Unsupported mode";
808 break; 831 break;
809 case DDERR_UNSUPPORTED: 832 case DDERR_WRONGMODE:
810 error = "Operation not supported"; 833 error = "Surface created in different mode";
811 break; 834 break;
812 case E_NOINTERFACE: 835 case DDERR_UNSUPPORTED:
813 error = "Interface not present"; 836 error = "Operation not supported";
814 break; 837 break;
815 default: 838 case E_NOINTERFACE:
816 SDL_snprintf(errbuf, SDL_arraysize(errbuf), 839 error = "Interface not present";
817 "%s: Unknown DirectDraw error: 0x%x", 840 break;
818 function, code); 841 default:
819 break; 842 SDL_snprintf (errbuf, SDL_arraysize (errbuf),
820 } 843 "%s: Unknown DirectDraw error: 0x%x", function, code);
821 if ( ! errbuf[0] ) { 844 break;
822 SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function, error); 845 }
823 } 846 if (!errbuf[0]) {
824 SDL_SetError("%s", errbuf); 847 SDL_snprintf (errbuf, SDL_arraysize (errbuf), "%s: %s", function,
825 return; 848 error);
826 } 849 }
827 850 SDL_SetError ("%s", errbuf);
828 851 return;
829 static int DX5_UpdateVideoInfo(_THIS) 852 }
830 { 853
831 /* This needs to be DDCAPS_DX5 for the DirectDraw2 interface */ 854
855 static int
856 DX5_UpdateVideoInfo (_THIS)
857 {
858 /* This needs to be DDCAPS_DX5 for the DirectDraw2 interface */
832 #if DIRECTDRAW_VERSION <= 0x300 859 #if DIRECTDRAW_VERSION <= 0x300
833 #error Your version of DirectX must be greater than or equal to 5.0 860 #error Your version of DirectX must be greater than or equal to 5.0
834 #endif 861 #endif
835 #ifndef IDirectDrawGammaControl_SetGammaRamp 862 #ifndef IDirectDrawGammaControl_SetGammaRamp
836 /*if gamma is undefined then we really have directx <= 0x500*/ 863 /*if gamma is undefined then we really have directx <= 0x500 */
837 DDCAPS DDCaps; 864 DDCAPS DDCaps;
838 #else 865 #else
839 DDCAPS_DX5 DDCaps; 866 DDCAPS_DX5 DDCaps;
840 #endif 867 #endif
841 HRESULT result; 868 HRESULT result;
842 869
843 /* Fill in our hardware acceleration capabilities */ 870 /* Fill in our hardware acceleration capabilities */
844 SDL_memset(&DDCaps, 0, sizeof(DDCaps)); 871 SDL_memset (&DDCaps, 0, sizeof (DDCaps));
845 DDCaps.dwSize = sizeof(DDCaps); 872 DDCaps.dwSize = sizeof (DDCaps);
846 result = IDirectDraw2_GetCaps(ddraw2, (DDCAPS *)&DDCaps, NULL); 873 result = IDirectDraw2_GetCaps (ddraw2, (DDCAPS *) & DDCaps, NULL);
847 if ( result != DD_OK ) { 874 if (result != DD_OK) {
848 SetDDerror("DirectDraw2::GetCaps", result); 875 SetDDerror ("DirectDraw2::GetCaps", result);
849 return(-1); 876 return (-1);
850 } 877 }
851 this->info.hw_available = 1; 878 this->info.hw_available = 1;
852 if ( (DDCaps.dwCaps & DDCAPS_BLT) == DDCAPS_BLT ) { 879 if ((DDCaps.dwCaps & DDCAPS_BLT) == DDCAPS_BLT) {
853 this->info.blit_hw = 1; 880 this->info.blit_hw = 1;
854 } 881 }
855 if ( ((DDCaps.dwCaps & DDCAPS_COLORKEY) == DDCAPS_COLORKEY) && 882 if (((DDCaps.dwCaps & DDCAPS_COLORKEY) == DDCAPS_COLORKEY) &&
856 ((DDCaps.dwCKeyCaps & DDCKEYCAPS_SRCBLT) == DDCKEYCAPS_SRCBLT) ) { 883 ((DDCaps.dwCKeyCaps & DDCKEYCAPS_SRCBLT) == DDCKEYCAPS_SRCBLT)) {
857 this->info.blit_hw_CC = 1; 884 this->info.blit_hw_CC = 1;
858 } 885 }
859 if ( (DDCaps.dwCaps & DDCAPS_ALPHA) == DDCAPS_ALPHA ) { 886 if ((DDCaps.dwCaps & DDCAPS_ALPHA) == DDCAPS_ALPHA) {
860 /* This is only for alpha channel, and DirectX 6 887 /* This is only for alpha channel, and DirectX 6
861 doesn't support 2D alpha blits yet, so set it 0 888 doesn't support 2D alpha blits yet, so set it 0
862 */ 889 */
863 this->info.blit_hw_A = 0; 890 this->info.blit_hw_A = 0;
864 } 891 }
865 if ( (DDCaps.dwCaps & DDCAPS_CANBLTSYSMEM) == DDCAPS_CANBLTSYSMEM ) { 892 if ((DDCaps.dwCaps & DDCAPS_CANBLTSYSMEM) == DDCAPS_CANBLTSYSMEM) {
866 this->info.blit_sw = 1; 893 this->info.blit_sw = 1;
867 /* This isn't necessarily true, but the HEL will cover us */ 894 /* This isn't necessarily true, but the HEL will cover us */
868 this->info.blit_sw_CC = this->info.blit_hw_CC; 895 this->info.blit_sw_CC = this->info.blit_hw_CC;
869 this->info.blit_sw_A = this->info.blit_hw_A; 896 this->info.blit_sw_A = this->info.blit_hw_A;
870 } 897 }
871 if ( (DDCaps.dwCaps & DDCAPS_BLTCOLORFILL) == DDCAPS_BLTCOLORFILL ) { 898 if ((DDCaps.dwCaps & DDCAPS_BLTCOLORFILL) == DDCAPS_BLTCOLORFILL) {
872 this->info.blit_fill = 1; 899 this->info.blit_fill = 1;
873 } 900 }
874 901
875 /* Find out how much video memory is available */ 902 /* Find out how much video memory is available */
876 { DDSCAPS ddsCaps; 903 {
877 DWORD total_mem; 904 DDSCAPS ddsCaps;
878 ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY; 905 DWORD total_mem;
879 result = IDirectDraw2_GetAvailableVidMem(ddraw2, 906 ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
880 &ddsCaps, &total_mem, NULL); 907 result = IDirectDraw2_GetAvailableVidMem (ddraw2,
881 if ( result != DD_OK ) { 908 &ddsCaps, &total_mem, NULL);
882 total_mem = DDCaps.dwVidMemTotal; 909 if (result != DD_OK) {
883 } 910 total_mem = DDCaps.dwVidMemTotal;
884 this->info.video_mem = total_mem/1024; 911 }
885 } 912 this->info.video_mem = total_mem / 1024;
886 return(0); 913 }
887 } 914 return (0);
888 915 }
889 int DX5_VideoInit(_THIS, SDL_PixelFormat *vformat) 916
890 { 917 int
891 HRESULT result; 918 DX5_VideoInit (_THIS, SDL_PixelFormat * vformat)
892 LPDIRECTDRAW ddraw; 919 {
893 int i, j; 920 HRESULT result;
894 HDC hdc; 921 LPDIRECTDRAW ddraw;
895 922 int i, j;
896 /* Intialize everything */ 923 HDC hdc;
897 ddraw2 = NULL; 924
898 SDL_primary = NULL; 925 /* Intialize everything */
899 SDL_clipper = NULL; 926 ddraw2 = NULL;
900 SDL_palette = NULL; 927 SDL_primary = NULL;
901 for ( i=0; i<NUM_MODELISTS; ++i ) { 928 SDL_clipper = NULL;
902 SDL_nummodes[i] = 0; 929 SDL_palette = NULL;
903 SDL_modelist[i] = NULL; 930 for (i = 0; i < NUM_MODELISTS; ++i) {
904 SDL_modeindex[i] = 0; 931 SDL_nummodes[i] = 0;
905 } 932 SDL_modelist[i] = NULL;
906 colorchange_expected = 0; 933 SDL_modeindex[i] = 0;
907 934 }
908 /* Create the window */ 935 colorchange_expected = 0;
909 if ( DX5_CreateWindow(this) < 0 ) { 936
910 return(-1); 937 /* Create the window */
911 } 938 if (DX5_CreateWindow (this) < 0) {
912 939 return (-1);
940 }
913 #if !SDL_AUDIO_DISABLED 941 #if !SDL_AUDIO_DISABLED
914 DX5_SoundFocus(SDL_Window); 942 DX5_SoundFocus (SDL_Window);
915 #endif 943 #endif
916 944
917 /* Create the DirectDraw object */ 945 /* Create the DirectDraw object */
918 result = DDrawCreate(NULL, &ddraw, NULL); 946 result = DDrawCreate (NULL, &ddraw, NULL);
919 if ( result != DD_OK ) { 947 if (result != DD_OK) {
920 SetDDerror("DirectDrawCreate", result); 948 SetDDerror ("DirectDrawCreate", result);
921 return(-1); 949 return (-1);
922 } 950 }
923 result = IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw2, 951 result = IDirectDraw_QueryInterface (ddraw, &IID_IDirectDraw2,
924 (LPVOID *)&ddraw2); 952 (LPVOID *) & ddraw2);
925 IDirectDraw_Release(ddraw); 953 IDirectDraw_Release (ddraw);
926 if ( result != DD_OK ) { 954 if (result != DD_OK) {
927 SetDDerror("DirectDraw::QueryInterface", result); 955 SetDDerror ("DirectDraw::QueryInterface", result);
928 return(-1); 956 return (-1);
929 } 957 }
930 958
931 /* Determine the screen depth */ 959 /* Determine the screen depth */
932 hdc = GetDC(SDL_Window); 960 hdc = GetDC (SDL_Window);
933 vformat->BitsPerPixel = GetDeviceCaps(hdc,PLANES) * 961 vformat->BitsPerPixel = GetDeviceCaps (hdc, PLANES) *
934 GetDeviceCaps(hdc,BITSPIXEL); 962 GetDeviceCaps (hdc, BITSPIXEL);
935 ReleaseDC(SDL_Window, hdc); 963 ReleaseDC (SDL_Window, hdc);
936 964
937 #ifndef NO_CHANGEDISPLAYSETTINGS 965 #ifndef NO_CHANGEDISPLAYSETTINGS
938 /* Query for the desktop resolution */ 966 /* Query for the desktop resolution */
939 EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &SDL_desktop_mode); 967 EnumDisplaySettings (NULL, ENUM_CURRENT_SETTINGS, &SDL_desktop_mode);
940 this->info.current_w = SDL_desktop_mode.dmPelsWidth; 968 this->info.current_w = SDL_desktop_mode.dmPelsWidth;
941 this->info.current_h = SDL_desktop_mode.dmPelsHeight; 969 this->info.current_h = SDL_desktop_mode.dmPelsHeight;
942 #endif 970 #endif
943 971
944 /* Enumerate the available fullscreen modes */ 972 /* Enumerate the available fullscreen modes */
945 for ( i=0; i<NUM_MODELISTS; ++i ) 973 for (i = 0; i < NUM_MODELISTS; ++i)
946 enumlists[i] = NULL; 974 enumlists[i] = NULL;
947 975
948 result = IDirectDraw2_EnumDisplayModes(ddraw2,DDEDM_REFRESHRATES,NULL,this,EnumModes2); 976 result =
949 if ( result != DD_OK ) { 977 IDirectDraw2_EnumDisplayModes (ddraw2, DDEDM_REFRESHRATES, NULL, this,
950 SetDDerror("DirectDraw2::EnumDisplayModes", result); 978 EnumModes2);
951 return(-1); 979 if (result != DD_OK) {
952 } 980 SetDDerror ("DirectDraw2::EnumDisplayModes", result);
953 for ( i=0; i<NUM_MODELISTS; ++i ) { 981 return (-1);
954 struct DX5EnumRect *rect; 982 }
955 SDL_modelist[i] = (SDL_Rect **) 983 for (i = 0; i < NUM_MODELISTS; ++i) {
956 SDL_malloc((SDL_nummodes[i]+1)*sizeof(SDL_Rect *)); 984 struct DX5EnumRect *rect;
957 if ( SDL_modelist[i] == NULL ) { 985 SDL_modelist[i] = (SDL_Rect **)
958 SDL_OutOfMemory(); 986 SDL_malloc ((SDL_nummodes[i] + 1) * sizeof (SDL_Rect *));
959 return(-1); 987 if (SDL_modelist[i] == NULL) {
960 } 988 SDL_OutOfMemory ();
961 for ( j = 0, rect = enumlists[i]; rect; ++j, rect = rect->next ) { 989 return (-1);
962 SDL_modelist[i][j] = &rect->r; 990 }
963 } 991 for (j = 0, rect = enumlists[i]; rect; ++j, rect = rect->next) {
964 SDL_modelist[i][j] = NULL; 992 SDL_modelist[i][j] = &rect->r;
965 993 }
966 if ( SDL_nummodes[i] > 0 ) { 994 SDL_modelist[i][j] = NULL;
967 SDL_qsort(SDL_modelist[i], SDL_nummodes[i], sizeof *SDL_modelist[i], cmpmodes); 995
968 } 996 if (SDL_nummodes[i] > 0) {
969 } 997 SDL_qsort (SDL_modelist[i], SDL_nummodes[i],
970 998 sizeof *SDL_modelist[i], cmpmodes);
971 /* Fill in some window manager capabilities */ 999 }
972 this->info.wm_available = 1; 1000 }
973 1001
974 /* Fill in the video hardware capabilities */ 1002 /* Fill in some window manager capabilities */
975 DX5_UpdateVideoInfo(this); 1003 this->info.wm_available = 1;
976 1004
977 return(0); 1005 /* Fill in the video hardware capabilities */
978 } 1006 DX5_UpdateVideoInfo (this);
979 1007
980 SDL_Rect **DX5_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) 1008 return (0);
981 { 1009 }
982 int bpp; 1010
983 1011 SDL_Rect **
984 bpp = format->BitsPerPixel; 1012 DX5_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags)
985 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 1013 {
986 /* FIXME: No support for 1 bpp or 4 bpp formats */ 1014 int bpp;
987 switch (bpp) { /* Does windows support other BPP? */ 1015
988 case 8: 1016 bpp = format->BitsPerPixel;
989 case 16: 1017 if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
990 case 24: 1018 /* FIXME: No support for 1 bpp or 4 bpp formats */
991 case 32: 1019 switch (bpp) { /* Does windows support other BPP? */
992 bpp = (bpp/8)-1; 1020 case 8:
993 if ( SDL_nummodes[bpp] > 0 ) 1021 case 16:
994 return(SDL_modelist[bpp]); 1022 case 24:
995 /* Fall through */ 1023 case 32:
996 default: 1024 bpp = (bpp / 8) - 1;
997 return((SDL_Rect **)0); 1025 if (SDL_nummodes[bpp] > 0)
998 } 1026 return (SDL_modelist[bpp]);
999 } else { 1027 /* Fall through */
1000 if ( this->screen->format->BitsPerPixel == bpp ) { 1028 default:
1001 return((SDL_Rect **)-1); 1029 return ((SDL_Rect **) 0);
1002 } else { 1030 }
1003 return((SDL_Rect **)0); 1031 } else {
1004 } 1032 if (this->screen->format->BitsPerPixel == bpp) {
1005 } 1033 return ((SDL_Rect **) - 1);
1034 } else {
1035 return ((SDL_Rect **) 0);
1036 }
1037 }
1006 } 1038 }
1007 1039
1008 /* Various screen update functions available */ 1040 /* Various screen update functions available */
1009 static void DX5_WindowUpdate(_THIS, int numrects, SDL_Rect *rects); 1041 static void DX5_WindowUpdate (_THIS, int numrects, SDL_Rect * rects);
1010 static void DX5_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); 1042 static void DX5_DirectUpdate (_THIS, int numrects, SDL_Rect * rects);
1011 1043
1012 SDL_Surface *DX5_SetVideoMode(_THIS, SDL_Surface *current, 1044 SDL_Surface *
1013 int width, int height, int bpp, Uint32 flags) 1045 DX5_SetVideoMode (_THIS, SDL_Surface * current,
1014 { 1046 int width, int height, int bpp, Uint32 flags)
1015 SDL_Surface *video; 1047 {
1016 HRESULT result; 1048 SDL_Surface *video;
1017 DWORD sharemode; 1049 HRESULT result;
1018 DWORD style; 1050 DWORD sharemode;
1019 const DWORD directstyle = 1051 DWORD style;
1020 (WS_POPUP); 1052 const DWORD directstyle = (WS_POPUP);
1021 const DWORD windowstyle = 1053 const DWORD windowstyle =
1022 (WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX); 1054 (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX);
1023 const DWORD resizestyle = 1055 const DWORD resizestyle = (WS_THICKFRAME | WS_MAXIMIZEBOX);
1024 (WS_THICKFRAME|WS_MAXIMIZEBOX); 1056 DDSURFACEDESC ddsd;
1025 DDSURFACEDESC ddsd; 1057 LPDIRECTDRAWSURFACE dd_surface1;
1026 LPDIRECTDRAWSURFACE dd_surface1; 1058 LPDIRECTDRAWSURFACE3 dd_surface3;
1027 LPDIRECTDRAWSURFACE3 dd_surface3; 1059
1028 1060 SDL_resizing = 1;
1029 SDL_resizing = 1;
1030 #ifdef DDRAW_DEBUG 1061 #ifdef DDRAW_DEBUG
1031 fprintf(stderr, "Setting %dx%dx%d video mode\n", width, height, bpp); 1062 fprintf (stderr, "Setting %dx%dx%d video mode\n", width, height, bpp);
1032 #endif 1063 #endif
1033 /* Clean up any previous DirectDraw surfaces */ 1064 /* Clean up any previous DirectDraw surfaces */
1034 if ( current->hwdata ) { 1065 if (current->hwdata) {
1035 this->FreeHWSurface(this, current); 1066 this->FreeHWSurface (this, current);
1036 current->hwdata = NULL; 1067 current->hwdata = NULL;
1037 } 1068 }
1038 if ( SDL_primary != NULL ) { 1069 if (SDL_primary != NULL) {
1039 IDirectDrawSurface3_Release(SDL_primary); 1070 IDirectDrawSurface3_Release (SDL_primary);
1040 SDL_primary = NULL; 1071 SDL_primary = NULL;
1041 } 1072 }
1042
1043 #ifndef NO_CHANGEDISPLAYSETTINGS 1073 #ifndef NO_CHANGEDISPLAYSETTINGS
1044 /* Unset any previous OpenGL fullscreen mode */ 1074 /* Unset any previous OpenGL fullscreen mode */
1045 if ( (current->flags & (SDL_INTERNALOPENGL|SDL_FULLSCREEN)) == 1075 if ((current->flags & (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) ==
1046 (SDL_INTERNALOPENGL|SDL_FULLSCREEN) ) { 1076 (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) {
1047 ChangeDisplaySettings(NULL, 0); 1077 ChangeDisplaySettings (NULL, 0);
1048 } 1078 }
1049 #endif 1079 #endif
1050 1080
1051 /* Clean up any GL context that may be hanging around */ 1081 /* Clean up any GL context that may be hanging around */
1052 if ( current->flags & SDL_INTERNALOPENGL ) { 1082 if (current->flags & SDL_INTERNALOPENGL) {
1053 WIN_GL_ShutDown(this); 1083 WIN_GL_ShutDown (this);
1054 } 1084 }
1055 1085
1056 /* If we are setting a GL mode, use GDI, not DirectX (yuck) */ 1086 /* If we are setting a GL mode, use GDI, not DirectX (yuck) */
1057 if ( flags & SDL_INTERNALOPENGL ) { 1087 if (flags & SDL_INTERNALOPENGL) {
1058 Uint32 Rmask, Gmask, Bmask; 1088 Uint32 Rmask, Gmask, Bmask;
1059 1089
1060 /* Recalculate the bitmasks if necessary */ 1090 /* Recalculate the bitmasks if necessary */
1061 if ( bpp == current->format->BitsPerPixel ) { 1091 if (bpp == current->format->BitsPerPixel) {
1062 video = current; 1092 video = current;
1063 } else { 1093 } else {
1064 switch (bpp) { 1094 switch (bpp) {
1065 case 15: 1095 case 15:
1066 case 16: 1096 case 16:
1067 if ( 0 /*DIB_SussScreenDepth() == 15*/ ) { 1097 if (0 /*DIB_SussScreenDepth() == 15 */ ) {
1068 /* 5-5-5 */ 1098 /* 5-5-5 */
1069 Rmask = 0x00007c00; 1099 Rmask = 0x00007c00;
1070 Gmask = 0x000003e0; 1100 Gmask = 0x000003e0;
1071 Bmask = 0x0000001f; 1101 Bmask = 0x0000001f;
1072 } else { 1102 } else {
1073 /* 5-6-5 */ 1103 /* 5-6-5 */
1074 Rmask = 0x0000f800; 1104 Rmask = 0x0000f800;
1075 Gmask = 0x000007e0; 1105 Gmask = 0x000007e0;
1076 Bmask = 0x0000001f; 1106 Bmask = 0x0000001f;
1077 } 1107 }
1078 break; 1108 break;
1079 case 24: 1109 case 24:
1080 case 32: 1110 case 32:
1081 /* GDI defined as 8-8-8 */ 1111 /* GDI defined as 8-8-8 */
1082 Rmask = 0x00ff0000; 1112 Rmask = 0x00ff0000;
1083 Gmask = 0x0000ff00; 1113 Gmask = 0x0000ff00;
1084 Bmask = 0x000000ff; 1114 Bmask = 0x000000ff;
1085 break; 1115 break;
1086 default: 1116 default:
1087 Rmask = 0x00000000; 1117 Rmask = 0x00000000;
1088 Gmask = 0x00000000; 1118 Gmask = 0x00000000;
1089 Bmask = 0x00000000; 1119 Bmask = 0x00000000;
1090 break; 1120 break;
1091 } 1121 }
1092 video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, bpp, 1122 video = SDL_CreateRGBSurface (SDL_SWSURFACE, 0, 0, bpp,
1093 Rmask, Gmask, Bmask, 0); 1123 Rmask, Gmask, Bmask, 0);
1094 if ( video == NULL ) { 1124 if (video == NULL) {
1095 SDL_OutOfMemory(); 1125 SDL_OutOfMemory ();
1096 return(NULL); 1126 return (NULL);
1097 } 1127 }
1098 } 1128 }
1099 1129
1100 /* Fill in part of the video surface */ 1130 /* Fill in part of the video surface */
1101 video->flags = 0; /* Clear flags */ 1131 video->flags = 0; /* Clear flags */
1102 video->w = width; 1132 video->w = width;
1103 video->h = height; 1133 video->h = height;
1104 video->pitch = SDL_CalculatePitch(video); 1134 video->pitch = SDL_CalculatePitch (video);
1105 1135
1106 #ifndef NO_CHANGEDISPLAYSETTINGS 1136 #ifndef NO_CHANGEDISPLAYSETTINGS
1107 /* Set fullscreen mode if appropriate. 1137 /* Set fullscreen mode if appropriate.
1108 Ugh, since our list of valid video modes comes from 1138 Ugh, since our list of valid video modes comes from
1109 the DirectX driver, we may not actually be able to 1139 the DirectX driver, we may not actually be able to
1110 change to the desired resolution here. 1140 change to the desired resolution here.
1111 FIXME: Should we do a closest match? 1141 FIXME: Should we do a closest match?
1112 */ 1142 */
1113 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 1143 if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
1114 DEVMODE settings; 1144 DEVMODE settings;
1115 BOOL changed; 1145 BOOL changed;
1116 1146
1117 SDL_memset(&settings, 0, sizeof(DEVMODE)); 1147 SDL_memset (&settings, 0, sizeof (DEVMODE));
1118 settings.dmSize = sizeof(DEVMODE); 1148 settings.dmSize = sizeof (DEVMODE);
1119 settings.dmBitsPerPel = video->format->BitsPerPixel; 1149 settings.dmBitsPerPel = video->format->BitsPerPixel;
1120 settings.dmPelsWidth = width; 1150 settings.dmPelsWidth = width;
1121 settings.dmPelsHeight = height; 1151 settings.dmPelsHeight = height;
1122 settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL; 1152 settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
1123 if ( width <= (int)SDL_desktop_mode.dmPelsWidth && 1153 if (width <= (int) SDL_desktop_mode.dmPelsWidth
1124 height <= (int)SDL_desktop_mode.dmPelsHeight ) { 1154 && height <= (int) SDL_desktop_mode.dmPelsHeight) {
1125 settings.dmDisplayFrequency = SDL_desktop_mode.dmDisplayFrequency; 1155 settings.dmDisplayFrequency =
1126 settings.dmFields |= DM_DISPLAYFREQUENCY; 1156 SDL_desktop_mode.dmDisplayFrequency;
1127 } 1157 settings.dmFields |= DM_DISPLAYFREQUENCY;
1128 changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL); 1158 }
1129 if ( ! changed && (settings.dmFields & DM_DISPLAYFREQUENCY) ) { 1159 changed =
1130 settings.dmFields &= ~DM_DISPLAYFREQUENCY; 1160 (ChangeDisplaySettings (&settings, CDS_FULLSCREEN) ==
1131 changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL); 1161 DISP_CHANGE_SUCCESSFUL);
1132 } 1162 if (!changed && (settings.dmFields & DM_DISPLAYFREQUENCY)) {
1133 if ( changed ) { 1163 settings.dmFields &= ~DM_DISPLAYFREQUENCY;
1134 video->flags |= SDL_FULLSCREEN; 1164 changed = (ChangeDisplaySettings (&settings, CDS_FULLSCREEN)
1135 SDL_fullscreen_mode = settings; 1165 == DISP_CHANGE_SUCCESSFUL);
1136 } 1166 }
1137 } 1167 if (changed) {
1168 video->flags |= SDL_FULLSCREEN;
1169 SDL_fullscreen_mode = settings;
1170 }
1171 }
1138 #endif /* !NO_CHANGEDISPLAYSETTINGS */ 1172 #endif /* !NO_CHANGEDISPLAYSETTINGS */
1139 1173
1140 style = GetWindowLong(SDL_Window, GWL_STYLE); 1174 style = GetWindowLong (SDL_Window, GWL_STYLE);
1141 style &= ~(resizestyle|WS_MAXIMIZE); 1175 style &= ~(resizestyle | WS_MAXIMIZE);
1142 if ( video->flags & SDL_FULLSCREEN ) { 1176 if (video->flags & SDL_FULLSCREEN) {
1143 style &= ~windowstyle; 1177 style &= ~windowstyle;
1144 style |= directstyle; 1178 style |= directstyle;
1145 } else { 1179 } else {
1146 if ( flags & SDL_NOFRAME ) { 1180 if (flags & SDL_NOFRAME) {
1147 style &= ~windowstyle; 1181 style &= ~windowstyle;
1148 style |= directstyle; 1182 style |= directstyle;
1149 video->flags |= SDL_NOFRAME; 1183 video->flags |= SDL_NOFRAME;
1150 } else { 1184 } else {
1151 style &= ~directstyle; 1185 style &= ~directstyle;
1152 style |= windowstyle; 1186 style |= windowstyle;
1153 if ( flags & SDL_RESIZABLE ) { 1187 if (flags & SDL_RESIZABLE) {
1154 style |= resizestyle; 1188 style |= resizestyle;
1155 video->flags |= SDL_RESIZABLE; 1189 video->flags |= SDL_RESIZABLE;
1156 } 1190 }
1157 } 1191 }
1158 #if WS_MAXIMIZE 1192 #if WS_MAXIMIZE
1159 if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE; 1193 if (IsZoomed (SDL_Window))
1160 #endif 1194 style |= WS_MAXIMIZE;
1161 } 1195 #endif
1162 1196 }
1163 /* DJM: Don't piss of anyone who has setup his own window */ 1197
1164 if ( !SDL_windowid ) 1198 /* DJM: Don't piss of anyone who has setup his own window */
1165 SetWindowLong(SDL_Window, GWL_STYLE, style); 1199 if (!SDL_windowid)
1166 1200 SetWindowLong (SDL_Window, GWL_STYLE, style);
1167 /* Resize the window (copied from SDL WinDIB driver) */ 1201
1168 if ( !SDL_windowid && !IsZoomed(SDL_Window) ) { 1202 /* Resize the window (copied from SDL WinDIB driver) */
1169 RECT bounds; 1203 if (!SDL_windowid && !IsZoomed (SDL_Window)) {
1170 int x, y; 1204 RECT bounds;
1171 HWND top; 1205 int x, y;
1172 UINT swp_flags; 1206 HWND top;
1173 const char *window = NULL; 1207 UINT swp_flags;
1174 const char *center = NULL; 1208 const char *window = NULL;
1175 1209 const char *center = NULL;
1176 if ( !SDL_windowX && !SDL_windowY ) { 1210
1177 window = SDL_getenv("SDL_VIDEO_WINDOW_POS"); 1211 if (!SDL_windowX && !SDL_windowY) {
1178 center = SDL_getenv("SDL_VIDEO_CENTERED"); 1212 window = SDL_getenv ("SDL_VIDEO_WINDOW_POS");
1179 if ( window ) { 1213 center = SDL_getenv ("SDL_VIDEO_CENTERED");
1180 if ( SDL_sscanf(window, "%d,%d", &x, &y) == 2 ) { 1214 if (window) {
1181 SDL_windowX = x; 1215 if (SDL_sscanf (window, "%d,%d", &x, &y) == 2) {
1182 SDL_windowY = y; 1216 SDL_windowX = x;
1183 } 1217 SDL_windowY = y;
1184 if ( SDL_strcmp(window, "center") == 0 ) { 1218 }
1185 center = window; 1219 if (SDL_strcmp (window, "center") == 0) {
1186 } 1220 center = window;
1187 } 1221 }
1188 } 1222 }
1189 swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW); 1223 }
1190 1224 swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW);
1191 bounds.left = SDL_windowX; 1225
1192 bounds.top = SDL_windowY; 1226 bounds.left = SDL_windowX;
1193 bounds.right = SDL_windowX+video->w; 1227 bounds.top = SDL_windowY;
1194 bounds.bottom = SDL_windowY+video->h; 1228 bounds.right = SDL_windowX + video->w;
1195 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), FALSE, 0); 1229 bounds.bottom = SDL_windowY + video->h;
1196 width = bounds.right-bounds.left; 1230 AdjustWindowRectEx (&bounds,
1197 height = bounds.bottom-bounds.top; 1231 GetWindowLong (SDL_Window, GWL_STYLE),
1198 if ( (flags & SDL_FULLSCREEN) ) { 1232 FALSE, 0);
1199 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2; 1233 width = bounds.right - bounds.left;
1200 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2; 1234 height = bounds.bottom - bounds.top;
1201 } else if ( center ) { 1235 if ((flags & SDL_FULLSCREEN)) {
1202 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2; 1236 x = (GetSystemMetrics (SM_CXSCREEN) - width) / 2;
1203 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2; 1237 y = (GetSystemMetrics (SM_CYSCREEN) - height) / 2;
1204 } else if ( SDL_windowX || SDL_windowY || window ) { 1238 } else if (center) {
1205 x = bounds.left; 1239 x = (GetSystemMetrics (SM_CXSCREEN) - width) / 2;
1206 y = bounds.top; 1240 y = (GetSystemMetrics (SM_CYSCREEN) - height) / 2;
1207 } else { 1241 } else if (SDL_windowX || SDL_windowY || window) {
1208 x = y = -1; 1242 x = bounds.left;
1209 swp_flags |= SWP_NOMOVE; 1243 y = bounds.top;
1210 } 1244 } else {
1211 if ( flags & SDL_FULLSCREEN ) { 1245 x = y = -1;
1212 top = HWND_TOPMOST; 1246 swp_flags |= SWP_NOMOVE;
1213 } else { 1247 }
1214 top = HWND_NOTOPMOST; 1248 if (flags & SDL_FULLSCREEN) {
1215 } 1249 top = HWND_TOPMOST;
1216 SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags); 1250 } else {
1217 if ( !(flags & SDL_FULLSCREEN) ) { 1251 top = HWND_NOTOPMOST;
1218 SDL_windowX = SDL_bounds.left; 1252 }
1219 SDL_windowY = SDL_bounds.top; 1253 SetWindowPos (SDL_Window, top, x, y, width, height, swp_flags);
1220 } 1254 if (!(flags & SDL_FULLSCREEN)) {
1221 SetForegroundWindow(SDL_Window); 1255 SDL_windowX = SDL_bounds.left;
1222 } 1256 SDL_windowY = SDL_bounds.top;
1223 SDL_resizing = 0; 1257 }
1224 1258 SetForegroundWindow (SDL_Window);
1225 /* Set up for OpenGL */ 1259 }
1226 if ( WIN_GL_SetupWindow(this) < 0 ) { 1260 SDL_resizing = 0;
1227 return(NULL); 1261
1228 } 1262 /* Set up for OpenGL */
1229 video->flags |= SDL_INTERNALOPENGL; 1263 if (WIN_GL_SetupWindow (this) < 0) {
1230 return(video); 1264 return (NULL);
1231 } 1265 }
1232 1266 video->flags |= SDL_INTERNALOPENGL;
1233 /* Set the appropriate window style */ 1267 return (video);
1234 style = GetWindowLong(SDL_Window, GWL_STYLE); 1268 }
1235 style &= ~(resizestyle|WS_MAXIMIZE); 1269
1236 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 1270 /* Set the appropriate window style */
1237 style &= ~windowstyle; 1271 style = GetWindowLong (SDL_Window, GWL_STYLE);
1238 style |= directstyle; 1272 style &= ~(resizestyle | WS_MAXIMIZE);
1239 } else { 1273 if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
1240 if ( flags & SDL_NOFRAME ) { 1274 style &= ~windowstyle;
1241 style &= ~windowstyle; 1275 style |= directstyle;
1242 style |= directstyle; 1276 } else {
1243 } else { 1277 if (flags & SDL_NOFRAME) {
1244 style &= ~directstyle; 1278 style &= ~windowstyle;
1245 style |= windowstyle; 1279 style |= directstyle;
1246 if ( flags & SDL_RESIZABLE ) { 1280 } else {
1247 style |= resizestyle; 1281 style &= ~directstyle;
1248 } 1282 style |= windowstyle;
1249 } 1283 if (flags & SDL_RESIZABLE) {
1284 style |= resizestyle;
1285 }
1286 }
1250 #if WS_MAXIMIZE 1287 #if WS_MAXIMIZE
1251 if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE; 1288 if (IsZoomed (SDL_Window))
1252 #endif 1289 style |= WS_MAXIMIZE;
1253 } 1290 #endif
1254 /* DJM: Don't piss of anyone who has setup his own window */ 1291 }
1255 if ( !SDL_windowid ) 1292 /* DJM: Don't piss of anyone who has setup his own window */
1256 SetWindowLong(SDL_Window, GWL_STYLE, style); 1293 if (!SDL_windowid)
1257 1294 SetWindowLong (SDL_Window, GWL_STYLE, style);
1258 /* Set DirectDraw sharing mode.. exclusive when fullscreen */ 1295
1259 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 1296 /* Set DirectDraw sharing mode.. exclusive when fullscreen */
1260 sharemode = DDSCL_FULLSCREEN|DDSCL_EXCLUSIVE|DDSCL_ALLOWREBOOT; 1297 if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
1261 } else { 1298 sharemode = DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT;
1262 sharemode = DDSCL_NORMAL; 1299 } else {
1263 } 1300 sharemode = DDSCL_NORMAL;
1264 result = IDirectDraw2_SetCooperativeLevel(ddraw2,SDL_Window,sharemode); 1301 }
1265 if ( result != DD_OK ) { 1302 result = IDirectDraw2_SetCooperativeLevel (ddraw2, SDL_Window, sharemode);
1266 SetDDerror("DirectDraw2::SetCooperativeLevel", result); 1303 if (result != DD_OK) {
1267 return(NULL); 1304 SetDDerror ("DirectDraw2::SetCooperativeLevel", result);
1268 } 1305 return (NULL);
1269 1306 }
1270 /* Set the display mode, if we are in fullscreen mode */ 1307
1271 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 1308 /* Set the display mode, if we are in fullscreen mode */
1272 RECT bounds; 1309 if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
1273 struct DX5EnumRect *rect; 1310 RECT bounds;
1274 int maxRefreshRate; 1311 struct DX5EnumRect *rect;
1275 1312 int maxRefreshRate;
1276 /* Cover up desktop during mode change */ 1313
1277 bounds.left = 0; 1314 /* Cover up desktop during mode change */
1278 bounds.top = 0; 1315 bounds.left = 0;
1279 bounds.right = GetSystemMetrics(SM_CXSCREEN); 1316 bounds.top = 0;
1280 bounds.bottom = GetSystemMetrics(SM_CYSCREEN); 1317 bounds.right = GetSystemMetrics (SM_CXSCREEN);
1281 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), FALSE, 0); 1318 bounds.bottom = GetSystemMetrics (SM_CYSCREEN);
1282 SetWindowPos(SDL_Window, HWND_TOPMOST, 1319 AdjustWindowRectEx (&bounds, GetWindowLong (SDL_Window, GWL_STYLE),
1283 bounds.left, bounds.top, 1320 FALSE, 0);
1284 bounds.right - bounds.left, 1321 SetWindowPos (SDL_Window, HWND_TOPMOST, bounds.left, bounds.top,
1285 bounds.bottom - bounds.top, SWP_NOCOPYBITS); 1322 bounds.right - bounds.left,
1286 ShowWindow(SDL_Window, SW_SHOW); 1323 bounds.bottom - bounds.top, SWP_NOCOPYBITS);
1287 while ( GetForegroundWindow() != SDL_Window ) { 1324 ShowWindow (SDL_Window, SW_SHOW);
1288 SetForegroundWindow(SDL_Window); 1325 while (GetForegroundWindow () != SDL_Window) {
1289 SDL_Delay(100); 1326 SetForegroundWindow (SDL_Window);
1290 } 1327 SDL_Delay (100);
1291 1328 }
1292 /* find maximum monitor refresh rate for this resolution */ 1329
1293 /* Dmitry Yakimov ftech@tula.net */ 1330 /* find maximum monitor refresh rate for this resolution */
1294 maxRefreshRate = 0; /* system default */ 1331 /* Dmitry Yakimov ftech@tula.net */
1295 for ( rect = enumlists[bpp / 8 - 1]; rect; rect = rect->next ) { 1332 maxRefreshRate = 0; /* system default */
1296 if ( (width == rect->r.w) && (height == rect->r.h) ) { 1333 for (rect = enumlists[bpp / 8 - 1]; rect; rect = rect->next) {
1297 maxRefreshRate = rect->refreshRate; 1334 if ((width == rect->r.w) && (height == rect->r.h)) {
1298 break; 1335 maxRefreshRate = rect->refreshRate;
1299 } 1336 break;
1300 } 1337 }
1338 }
1301 #ifdef DDRAW_DEBUG 1339 #ifdef DDRAW_DEBUG
1302 fprintf(stderr, "refresh rate = %d Hz\n", maxRefreshRate); 1340 fprintf (stderr, "refresh rate = %d Hz\n", maxRefreshRate);
1303 #endif 1341 #endif
1304 1342
1305 result = IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp, maxRefreshRate, 0); 1343 result =
1306 if ( result != DD_OK ) { 1344 IDirectDraw2_SetDisplayMode (ddraw2, width, height, bpp,
1307 result = IDirectDraw2_SetDisplayMode(ddraw2, width, height, bpp, 0, 0); 1345 maxRefreshRate, 0);
1308 if ( result != DD_OK ) { 1346 if (result != DD_OK) {
1309 /* We couldn't set fullscreen mode, try window */ 1347 result =
1310 return(DX5_SetVideoMode(this, current, width, height, bpp, flags & ~SDL_FULLSCREEN)); 1348 IDirectDraw2_SetDisplayMode (ddraw2, width, height, bpp,
1311 } 1349 0, 0);
1312 } 1350 if (result != DD_OK) {
1313 DX5_DInputReset(this, 1); 1351 /* We couldn't set fullscreen mode, try window */
1314 } else { 1352 return (DX5_SetVideoMode
1315 DX5_DInputReset(this, 0); 1353 (this, current, width, height, bpp,
1316 } 1354 flags & ~SDL_FULLSCREEN));
1317 DX5_UpdateVideoInfo(this); 1355 }
1318 1356 }
1319 /* Create a primary DirectDraw surface */ 1357 DX5_DInputReset (this, 1);
1320 SDL_memset(&ddsd, 0, sizeof(ddsd)); 1358 } else {
1321 ddsd.dwSize = sizeof(ddsd); 1359 DX5_DInputReset (this, 0);
1322 ddsd.dwFlags = DDSD_CAPS; 1360 }
1323 ddsd.ddsCaps.dwCaps = (DDSCAPS_PRIMARYSURFACE|DDSCAPS_VIDEOMEMORY); 1361 DX5_UpdateVideoInfo (this);
1324 if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) { 1362
1325 /* There's no windowed double-buffering */ 1363 /* Create a primary DirectDraw surface */
1326 flags &= ~SDL_DOUBLEBUF; 1364 SDL_memset (&ddsd, 0, sizeof (ddsd));
1327 } 1365 ddsd.dwSize = sizeof (ddsd);
1328 if ( (flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { 1366 ddsd.dwFlags = DDSD_CAPS;
1329 ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT; 1367 ddsd.ddsCaps.dwCaps = (DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY);
1330 ddsd.ddsCaps.dwCaps |= (DDSCAPS_COMPLEX|DDSCAPS_FLIP); 1368 if ((flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
1331 ddsd.dwBackBufferCount = 1; 1369 /* There's no windowed double-buffering */
1332 } 1370 flags &= ~SDL_DOUBLEBUF;
1333 result = IDirectDraw2_CreateSurface(ddraw2, &ddsd, &dd_surface1, NULL); 1371 }
1334 if ( (result != DD_OK) && ((flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) ) { 1372 if ((flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
1335 ddsd.dwFlags &= ~DDSD_BACKBUFFERCOUNT; 1373 ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT;
1336 ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_COMPLEX|DDSCAPS_FLIP); 1374 ddsd.ddsCaps.dwCaps |= (DDSCAPS_COMPLEX | DDSCAPS_FLIP);
1337 ddsd.dwBackBufferCount = 0; 1375 ddsd.dwBackBufferCount = 1;
1338 result = IDirectDraw2_CreateSurface(ddraw2, 1376 }
1339 &ddsd, &dd_surface1, NULL); 1377 result = IDirectDraw2_CreateSurface (ddraw2, &ddsd, &dd_surface1, NULL);
1340 } 1378 if ((result != DD_OK) && ((flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)) {
1341 if ( result != DD_OK ) { 1379 ddsd.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
1342 SetDDerror("DirectDraw2::CreateSurface(PRIMARY)", result); 1380 ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_COMPLEX | DDSCAPS_FLIP);
1343 return(NULL); 1381 ddsd.dwBackBufferCount = 0;
1344 } 1382 result = IDirectDraw2_CreateSurface (ddraw2,
1345 result = IDirectDrawSurface_QueryInterface(dd_surface1, 1383 &ddsd, &dd_surface1, NULL);
1346 &IID_IDirectDrawSurface3, (LPVOID *)&SDL_primary); 1384 }
1347 if ( result != DD_OK ) { 1385 if (result != DD_OK) {
1348 SetDDerror("DirectDrawSurface::QueryInterface", result); 1386 SetDDerror ("DirectDraw2::CreateSurface(PRIMARY)", result);
1349 return(NULL); 1387 return (NULL);
1350 } 1388 }
1351 IDirectDrawSurface_Release(dd_surface1); 1389 result = IDirectDrawSurface_QueryInterface (dd_surface1,
1352 1390 &IID_IDirectDrawSurface3,
1353 /* Get the format of the primary DirectDraw surface */ 1391 (LPVOID *) & SDL_primary);
1354 SDL_memset(&ddsd, 0, sizeof(ddsd)); 1392 if (result != DD_OK) {
1355 ddsd.dwSize = sizeof(ddsd); 1393 SetDDerror ("DirectDrawSurface::QueryInterface", result);
1356 ddsd.dwFlags = DDSD_PIXELFORMAT|DDSD_CAPS; 1394 return (NULL);
1357 result = IDirectDrawSurface3_GetSurfaceDesc(SDL_primary, &ddsd); 1395 }
1358 if ( result != DD_OK ) { 1396 IDirectDrawSurface_Release (dd_surface1);
1359 SetDDerror("DirectDrawSurface::GetSurfaceDesc", result); 1397
1360 return(NULL); 1398 /* Get the format of the primary DirectDraw surface */
1361 } 1399 SDL_memset (&ddsd, 0, sizeof (ddsd));
1362 if ( ! (ddsd.ddpfPixelFormat.dwFlags&DDPF_RGB) ) { 1400 ddsd.dwSize = sizeof (ddsd);
1363 SDL_SetError("Primary DDRAW surface is not RGB format"); 1401 ddsd.dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
1364 return(NULL); 1402 result = IDirectDrawSurface3_GetSurfaceDesc (SDL_primary, &ddsd);
1365 } 1403 if (result != DD_OK) {
1366 1404 SetDDerror ("DirectDrawSurface::GetSurfaceDesc", result);
1367 /* Free old palette and create a new one if we're in 8-bit mode */ 1405 return (NULL);
1368 if ( SDL_palette != NULL ) { 1406 }
1369 IDirectDrawPalette_Release(SDL_palette); 1407 if (!(ddsd.ddpfPixelFormat.dwFlags & DDPF_RGB)) {
1370 SDL_palette = NULL; 1408 SDL_SetError ("Primary DDRAW surface is not RGB format");
1371 } 1409 return (NULL);
1410 }
1411
1412 /* Free old palette and create a new one if we're in 8-bit mode */
1413 if (SDL_palette != NULL) {
1414 IDirectDrawPalette_Release (SDL_palette);
1415 SDL_palette = NULL;
1416 }
1372 #if defined(NONAMELESSUNION) 1417 #if defined(NONAMELESSUNION)
1373 if ( ddsd.ddpfPixelFormat.u1.dwRGBBitCount == 8 ) { 1418 if (ddsd.ddpfPixelFormat.u1.dwRGBBitCount == 8) {
1374 #else 1419 #else
1375 if ( ddsd.ddpfPixelFormat.dwRGBBitCount == 8 ) { 1420 if (ddsd.ddpfPixelFormat.dwRGBBitCount == 8) {
1376 #endif 1421 #endif
1377 int i; 1422 int i;
1378 1423
1379 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 1424 if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
1380 /* We have access to the entire palette */ 1425 /* We have access to the entire palette */
1381 for ( i=0; i<256; ++i ) { 1426 for (i = 0; i < 256; ++i) {
1382 SDL_colors[i].peFlags = 1427 SDL_colors[i].peFlags = (PC_NOCOLLAPSE | PC_RESERVED);
1383 (PC_NOCOLLAPSE|PC_RESERVED); 1428 SDL_colors[i].peRed = 0;
1384 SDL_colors[i].peRed = 0; 1429 SDL_colors[i].peGreen = 0;
1385 SDL_colors[i].peGreen = 0; 1430 SDL_colors[i].peBlue = 0;
1386 SDL_colors[i].peBlue = 0; 1431 }
1387 } 1432 } else {
1388 } else { 1433 /* First 10 colors are reserved by Windows */
1389 /* First 10 colors are reserved by Windows */ 1434 for (i = 0; i < 10; ++i) {
1390 for ( i=0; i<10; ++i ) { 1435 SDL_colors[i].peFlags = PC_EXPLICIT;
1391 SDL_colors[i].peFlags = PC_EXPLICIT; 1436 SDL_colors[i].peRed = i;
1392 SDL_colors[i].peRed = i; 1437 SDL_colors[i].peGreen = 0;
1393 SDL_colors[i].peGreen = 0; 1438 SDL_colors[i].peBlue = 0;
1394 SDL_colors[i].peBlue = 0; 1439 }
1395 } 1440 for (i = 10; i < (10 + 236); ++i) {
1396 for ( i=10; i<(10+236); ++i ) { 1441 SDL_colors[i].peFlags = PC_NOCOLLAPSE;
1397 SDL_colors[i].peFlags = PC_NOCOLLAPSE; 1442 SDL_colors[i].peRed = 0;
1398 SDL_colors[i].peRed = 0; 1443 SDL_colors[i].peGreen = 0;
1399 SDL_colors[i].peGreen = 0; 1444 SDL_colors[i].peBlue = 0;
1400 SDL_colors[i].peBlue = 0; 1445 }
1401 } 1446 /* Last 10 colors are reserved by Windows */
1402 /* Last 10 colors are reserved by Windows */ 1447 for (i = 246; i < 256; ++i) {
1403 for ( i=246; i<256; ++i ) { 1448 SDL_colors[i].peFlags = PC_EXPLICIT;
1404 SDL_colors[i].peFlags = PC_EXPLICIT; 1449 SDL_colors[i].peRed = i;
1405 SDL_colors[i].peRed = i; 1450 SDL_colors[i].peGreen = 0;
1406 SDL_colors[i].peGreen = 0; 1451 SDL_colors[i].peBlue = 0;
1407 SDL_colors[i].peBlue = 0; 1452 }
1408 } 1453 }
1409 } 1454 result = IDirectDraw2_CreatePalette (ddraw2,
1410 result = IDirectDraw2_CreatePalette(ddraw2, 1455 (DDPCAPS_8BIT |
1411 (DDPCAPS_8BIT|DDPCAPS_ALLOW256), 1456 DDPCAPS_ALLOW256), SDL_colors,
1412 SDL_colors, &SDL_palette, NULL); 1457 &SDL_palette, NULL);
1413 if ( result != DD_OK ) { 1458 if (result != DD_OK) {
1414 SetDDerror("DirectDraw2::CreatePalette", result); 1459 SetDDerror ("DirectDraw2::CreatePalette", result);
1415 return(NULL); 1460 return (NULL);
1416 } 1461 }
1417 result = IDirectDrawSurface3_SetPalette(SDL_primary, 1462 result = IDirectDrawSurface3_SetPalette (SDL_primary, SDL_palette);
1418 SDL_palette); 1463 if (result != DD_OK) {
1419 if ( result != DD_OK ) { 1464 SetDDerror ("DirectDrawSurface3::SetPalette", result);
1420 SetDDerror("DirectDrawSurface3::SetPalette", result); 1465 return (NULL);
1421 return(NULL); 1466 }
1422 } 1467 }
1423 } 1468
1424 1469 /* Create our video surface using the same pixel format */
1425 /* Create our video surface using the same pixel format */ 1470 video = current;
1426 video = current; 1471 if ((width != video->w) || (height != video->h)
1427 if ( (width != video->w) || (height != video->h) 1472 || (video->format->BitsPerPixel !=
1428 || (video->format->BitsPerPixel !=
1429 #if defined(NONAMELESSUNION) 1473 #if defined(NONAMELESSUNION)
1430 ddsd.ddpfPixelFormat.u1.dwRGBBitCount) ) { 1474 ddsd.ddpfPixelFormat.u1.dwRGBBitCount)) {
1431 #else 1475 #else
1432 ddsd.ddpfPixelFormat.dwRGBBitCount) ) { 1476 ddsd.ddpfPixelFormat.dwRGBBitCount)) {
1433 #endif 1477 #endif
1434 SDL_FreeSurface(video); 1478 SDL_FreeSurface (video);
1435 video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, 1479 video = SDL_CreateRGBSurface (SDL_SWSURFACE, 0, 0,
1436 #if defined(NONAMELESSUNION) 1480 #if defined(NONAMELESSUNION)
1437 ddsd.ddpfPixelFormat.u1.dwRGBBitCount, 1481 ddsd.ddpfPixelFormat.u1.dwRGBBitCount,
1438 ddsd.ddpfPixelFormat.u2.dwRBitMask, 1482 ddsd.ddpfPixelFormat.u2.dwRBitMask,
1439 ddsd.ddpfPixelFormat.u3.dwGBitMask, 1483 ddsd.ddpfPixelFormat.u3.dwGBitMask,
1440 ddsd.ddpfPixelFormat.u4.dwBBitMask, 1484 ddsd.ddpfPixelFormat.u4.dwBBitMask,
1441 #else 1485 #else
1442 ddsd.ddpfPixelFormat.dwRGBBitCount, 1486 ddsd.ddpfPixelFormat.dwRGBBitCount,
1443 ddsd.ddpfPixelFormat.dwRBitMask, 1487 ddsd.ddpfPixelFormat.dwRBitMask,
1444 ddsd.ddpfPixelFormat.dwGBitMask, 1488 ddsd.ddpfPixelFormat.dwGBitMask,
1445 ddsd.ddpfPixelFormat.dwBBitMask, 1489 ddsd.ddpfPixelFormat.dwBBitMask,
1446 #endif 1490 #endif
1447 0); 1491 0);
1448 if ( video == NULL ) { 1492 if (video == NULL) {
1449 SDL_OutOfMemory(); 1493 SDL_OutOfMemory ();
1450 return(NULL); 1494 return (NULL);
1451 } 1495 }
1452 video->w = width; 1496 video->w = width;
1453 video->h = height; 1497 video->h = height;
1454 video->pitch = 0; 1498 video->pitch = 0;
1455 } 1499 }
1456 video->flags = 0; /* Clear flags */ 1500 video->flags = 0; /* Clear flags */
1457 1501
1458 /* If not fullscreen, locking is possible, but it doesn't do what 1502 /* If not fullscreen, locking is possible, but it doesn't do what
1459 the caller really expects -- if the locked surface is written to, 1503 the caller really expects -- if the locked surface is written to,
1460 the appropriate portion of the entire screen is modified, not 1504 the appropriate portion of the entire screen is modified, not
1461 the application window, as we would like. 1505 the application window, as we would like.
1462 Note that it is still possible to write directly to display 1506 Note that it is still possible to write directly to display
1463 memory, but the application must respect the clip list of 1507 memory, but the application must respect the clip list of
1464 the surface. There might be some odd timing interactions 1508 the surface. There might be some odd timing interactions
1465 involving clip list updates and background refreshing as 1509 involving clip list updates and background refreshing as
1466 Windows moves other windows across our window. 1510 Windows moves other windows across our window.
1467 We currently don't support this, even though it might be a 1511 We currently don't support this, even though it might be a
1468 good idea since BeOS has an implementation of BDirectWindow 1512 good idea since BeOS has an implementation of BDirectWindow
1469 that does the same thing. This would be most useful for 1513 that does the same thing. This would be most useful for
1470 applications that do complete screen updates every frame. 1514 applications that do complete screen updates every frame.
1471 -- Fixme? 1515 -- Fixme?
1472 */ 1516 */
1473 if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) { 1517 if ((flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
1474 /* Necessary if we're going from fullscreen to window */ 1518 /* Necessary if we're going from fullscreen to window */
1475 if ( video->pixels == NULL ) { 1519 if (video->pixels == NULL) {
1476 video->pitch = (width*video->format->BytesPerPixel); 1520 video->pitch = (width * video->format->BytesPerPixel);
1477 /* Pitch needs to be QWORD (8-byte) aligned */ 1521 /* Pitch needs to be QWORD (8-byte) aligned */
1478 video->pitch = (video->pitch + 7) & ~7; 1522 video->pitch = (video->pitch + 7) & ~7;
1479 video->pixels = (void *)SDL_malloc(video->h*video->pitch); 1523 video->pixels = (void *) SDL_malloc (video->h * video->pitch);
1480 if ( video->pixels == NULL ) { 1524 if (video->pixels == NULL) {
1481 if ( video != current ) { 1525 if (video != current) {
1482 SDL_FreeSurface(video); 1526 SDL_FreeSurface (video);
1483 } 1527 }
1484 SDL_OutOfMemory(); 1528 SDL_OutOfMemory ();
1485 return(NULL); 1529 return (NULL);
1486 } 1530 }
1487 } 1531 }
1488 dd_surface3 = NULL; 1532 dd_surface3 = NULL;
1489 #if 0 /* FIXME: enable this when SDL consistently reports lost surfaces */ 1533 #if 0 /* FIXME: enable this when SDL consistently reports lost surfaces */
1490 if ( (flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { 1534 if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
1491 video->flags |= SDL_HWSURFACE; 1535 video->flags |= SDL_HWSURFACE;
1492 } else { 1536 } else {
1493 video->flags |= SDL_SWSURFACE; 1537 video->flags |= SDL_SWSURFACE;
1494 } 1538 }
1495 #else 1539 #else
1496 video->flags |= SDL_SWSURFACE; 1540 video->flags |= SDL_SWSURFACE;
1497 #endif 1541 #endif
1498 if ( (flags & SDL_RESIZABLE) && !(flags & SDL_NOFRAME) ) { 1542 if ((flags & SDL_RESIZABLE) && !(flags & SDL_NOFRAME)) {
1499 video->flags |= SDL_RESIZABLE; 1543 video->flags |= SDL_RESIZABLE;
1500 } 1544 }
1501 if ( flags & SDL_NOFRAME ) { 1545 if (flags & SDL_NOFRAME) {
1502 video->flags |= SDL_NOFRAME; 1546 video->flags |= SDL_NOFRAME;
1503 } 1547 }
1504 } else { 1548 } else {
1505 /* Necessary if we're going from window to fullscreen */ 1549 /* Necessary if we're going from window to fullscreen */
1506 if ( video->pixels != NULL ) { 1550 if (video->pixels != NULL) {
1507 SDL_free(video->pixels); 1551 SDL_free (video->pixels);
1508 video->pixels = NULL; 1552 video->pixels = NULL;
1509 } 1553 }
1510 dd_surface3 = SDL_primary; 1554 dd_surface3 = SDL_primary;
1511 video->flags |= SDL_HWSURFACE; 1555 video->flags |= SDL_HWSURFACE;
1512 } 1556 }
1513 1557
1514 /* See if the primary surface has double-buffering enabled */ 1558 /* See if the primary surface has double-buffering enabled */
1515 if ( (ddsd.ddsCaps.dwCaps & DDSCAPS_FLIP) == DDSCAPS_FLIP ) { 1559 if ((ddsd.ddsCaps.dwCaps & DDSCAPS_FLIP) == DDSCAPS_FLIP) {
1516 video->flags |= SDL_DOUBLEBUF; 1560 video->flags |= SDL_DOUBLEBUF;
1517 } 1561 }
1518 1562
1519 /* Allocate the SDL surface associated with the primary surface */ 1563 /* Allocate the SDL surface associated with the primary surface */
1520 if ( DX5_AllocDDSurface(this, video, dd_surface3, 1564 if (DX5_AllocDDSurface (this, video, dd_surface3,
1521 video->flags&SDL_HWSURFACE) < 0 ) { 1565 video->flags & SDL_HWSURFACE) < 0) {
1522 if ( video != current ) { 1566 if (video != current) {
1523 SDL_FreeSurface(video); 1567 SDL_FreeSurface (video);
1524 } 1568 }
1525 return(NULL); 1569 return (NULL);
1526 } 1570 }
1527 1571
1528 /* Use the appropriate blitting function */ 1572 /* Use the appropriate blitting function */
1529 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 1573 if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
1530 video->flags |= SDL_FULLSCREEN; 1574 video->flags |= SDL_FULLSCREEN;
1531 if ( video->format->palette != NULL ) { 1575 if (video->format->palette != NULL) {
1532 video->flags |= SDL_HWPALETTE; 1576 video->flags |= SDL_HWPALETTE;
1533 } 1577 }
1534 this->UpdateRects = DX5_DirectUpdate; 1578 this->UpdateRects = DX5_DirectUpdate;
1535 } else { 1579 } else {
1536 this->UpdateRects = DX5_WindowUpdate; 1580 this->UpdateRects = DX5_WindowUpdate;
1537 } 1581 }
1538 1582
1539 /* Make our window the proper size, set the clipper, then show it */ 1583 /* Make our window the proper size, set the clipper, then show it */
1540 if ( (flags & SDL_FULLSCREEN) != SDL_FULLSCREEN ) { 1584 if ((flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
1541 /* Create and set a clipper on our primary surface */ 1585 /* Create and set a clipper on our primary surface */
1542 if ( SDL_clipper == NULL ) { 1586 if (SDL_clipper == NULL) {
1543 result = IDirectDraw2_CreateClipper(ddraw2, 1587 result = IDirectDraw2_CreateClipper (ddraw2,
1544 0, &SDL_clipper, NULL); 1588 0, &SDL_clipper, NULL);
1545 if ( result != DD_OK ) { 1589 if (result != DD_OK) {
1546 if ( video != current ) { 1590 if (video != current) {
1547 SDL_FreeSurface(video); 1591 SDL_FreeSurface (video);
1548 } 1592 }
1549 SetDDerror("DirectDraw2::CreateClipper",result); 1593 SetDDerror ("DirectDraw2::CreateClipper", result);
1550 return(NULL); 1594 return (NULL);
1551 } 1595 }
1552 } 1596 }
1553 result = IDirectDrawClipper_SetHWnd(SDL_clipper, 0, SDL_Window); 1597 result = IDirectDrawClipper_SetHWnd (SDL_clipper, 0, SDL_Window);
1554 if ( result != DD_OK ) { 1598 if (result != DD_OK) {
1555 if ( video != current ) { 1599 if (video != current) {
1556 SDL_FreeSurface(video); 1600 SDL_FreeSurface (video);
1557 } 1601 }
1558 SetDDerror("DirectDrawClipper::SetHWnd", result); 1602 SetDDerror ("DirectDrawClipper::SetHWnd", result);
1559 return(NULL); 1603 return (NULL);
1560 } 1604 }
1561 result = IDirectDrawSurface3_SetClipper(SDL_primary, 1605 result = IDirectDrawSurface3_SetClipper (SDL_primary, SDL_clipper);
1562 SDL_clipper); 1606 if (result != DD_OK) {
1563 if ( result != DD_OK ) { 1607 if (video != current) {
1564 if ( video != current ) { 1608 SDL_FreeSurface (video);
1565 SDL_FreeSurface(video); 1609 }
1566 } 1610 SetDDerror ("DirectDrawSurface3::SetClipper", result);
1567 SetDDerror("DirectDrawSurface3::SetClipper", result); 1611 return (NULL);
1568 return(NULL); 1612 }
1569 } 1613
1570 1614 /* Resize the window (copied from SDL WinDIB driver) */
1571 /* Resize the window (copied from SDL WinDIB driver) */ 1615 if (!SDL_windowid && !IsZoomed (SDL_Window)) {
1572 if ( !SDL_windowid && !IsZoomed(SDL_Window) ) { 1616 RECT bounds;
1573 RECT bounds; 1617 int x, y;
1574 int x, y; 1618 UINT swp_flags;
1575 UINT swp_flags; 1619 const char *window = NULL;
1576 const char *window = NULL; 1620 const char *center = NULL;
1577 const char *center = NULL; 1621
1578 1622 if (!SDL_windowX && !SDL_windowY) {
1579 if ( !SDL_windowX && !SDL_windowY ) { 1623 window = SDL_getenv ("SDL_VIDEO_WINDOW_POS");
1580 window = SDL_getenv("SDL_VIDEO_WINDOW_POS"); 1624 center = SDL_getenv ("SDL_VIDEO_CENTERED");
1581 center = SDL_getenv("SDL_VIDEO_CENTERED"); 1625 if (window) {
1582 if ( window ) { 1626 if (SDL_sscanf (window, "%d,%d", &x, &y) == 2) {
1583 if ( SDL_sscanf(window, "%d,%d", &x, &y) == 2 ) { 1627 SDL_windowX = x;
1584 SDL_windowX = x; 1628 SDL_windowY = y;
1585 SDL_windowY = y; 1629 }
1586 } 1630 if (SDL_strcmp (window, "center") == 0) {
1587 if ( SDL_strcmp(window, "center") == 0 ) { 1631 center = window;
1588 center = window; 1632 }
1589 } 1633 }
1590 } 1634 }
1591 } 1635 swp_flags = SWP_NOCOPYBITS;
1592 swp_flags = SWP_NOCOPYBITS; 1636
1593 1637 bounds.left = SDL_windowX;
1594 bounds.left = SDL_windowX; 1638 bounds.top = SDL_windowY;
1595 bounds.top = SDL_windowY; 1639 bounds.right = SDL_windowX + video->w;
1596 bounds.right = SDL_windowX+video->w; 1640 bounds.bottom = SDL_windowY + video->h;
1597 bounds.bottom = SDL_windowY+video->h; 1641 AdjustWindowRectEx (&bounds,
1598 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), FALSE, 0); 1642 GetWindowLong (SDL_Window, GWL_STYLE),
1599 width = bounds.right-bounds.left; 1643 FALSE, 0);
1600 height = bounds.bottom-bounds.top; 1644 width = bounds.right - bounds.left;
1601 if ( center ) { 1645 height = bounds.bottom - bounds.top;
1602 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2; 1646 if (center) {
1603 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2; 1647 x = (GetSystemMetrics (SM_CXSCREEN) - width) / 2;
1604 } else if ( SDL_windowX || SDL_windowY || window ) { 1648 y = (GetSystemMetrics (SM_CYSCREEN) - height) / 2;
1605 x = bounds.left; 1649 } else if (SDL_windowX || SDL_windowY || window) {
1606 y = bounds.top; 1650 x = bounds.left;
1607 } else { 1651 y = bounds.top;
1608 x = y = -1; 1652 } else {
1609 swp_flags |= SWP_NOMOVE; 1653 x = y = -1;
1610 } 1654 swp_flags |= SWP_NOMOVE;
1611 SetWindowPos(SDL_Window, HWND_NOTOPMOST, x, y, width, height, swp_flags); 1655 }
1612 SDL_windowX = SDL_bounds.left; 1656 SetWindowPos (SDL_Window, HWND_NOTOPMOST, x, y, width, height,
1613 SDL_windowY = SDL_bounds.top; 1657 swp_flags);
1614 } 1658 SDL_windowX = SDL_bounds.left;
1615 1659 SDL_windowY = SDL_bounds.top;
1616 } 1660 }
1617 ShowWindow(SDL_Window, SW_SHOW); 1661
1618 SetForegroundWindow(SDL_Window); 1662 }
1619 SDL_resizing = 0; 1663 ShowWindow (SDL_Window, SW_SHOW);
1620 1664 SetForegroundWindow (SDL_Window);
1621 /* JC 14 Mar 2006 1665 SDL_resizing = 0;
1622 Flush the message loop or this can cause big problems later 1666
1623 Especially if the user decides to use dialog boxes or assert()! 1667 /* JC 14 Mar 2006
1624 */ 1668 Flush the message loop or this can cause big problems later
1625 WIN_FlushMessageQueue(); 1669 Especially if the user decides to use dialog boxes or assert()!
1626 1670 */
1627 /* We're live! */ 1671 WIN_FlushMessageQueue ();
1628 return(video); 1672
1629 } 1673 /* We're live! */
1630 1674 return (video);
1631 struct private_hwdata { 1675 }
1632 LPDIRECTDRAWSURFACE3 dd_surface; 1676
1633 LPDIRECTDRAWSURFACE3 dd_writebuf; 1677 struct private_hwdata
1678 {
1679 LPDIRECTDRAWSURFACE3 dd_surface;
1680 LPDIRECTDRAWSURFACE3 dd_writebuf;
1634 }; 1681 };
1635 1682
1636 static int DX5_AllocDDSurface(_THIS, SDL_Surface *surface, 1683 static int
1637 LPDIRECTDRAWSURFACE3 requested, Uint32 flag) 1684 DX5_AllocDDSurface (_THIS, SDL_Surface * surface,
1638 { 1685 LPDIRECTDRAWSURFACE3 requested, Uint32 flag)
1639 LPDIRECTDRAWSURFACE dd_surface1; 1686 {
1640 LPDIRECTDRAWSURFACE3 dd_surface3; 1687 LPDIRECTDRAWSURFACE dd_surface1;
1641 DDSURFACEDESC ddsd; 1688 LPDIRECTDRAWSURFACE3 dd_surface3;
1642 HRESULT result; 1689 DDSURFACEDESC ddsd;
1643 1690 HRESULT result;
1644 /* Clear the hardware flag, in case we fail */ 1691
1645 surface->flags &= ~flag; 1692 /* Clear the hardware flag, in case we fail */
1646 1693 surface->flags &= ~flag;
1647 /* Allocate the hardware acceleration data */ 1694
1648 surface->hwdata = (struct private_hwdata *) 1695 /* Allocate the hardware acceleration data */
1649 SDL_malloc(sizeof(*surface->hwdata)); 1696 surface->hwdata = (struct private_hwdata *)
1650 if ( surface->hwdata == NULL ) { 1697 SDL_malloc (sizeof (*surface->hwdata));
1651 SDL_OutOfMemory(); 1698 if (surface->hwdata == NULL) {
1652 return(-1); 1699 SDL_OutOfMemory ();
1653 } 1700 return (-1);
1654 dd_surface3 = NULL; 1701 }
1655 1702 dd_surface3 = NULL;
1656 /* Set up the surface description */ 1703
1657 SDL_memset(&ddsd, 0, sizeof(ddsd)); 1704 /* Set up the surface description */
1658 ddsd.dwSize = sizeof(ddsd); 1705 SDL_memset (&ddsd, 0, sizeof (ddsd));
1659 ddsd.dwFlags = (DDSD_WIDTH|DDSD_HEIGHT|DDSD_CAPS| 1706 ddsd.dwSize = sizeof (ddsd);
1660 DDSD_PITCH|DDSD_PIXELFORMAT); 1707 ddsd.dwFlags = (DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS |
1661 ddsd.dwWidth = surface->w; 1708 DDSD_PITCH | DDSD_PIXELFORMAT);
1662 ddsd.dwHeight= surface->h; 1709 ddsd.dwWidth = surface->w;
1710 ddsd.dwHeight = surface->h;
1663 #if defined(NONAMELESSUNION) 1711 #if defined(NONAMELESSUNION)
1664 ddsd.u1.lPitch = surface->pitch; 1712 ddsd.u1.lPitch = surface->pitch;
1665 #else 1713 #else
1666 ddsd.lPitch = surface->pitch; 1714 ddsd.lPitch = surface->pitch;
1667 #endif 1715 #endif
1668 if ( (flag & SDL_HWSURFACE) == SDL_HWSURFACE ) { 1716 if ((flag & SDL_HWSURFACE) == SDL_HWSURFACE) {
1669 ddsd.ddsCaps.dwCaps = 1717 ddsd.ddsCaps.dwCaps = (DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY);
1670 (DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY); 1718 } else {
1671 } else { 1719 ddsd.ddsCaps.dwCaps = (DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY);
1672 ddsd.ddsCaps.dwCaps = 1720 }
1673 (DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY); 1721 ddsd.ddpfPixelFormat.dwSize = sizeof (ddsd.ddpfPixelFormat);
1674 } 1722 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
1675 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat); 1723 if (surface->format->palette) {
1676 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB; 1724 ddsd.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8;
1677 if ( surface->format->palette ) { 1725 }
1678 ddsd.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8;
1679 }
1680 #if defined(NONAMELESSUNION) 1726 #if defined(NONAMELESSUNION)
1681 ddsd.ddpfPixelFormat.u1.dwRGBBitCount = surface->format->BitsPerPixel; 1727 ddsd.ddpfPixelFormat.u1.dwRGBBitCount = surface->format->BitsPerPixel;
1682 ddsd.ddpfPixelFormat.u2.dwRBitMask = surface->format->Rmask; 1728 ddsd.ddpfPixelFormat.u2.dwRBitMask = surface->format->Rmask;
1683 ddsd.ddpfPixelFormat.u3.dwGBitMask = surface->format->Gmask; 1729 ddsd.ddpfPixelFormat.u3.dwGBitMask = surface->format->Gmask;
1684 ddsd.ddpfPixelFormat.u4.dwBBitMask = surface->format->Bmask; 1730 ddsd.ddpfPixelFormat.u4.dwBBitMask = surface->format->Bmask;
1685 #else 1731 #else
1686 ddsd.ddpfPixelFormat.dwRGBBitCount = surface->format->BitsPerPixel; 1732 ddsd.ddpfPixelFormat.dwRGBBitCount = surface->format->BitsPerPixel;
1687 ddsd.ddpfPixelFormat.dwRBitMask = surface->format->Rmask; 1733 ddsd.ddpfPixelFormat.dwRBitMask = surface->format->Rmask;
1688 ddsd.ddpfPixelFormat.dwGBitMask = surface->format->Gmask; 1734 ddsd.ddpfPixelFormat.dwGBitMask = surface->format->Gmask;
1689 ddsd.ddpfPixelFormat.dwBBitMask = surface->format->Bmask; 1735 ddsd.ddpfPixelFormat.dwBBitMask = surface->format->Bmask;
1690 #endif 1736 #endif
1691 1737
1692 /* Create the DirectDraw video surface */ 1738 /* Create the DirectDraw video surface */
1693 if ( requested != NULL ) { 1739 if (requested != NULL) {
1694 dd_surface3 = requested; 1740 dd_surface3 = requested;
1695 } else { 1741 } else {
1696 result = IDirectDraw2_CreateSurface(ddraw2, 1742 result = IDirectDraw2_CreateSurface (ddraw2,
1697 &ddsd, &dd_surface1, NULL); 1743 &ddsd, &dd_surface1, NULL);
1698 if ( result != DD_OK ) { 1744 if (result != DD_OK) {
1699 SetDDerror("DirectDraw2::CreateSurface", result); 1745 SetDDerror ("DirectDraw2::CreateSurface", result);
1700 goto error_end; 1746 goto error_end;
1701 } 1747 }
1702 result = IDirectDrawSurface_QueryInterface(dd_surface1, 1748 result = IDirectDrawSurface_QueryInterface (dd_surface1,
1703 &IID_IDirectDrawSurface3, (LPVOID *)&dd_surface3); 1749 &IID_IDirectDrawSurface3,
1704 IDirectDrawSurface_Release(dd_surface1); 1750 (LPVOID *) & dd_surface3);
1705 if ( result != DD_OK ) { 1751 IDirectDrawSurface_Release (dd_surface1);
1706 SetDDerror("DirectDrawSurface::QueryInterface", result); 1752 if (result != DD_OK) {
1707 goto error_end; 1753 SetDDerror ("DirectDrawSurface::QueryInterface", result);
1708 } 1754 goto error_end;
1709 } 1755 }
1710 1756 }
1711 if ( (flag & SDL_HWSURFACE) == SDL_HWSURFACE ) { 1757
1712 /* Check to see whether the surface actually ended up 1758 if ((flag & SDL_HWSURFACE) == SDL_HWSURFACE) {
1713 in video memory, and fail if not. We expect the 1759 /* Check to see whether the surface actually ended up
1714 surfaces we create here to actually be in hardware! 1760 in video memory, and fail if not. We expect the
1715 */ 1761 surfaces we create here to actually be in hardware!
1716 result = IDirectDrawSurface3_GetCaps(dd_surface3,&ddsd.ddsCaps); 1762 */
1717 if ( result != DD_OK ) { 1763 result = IDirectDrawSurface3_GetCaps (dd_surface3, &ddsd.ddsCaps);
1718 SetDDerror("DirectDrawSurface3::GetCaps", result); 1764 if (result != DD_OK) {
1719 goto error_end; 1765 SetDDerror ("DirectDrawSurface3::GetCaps", result);
1720 } 1766 goto error_end;
1721 if ( (ddsd.ddsCaps.dwCaps&DDSCAPS_VIDEOMEMORY) != 1767 }
1722 DDSCAPS_VIDEOMEMORY ) { 1768 if ((ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) !=
1723 SDL_SetError("No room in video memory"); 1769 DDSCAPS_VIDEOMEMORY) {
1724 goto error_end; 1770 SDL_SetError ("No room in video memory");
1725 } 1771 goto error_end;
1726 } else { 1772 }
1727 /* Try to hook our surface memory */ 1773 } else {
1728 ddsd.dwFlags = DDSD_LPSURFACE; 1774 /* Try to hook our surface memory */
1729 ddsd.lpSurface = surface->pixels; 1775 ddsd.dwFlags = DDSD_LPSURFACE;
1730 result = IDirectDrawSurface3_SetSurfaceDesc(dd_surface3, 1776 ddsd.lpSurface = surface->pixels;
1731 &ddsd, 0); 1777 result = IDirectDrawSurface3_SetSurfaceDesc (dd_surface3, &ddsd, 0);
1732 if ( result != DD_OK ) { 1778 if (result != DD_OK) {
1733 SetDDerror("DirectDraw2::SetSurfaceDesc", result); 1779 SetDDerror ("DirectDraw2::SetSurfaceDesc", result);
1734 goto error_end; 1780 goto error_end;
1735 } 1781 }
1736 1782
1737 } 1783 }
1738 1784
1739 /* Make sure the surface format was set properly */ 1785 /* Make sure the surface format was set properly */
1740 SDL_memset(&ddsd, 0, sizeof(ddsd)); 1786 SDL_memset (&ddsd, 0, sizeof (ddsd));
1741 ddsd.dwSize = sizeof(ddsd); 1787 ddsd.dwSize = sizeof (ddsd);
1742 result = IDirectDrawSurface3_Lock(dd_surface3, NULL, 1788 result = IDirectDrawSurface3_Lock (dd_surface3, NULL,
1743 &ddsd, (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL); 1789 &ddsd,
1744 if ( result != DD_OK ) { 1790 (DDLOCK_NOSYSLOCK | DDLOCK_WAIT),
1745 SetDDerror("DirectDrawSurface3::Lock", result); 1791 NULL);
1746 goto error_end; 1792 if (result != DD_OK) {
1747 } 1793 SetDDerror ("DirectDrawSurface3::Lock", result);
1748 IDirectDrawSurface3_Unlock(dd_surface3, NULL); 1794 goto error_end;
1749 1795 }
1750 if ( (flag & SDL_HWSURFACE) == SDL_SWSURFACE ) { 1796 IDirectDrawSurface3_Unlock (dd_surface3, NULL);
1751 if ( ddsd.lpSurface != surface->pixels ) { 1797
1752 SDL_SetError("DDraw didn't use SDL surface memory"); 1798 if ((flag & SDL_HWSURFACE) == SDL_SWSURFACE) {
1753 goto error_end; 1799 if (ddsd.lpSurface != surface->pixels) {
1754 } 1800 SDL_SetError ("DDraw didn't use SDL surface memory");
1755 if ( 1801 goto error_end;
1802 }
1803 if (
1756 #if defined(NONAMELESSUNION) 1804 #if defined(NONAMELESSUNION)
1757 ddsd.u1.lPitch 1805 ddsd.u1.lPitch
1758 #else 1806 #else
1759 ddsd.lPitch 1807 ddsd.lPitch
1760 #endif 1808 #endif
1761 != (LONG)surface->pitch ) { 1809 != (LONG) surface->pitch) {
1762 SDL_SetError("DDraw created surface with wrong pitch"); 1810 SDL_SetError ("DDraw created surface with wrong pitch");
1763 goto error_end; 1811 goto error_end;
1764 } 1812 }
1765 } else { 1813 } else {
1766 #if defined(NONAMELESSUNION) 1814 #if defined(NONAMELESSUNION)
1767 surface->pitch = (Uint16)ddsd.u1.lPitch; 1815 surface->pitch = (Uint16) ddsd.u1.lPitch;
1768 #else 1816 #else
1769 surface->pitch = (Uint16)ddsd.lPitch; 1817 surface->pitch = (Uint16) ddsd.lPitch;
1770 #endif 1818 #endif
1771 } 1819 }
1772 #if defined(NONAMELESSUNION) 1820 #if defined(NONAMELESSUNION)
1773 if ( (ddsd.ddpfPixelFormat.u1.dwRGBBitCount != 1821 if ((ddsd.ddpfPixelFormat.u1.dwRGBBitCount !=
1774 surface->format->BitsPerPixel) || 1822 surface->format->BitsPerPixel) ||
1775 (ddsd.ddpfPixelFormat.u2.dwRBitMask != surface->format->Rmask) || 1823 (ddsd.ddpfPixelFormat.u2.dwRBitMask != surface->format->Rmask) ||
1776 (ddsd.ddpfPixelFormat.u3.dwGBitMask != surface->format->Gmask) || 1824 (ddsd.ddpfPixelFormat.u3.dwGBitMask != surface->format->Gmask) ||
1777 (ddsd.ddpfPixelFormat.u4.dwBBitMask != surface->format->Bmask) ){ 1825 (ddsd.ddpfPixelFormat.u4.dwBBitMask != surface->format->Bmask)) {
1778 #else 1826 #else
1779 if ( (ddsd.ddpfPixelFormat.dwRGBBitCount != 1827 if ((ddsd.ddpfPixelFormat.dwRGBBitCount !=
1780 surface->format->BitsPerPixel) || 1828 surface->format->BitsPerPixel) ||
1781 (ddsd.ddpfPixelFormat.dwRBitMask != surface->format->Rmask) || 1829 (ddsd.ddpfPixelFormat.dwRBitMask != surface->format->Rmask) ||
1782 (ddsd.ddpfPixelFormat.dwGBitMask != surface->format->Gmask) || 1830 (ddsd.ddpfPixelFormat.dwGBitMask != surface->format->Gmask) ||
1783 (ddsd.ddpfPixelFormat.dwBBitMask != surface->format->Bmask) ){ 1831 (ddsd.ddpfPixelFormat.dwBBitMask != surface->format->Bmask)) {
1784 #endif 1832 #endif
1785 SDL_SetError("DDraw didn't use SDL surface description"); 1833 SDL_SetError ("DDraw didn't use SDL surface description");
1786 goto error_end; 1834 goto error_end;
1787 } 1835 }
1788 if ( (ddsd.dwWidth != (DWORD)surface->w) || 1836 if ((ddsd.dwWidth != (DWORD) surface->w) ||
1789 (ddsd.dwHeight != (DWORD)surface->h) ) { 1837 (ddsd.dwHeight != (DWORD) surface->h)) {
1790 SDL_SetError("DDraw created surface with wrong size"); 1838 SDL_SetError ("DDraw created surface with wrong size");
1791 goto error_end; 1839 goto error_end;
1792 } 1840 }
1793 1841
1794 /* Set the surface private data */ 1842 /* Set the surface private data */
1795 surface->flags |= flag; 1843 surface->flags |= flag;
1796 surface->hwdata->dd_surface = dd_surface3; 1844 surface->hwdata->dd_surface = dd_surface3;
1797 if ( (surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { 1845 if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
1798 LPDIRECTDRAWSURFACE3 dd_writebuf; 1846 LPDIRECTDRAWSURFACE3 dd_writebuf;
1799 1847
1800 ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; 1848 ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
1801 result = IDirectDrawSurface3_GetAttachedSurface(dd_surface3, 1849 result = IDirectDrawSurface3_GetAttachedSurface (dd_surface3,
1802 &ddsd.ddsCaps, &dd_writebuf); 1850 &ddsd.ddsCaps,
1803 if ( result != DD_OK ) { 1851 &dd_writebuf);
1804 SetDDerror("DirectDrawSurface3::GetAttachedSurface", 1852 if (result != DD_OK) {
1805 result); 1853 SetDDerror ("DirectDrawSurface3::GetAttachedSurface", result);
1806 } else { 1854 } else {
1807 dd_surface3 = dd_writebuf; 1855 dd_surface3 = dd_writebuf;
1808 } 1856 }
1809 } 1857 }
1810 surface->hwdata->dd_writebuf = dd_surface3; 1858 surface->hwdata->dd_writebuf = dd_surface3;
1811 1859
1812 /* We're ready to go! */ 1860 /* We're ready to go! */
1813 return(0); 1861 return (0);
1814 1862
1815 /* Okay, so goto's are cheesy, but there are so many possible 1863 /* Okay, so goto's are cheesy, but there are so many possible
1816 errors in this function, and the cleanup is the same in 1864 errors in this function, and the cleanup is the same in
1817 every single case. Is there a better way, other than deeply 1865 every single case. Is there a better way, other than deeply
1818 nesting the code? 1866 nesting the code?
1819 */ 1867 */
1820 error_end: 1868 error_end:
1821 if ( (dd_surface3 != NULL) && (dd_surface3 != requested) ) { 1869 if ((dd_surface3 != NULL) && (dd_surface3 != requested)) {
1822 IDirectDrawSurface_Release(dd_surface3); 1870 IDirectDrawSurface_Release (dd_surface3);
1823 } 1871 }
1824 SDL_free(surface->hwdata); 1872 SDL_free (surface->hwdata);
1825 surface->hwdata = NULL; 1873 surface->hwdata = NULL;
1826 return(-1); 1874 return (-1);
1827 } 1875 }
1828 1876
1829 static int DX5_AllocHWSurface(_THIS, SDL_Surface *surface) 1877 static int
1830 { 1878 DX5_AllocHWSurface (_THIS, SDL_Surface * surface)
1831 /* DDraw limitation -- you need to set cooperative level first */ 1879 {
1832 if ( SDL_primary == NULL ) { 1880 /* DDraw limitation -- you need to set cooperative level first */
1833 SDL_SetError("You must set a non-GL video mode first"); 1881 if (SDL_primary == NULL) {
1834 return(-1); 1882 SDL_SetError ("You must set a non-GL video mode first");
1835 } 1883 return (-1);
1836 return(DX5_AllocDDSurface(this, surface, NULL, SDL_HWSURFACE)); 1884 }
1885 return (DX5_AllocDDSurface (this, surface, NULL, SDL_HWSURFACE));
1837 } 1886 }
1838 1887
1839 #ifdef DDRAW_DEBUG 1888 #ifdef DDRAW_DEBUG
1840 void PrintSurface(char *title, LPDIRECTDRAWSURFACE3 surface, Uint32 flags) 1889 void
1841 { 1890 PrintSurface (char *title, LPDIRECTDRAWSURFACE3 surface, Uint32 flags)
1842 DDSURFACEDESC ddsd; 1891 {
1843 1892 DDSURFACEDESC ddsd;
1844 /* Lock and load! */ 1893
1845 SDL_memset(&ddsd, 0, sizeof(ddsd)); 1894 /* Lock and load! */
1846 ddsd.dwSize = sizeof(ddsd); 1895 SDL_memset (&ddsd, 0, sizeof (ddsd));
1847 if ( IDirectDrawSurface3_Lock(surface, NULL, &ddsd, 1896 ddsd.dwSize = sizeof (ddsd);
1848 (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL) != DD_OK ) { 1897 if (IDirectDrawSurface3_Lock (surface, NULL, &ddsd,
1849 return; 1898 (DDLOCK_NOSYSLOCK | DDLOCK_WAIT),
1850 } 1899 NULL) != DD_OK) {
1851 IDirectDrawSurface3_Unlock(surface, NULL); 1900 return;
1852 1901 }
1853 fprintf(stderr, "%s:\n", title); 1902 IDirectDrawSurface3_Unlock (surface, NULL);
1854 fprintf(stderr, "\tSize: %dx%d in %s at %ld bpp (pitch = %ld)\n", 1903
1855 ddsd.dwWidth, ddsd.dwHeight, 1904 fprintf (stderr, "%s:\n", title);
1856 (flags & SDL_HWSURFACE) ? "hardware" : "software", 1905 fprintf (stderr, "\tSize: %dx%d in %s at %ld bpp (pitch = %ld)\n",
1906 ddsd.dwWidth, ddsd.dwHeight,
1907 (flags & SDL_HWSURFACE) ? "hardware" : "software",
1857 #if defined(NONAMELESSUNION) 1908 #if defined(NONAMELESSUNION)
1858 ddsd.ddpfPixelFormat.u1.dwRGBBitCount, ddsd.u1.lPitch); 1909 ddsd.ddpfPixelFormat.u1.dwRGBBitCount, ddsd.u1.lPitch);
1859 #else 1910 #else
1860 ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.lPitch); 1911 ddsd.ddpfPixelFormat.dwRGBBitCount, ddsd.lPitch);
1861 #endif 1912 #endif
1862 fprintf(stderr, "\tR = 0x%X, G = 0x%X, B = 0x%X\n", 1913 fprintf (stderr, "\tR = 0x%X, G = 0x%X, B = 0x%X\n",
1863 #if defined(NONAMELESSUNION) 1914 #if defined(NONAMELESSUNION)
1864 ddsd.ddpfPixelFormat.u2.dwRBitMask, 1915 ddsd.ddpfPixelFormat.u2.dwRBitMask,
1865 ddsd.ddpfPixelFormat.u3.dwGBitMask, 1916 ddsd.ddpfPixelFormat.u3.dwGBitMask,
1866 ddsd.ddpfPixelFormat.u4.dwBBitMask); 1917 ddsd.ddpfPixelFormat.u4.dwBBitMask);
1867 #else 1918 #else
1868 ddsd.ddpfPixelFormat.dwRBitMask, 1919 ddsd.ddpfPixelFormat.dwRBitMask,
1869 ddsd.ddpfPixelFormat.dwGBitMask, 1920 ddsd.ddpfPixelFormat.dwGBitMask,
1870 ddsd.ddpfPixelFormat.dwBBitMask); 1921 ddsd.ddpfPixelFormat.dwBBitMask);
1871 #endif 1922 #endif
1872 } 1923 }
1873 #endif /* DDRAW_DEBUG */ 1924 #endif /* DDRAW_DEBUG */
1874 1925
1875 static int DX5_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, 1926 static int
1876 SDL_Surface *dst, SDL_Rect *dstrect) 1927 DX5_HWAccelBlit (SDL_Surface * src, SDL_Rect * srcrect,
1877 { 1928 SDL_Surface * dst, SDL_Rect * dstrect)
1878 LPDIRECTDRAWSURFACE3 src_surface; 1929 {
1879 LPDIRECTDRAWSURFACE3 dst_surface; 1930 LPDIRECTDRAWSURFACE3 src_surface;
1880 DWORD flags; 1931 LPDIRECTDRAWSURFACE3 dst_surface;
1881 RECT rect; 1932 DWORD flags;
1882 HRESULT result; 1933 RECT rect;
1883 1934 HRESULT result;
1884 /* Set it up.. the desination must have a DDRAW surface */ 1935
1885 src_surface = src->hwdata->dd_writebuf; 1936 /* Set it up.. the desination must have a DDRAW surface */
1886 dst_surface = dst->hwdata->dd_writebuf; 1937 src_surface = src->hwdata->dd_writebuf;
1887 rect.top = (LONG)srcrect->y; 1938 dst_surface = dst->hwdata->dd_writebuf;
1888 rect.bottom = (LONG)srcrect->y+srcrect->h; 1939 rect.top = (LONG) srcrect->y;
1889 rect.left = (LONG)srcrect->x; 1940 rect.bottom = (LONG) srcrect->y + srcrect->h;
1890 rect.right = (LONG)srcrect->x+srcrect->w; 1941 rect.left = (LONG) srcrect->x;
1891 if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) 1942 rect.right = (LONG) srcrect->x + srcrect->w;
1892 flags = DDBLTFAST_SRCCOLORKEY; 1943 if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)
1893 else 1944 flags = DDBLTFAST_SRCCOLORKEY;
1894 flags = DDBLTFAST_NOCOLORKEY; 1945 else
1895 /* FIXME: We can remove this flag for _really_ fast blit queuing, 1946 flags = DDBLTFAST_NOCOLORKEY;
1896 but it will affect the return values of locks and flips. 1947 /* FIXME: We can remove this flag for _really_ fast blit queuing,
1897 */ 1948 but it will affect the return values of locks and flips.
1898 flags |= DDBLTFAST_WAIT; 1949 */
1899 1950 flags |= DDBLTFAST_WAIT;
1900 /* Do the blit! */ 1951
1901 result = IDirectDrawSurface3_BltFast(dst_surface, 1952 /* Do the blit! */
1902 dstrect->x, dstrect->y, src_surface, &rect, flags); 1953 result = IDirectDrawSurface3_BltFast (dst_surface,
1903 if ( result != DD_OK ) { 1954 dstrect->x, dstrect->y, src_surface,
1904 if ( result == DDERR_SURFACELOST ) { 1955 &rect, flags);
1905 result = IDirectDrawSurface3_Restore(src_surface); 1956 if (result != DD_OK) {
1906 result = IDirectDrawSurface3_Restore(dst_surface); 1957 if (result == DDERR_SURFACELOST) {
1907 /* The surfaces need to be reloaded with artwork */ 1958 result = IDirectDrawSurface3_Restore (src_surface);
1908 SDL_SetError("Blit surfaces were lost, reload them"); 1959 result = IDirectDrawSurface3_Restore (dst_surface);
1909 return(-2); 1960 /* The surfaces need to be reloaded with artwork */
1910 } 1961 SDL_SetError ("Blit surfaces were lost, reload them");
1911 SetDDerror("IDirectDrawSurface3::BltFast", result); 1962 return (-2);
1963 }
1964 SetDDerror ("IDirectDrawSurface3::BltFast", result);
1912 #ifdef DDRAW_DEBUG 1965 #ifdef DDRAW_DEBUG
1913 fprintf(stderr, "Original dest rect: %dx%d at %d,%d\n", dstrect->w, dstrect->h, dstrect->x, dstrect->y); 1966 fprintf (stderr, "Original dest rect: %dx%d at %d,%d\n", dstrect->w,
1914 fprintf(stderr, "HW accelerated %sblit to from 0x%p to 0x%p at (%d,%d)\n", 1967 dstrect->h, dstrect->x, dstrect->y);
1915 (src->flags & SDL_SRCCOLORKEY) ? "colorkey " : "", src, dst, 1968 fprintf (stderr,
1916 dstrect->x, dstrect->y); 1969 "HW accelerated %sblit to from 0x%p to 0x%p at (%d,%d)\n",
1917 PrintSurface("SRC", src_surface, src->flags); 1970 (src->flags & SDL_SRCCOLORKEY) ? "colorkey " : "", src,
1918 PrintSurface("DST", dst_surface, dst->flags); 1971 dst, dstrect->x, dstrect->y);
1919 fprintf(stderr, "Source rectangle: (%d,%d) - (%d,%d)\n", 1972 PrintSurface ("SRC", src_surface, src->flags);
1920 rect.left, rect.top, rect.right, rect.bottom); 1973 PrintSurface ("DST", dst_surface, dst->flags);
1921 #endif 1974 fprintf (stderr, "Source rectangle: (%d,%d) - (%d,%d)\n",
1922 /* Unexpected error, fall back to software blit */ 1975 rect.left, rect.top, rect.right, rect.bottom);
1923 return(src->map->sw_blit(src, srcrect, dst, dstrect)); 1976 #endif
1924 } 1977 /* Unexpected error, fall back to software blit */
1925 return(0); 1978 return (src->map->sw_blit (src, srcrect, dst, dstrect));
1926 } 1979 }
1927 1980 return (0);
1928 static int DX5_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst) 1981 }
1929 { 1982
1930 int accelerated; 1983 static int
1931 1984 DX5_CheckHWBlit (_THIS, SDL_Surface * src, SDL_Surface * dst)
1932 /* We need to have a DDraw surface for HW blits */ 1985 {
1933 if ( (src->flags & SDL_HWSURFACE) == SDL_SWSURFACE ) { 1986 int accelerated;
1934 /* Allocate a DDraw surface for the blit */ 1987
1935 if ( src->hwdata == NULL ) { 1988 /* We need to have a DDraw surface for HW blits */
1936 DX5_AllocDDSurface(this, src, NULL, SDL_SWSURFACE); 1989 if ((src->flags & SDL_HWSURFACE) == SDL_SWSURFACE) {
1937 } 1990 /* Allocate a DDraw surface for the blit */
1938 } 1991 if (src->hwdata == NULL) {
1939 if ( src->hwdata == NULL ) { 1992 DX5_AllocDDSurface (this, src, NULL, SDL_SWSURFACE);
1940 return(0); 1993 }
1941 } 1994 }
1942 1995 if (src->hwdata == NULL) {
1943 /* Set initial acceleration on */ 1996 return (0);
1944 src->flags |= SDL_HWACCEL; 1997 }
1945 1998
1946 /* Set the surface attributes */ 1999 /* Set initial acceleration on */
1947 if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { 2000 src->flags |= SDL_HWACCEL;
1948 if ( DX5_SetHWColorKey(this, src, src->format->colorkey) < 0 ) { 2001
1949 src->flags &= ~SDL_HWACCEL; 2002 /* Set the surface attributes */
1950 } 2003 if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
1951 } 2004 if (DX5_SetHWColorKey (this, src, src->format->colorkey) < 0) {
1952 if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { 2005 src->flags &= ~SDL_HWACCEL;
1953 if ( DX5_SetHWAlpha(this, src, src->format->alpha) < 0 ) { 2006 }
1954 src->flags &= ~SDL_HWACCEL; 2007 }
1955 } 2008 if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
1956 } 2009 if (DX5_SetHWAlpha (this, src, src->format->alpha) < 0) {
1957 2010 src->flags &= ~SDL_HWACCEL;
1958 /* Check to see if final surface blit is accelerated */ 2011 }
1959 accelerated = !!(src->flags & SDL_HWACCEL); 2012 }
1960 if ( accelerated ) { 2013
2014 /* Check to see if final surface blit is accelerated */
2015 accelerated = !!(src->flags & SDL_HWACCEL);
2016 if (accelerated) {
1961 #ifdef DDRAW_DEBUG 2017 #ifdef DDRAW_DEBUG
1962 fprintf(stderr, "Setting accelerated blit on 0x%p\n", src); 2018 fprintf (stderr, "Setting accelerated blit on 0x%p\n", src);
1963 #endif 2019 #endif
1964 src->map->hw_blit = DX5_HWAccelBlit; 2020 src->map->hw_blit = DX5_HWAccelBlit;
1965 } 2021 }
1966 return(accelerated); 2022 return (accelerated);
1967 } 2023 }
1968 2024
1969 static int DX5_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color) 2025 static int
1970 { 2026 DX5_FillHWRect (_THIS, SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
1971 LPDIRECTDRAWSURFACE3 dst_surface; 2027 {
1972 RECT area; 2028 LPDIRECTDRAWSURFACE3 dst_surface;
1973 DDBLTFX bltfx; 2029 RECT area;
1974 HRESULT result; 2030 DDBLTFX bltfx;
2031 HRESULT result;
1975 2032
1976 #ifdef DDRAW_DEBUG 2033 #ifdef DDRAW_DEBUG
1977 fprintf(stderr, "HW accelerated fill at (%d,%d)\n", dstrect->x, dstrect->y); 2034 fprintf (stderr, "HW accelerated fill at (%d,%d)\n", dstrect->x,
1978 #endif 2035 dstrect->y);
1979 dst_surface = dst->hwdata->dd_writebuf; 2036 #endif
1980 area.top = (LONG)dstrect->y; 2037 dst_surface = dst->hwdata->dd_writebuf;
1981 area.bottom = (LONG)dstrect->y+dstrect->h; 2038 area.top = (LONG) dstrect->y;
1982 area.left = (LONG)dstrect->x; 2039 area.bottom = (LONG) dstrect->y + dstrect->h;
1983 area.right = (LONG)dstrect->x+dstrect->w; 2040 area.left = (LONG) dstrect->x;
1984 bltfx.dwSize = sizeof(bltfx); 2041 area.right = (LONG) dstrect->x + dstrect->w;
2042 bltfx.dwSize = sizeof (bltfx);
1985 #if defined(NONAMELESSUNION) 2043 #if defined(NONAMELESSUNION)
1986 bltfx.u5.dwFillColor = color; 2044 bltfx.u5.dwFillColor = color;
1987 #else 2045 #else
1988 bltfx.dwFillColor = color; 2046 bltfx.dwFillColor = color;
1989 #endif 2047 #endif
1990 result = IDirectDrawSurface3_Blt(dst_surface, 2048 result = IDirectDrawSurface3_Blt (dst_surface,
1991 &area, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &bltfx); 2049 &area, NULL, NULL,
1992 if ( result == DDERR_SURFACELOST ) { 2050 DDBLT_COLORFILL | DDBLT_WAIT, &bltfx);
1993 IDirectDrawSurface3_Restore(dst_surface); 2051 if (result == DDERR_SURFACELOST) {
1994 result = IDirectDrawSurface3_Blt(dst_surface, 2052 IDirectDrawSurface3_Restore (dst_surface);
1995 &area, NULL, NULL, DDBLT_COLORFILL|DDBLT_WAIT, &bltfx); 2053 result = IDirectDrawSurface3_Blt (dst_surface,
1996 } 2054 &area, NULL, NULL,
1997 if ( result != DD_OK ) { 2055 DDBLT_COLORFILL | DDBLT_WAIT,
1998 SetDDerror("IDirectDrawSurface3::Blt", result); 2056 &bltfx);
1999 return(-1); 2057 }
2000 } 2058 if (result != DD_OK) {
2001 return(0); 2059 SetDDerror ("IDirectDrawSurface3::Blt", result);
2002 } 2060 return (-1);
2003 2061 }
2004 static int DX5_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) 2062 return (0);
2005 { 2063 }
2006 DDCOLORKEY colorkey; 2064
2007 HRESULT result; 2065 static int
2008 2066 DX5_SetHWColorKey (_THIS, SDL_Surface * surface, Uint32 key)
2009 /* Set the surface colorkey */ 2067 {
2010 colorkey.dwColorSpaceLowValue = key; 2068 DDCOLORKEY colorkey;
2011 colorkey.dwColorSpaceHighValue = key; 2069 HRESULT result;
2012 result = IDirectDrawSurface3_SetColorKey( 2070
2013 surface->hwdata->dd_surface, DDCKEY_SRCBLT, &colorkey); 2071 /* Set the surface colorkey */
2014 if ( result != DD_OK ) { 2072 colorkey.dwColorSpaceLowValue = key;
2015 SetDDerror("IDirectDrawSurface3::SetColorKey", result); 2073 colorkey.dwColorSpaceHighValue = key;
2016 return(-1); 2074 result =
2017 } 2075 IDirectDrawSurface3_SetColorKey (surface->hwdata->dd_surface,
2018 return(0); 2076 DDCKEY_SRCBLT, &colorkey);
2019 } 2077 if (result != DD_OK) {
2020 static int DX5_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha) 2078 SetDDerror ("IDirectDrawSurface3::SetColorKey", result);
2021 { 2079 return (-1);
2022 return(-1); 2080 }
2023 } 2081 return (0);
2024 2082 }
2025 static int DX5_LockHWSurface(_THIS, SDL_Surface *surface) 2083 static int
2026 { 2084 DX5_SetHWAlpha (_THIS, SDL_Surface * surface, Uint8 alpha)
2027 HRESULT result; 2085 {
2028 LPDIRECTDRAWSURFACE3 dd_surface; 2086 return (-1);
2029 DDSURFACEDESC ddsd; 2087 }
2030 2088
2031 /* Lock and load! */ 2089 static int
2032 dd_surface = surface->hwdata->dd_writebuf; 2090 DX5_LockHWSurface (_THIS, SDL_Surface * surface)
2033 SDL_memset(&ddsd, 0, sizeof(ddsd)); 2091 {
2034 ddsd.dwSize = sizeof(ddsd); 2092 HRESULT result;
2035 result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd, 2093 LPDIRECTDRAWSURFACE3 dd_surface;
2036 (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL); 2094 DDSURFACEDESC ddsd;
2037 if ( result == DDERR_SURFACELOST ) { 2095
2038 result = IDirectDrawSurface3_Restore( 2096 /* Lock and load! */
2039 surface->hwdata->dd_surface); 2097 dd_surface = surface->hwdata->dd_writebuf;
2040 result = IDirectDrawSurface3_Lock(dd_surface, NULL, &ddsd, 2098 SDL_memset (&ddsd, 0, sizeof (ddsd));
2041 (DDLOCK_NOSYSLOCK|DDLOCK_WAIT), NULL); 2099 ddsd.dwSize = sizeof (ddsd);
2042 } 2100 result = IDirectDrawSurface3_Lock (dd_surface, NULL, &ddsd,
2043 if ( result != DD_OK ) { 2101 (DDLOCK_NOSYSLOCK | DDLOCK_WAIT),
2044 SetDDerror("DirectDrawSurface3::Lock", result); 2102 NULL);
2045 return(-1); 2103 if (result == DDERR_SURFACELOST) {
2046 } 2104 result = IDirectDrawSurface3_Restore (surface->hwdata->dd_surface);
2047 /* Pitch might have changed -- recalculate pitch and offset */ 2105 result = IDirectDrawSurface3_Lock (dd_surface, NULL, &ddsd,
2106 (DDLOCK_NOSYSLOCK | DDLOCK_WAIT),
2107 NULL);
2108 }
2109 if (result != DD_OK) {
2110 SetDDerror ("DirectDrawSurface3::Lock", result);
2111 return (-1);
2112 }
2113 /* Pitch might have changed -- recalculate pitch and offset */
2048 #if defined(NONAMELESSUNION) 2114 #if defined(NONAMELESSUNION)
2049 if ( surface->pitch != ddsd.u1.lPitch ) { 2115 if (surface->pitch != ddsd.u1.lPitch) {
2050 surface->pitch = ddsd.u1.lPitch; 2116 surface->pitch = ddsd.u1.lPitch;
2051 #else 2117 #else
2052 if ( surface->pitch != ddsd.lPitch ) { 2118 if (surface->pitch != ddsd.lPitch) {
2053 surface->pitch = (Uint16)ddsd.lPitch; 2119 surface->pitch = (Uint16) ddsd.lPitch;
2054 #endif 2120 #endif
2055 surface->offset = 2121 surface->offset =
2056 ((ddsd.dwHeight-surface->h)/2)*surface->pitch + 2122 ((ddsd.dwHeight - surface->h) / 2) * surface->pitch +
2057 ((ddsd.dwWidth-surface->w)/2)* 2123 ((ddsd.dwWidth - surface->w) / 2) *
2058 surface->format->BytesPerPixel; 2124 surface->format->BytesPerPixel;
2059 } 2125 }
2060 surface->pixels = ddsd.lpSurface; 2126 surface->pixels = ddsd.lpSurface;
2061 return(0); 2127 return (0);
2062 } 2128 }
2063 2129
2064 static void DX5_UnlockHWSurface(_THIS, SDL_Surface *surface) 2130 static void
2065 { 2131 DX5_UnlockHWSurface (_THIS, SDL_Surface * surface)
2066 IDirectDrawSurface3_Unlock(surface->hwdata->dd_writebuf, NULL); 2132 {
2067 surface->pixels = NULL; 2133 IDirectDrawSurface3_Unlock (surface->hwdata->dd_writebuf, NULL);
2068 } 2134 surface->pixels = NULL;
2069 2135 }
2070 static int DX5_FlipHWSurface(_THIS, SDL_Surface *surface) 2136
2071 { 2137 static int
2072 HRESULT result; 2138 DX5_FlipHWSurface (_THIS, SDL_Surface * surface)
2073 LPDIRECTDRAWSURFACE3 dd_surface; 2139 {
2074 2140 HRESULT result;
2075 dd_surface = surface->hwdata->dd_surface; 2141 LPDIRECTDRAWSURFACE3 dd_surface;
2076 2142
2077 /* to prevent big slowdown on fast computers, wait here instead of driver ring 0 code */ 2143 dd_surface = surface->hwdata->dd_surface;
2078 /* Dmitry Yakimov (ftech@tula.net) */ 2144
2079 while(IDirectDrawSurface3_GetFlipStatus(dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING); 2145 /* to prevent big slowdown on fast computers, wait here instead of driver ring 0 code */
2080 2146 /* Dmitry Yakimov (ftech@tula.net) */
2081 result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT); 2147 while (IDirectDrawSurface3_GetFlipStatus (dd_surface, DDGBS_ISBLTDONE) ==
2082 if ( result == DDERR_SURFACELOST ) { 2148 DDERR_WASSTILLDRAWING);
2083 result = IDirectDrawSurface3_Restore( 2149
2084 surface->hwdata->dd_surface); 2150 result = IDirectDrawSurface3_Flip (dd_surface, NULL, DDFLIP_WAIT);
2085 while(IDirectDrawSurface3_GetFlipStatus(dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING); 2151 if (result == DDERR_SURFACELOST) {
2086 result = IDirectDrawSurface3_Flip(dd_surface, NULL, DDFLIP_WAIT); 2152 result = IDirectDrawSurface3_Restore (surface->hwdata->dd_surface);
2087 } 2153 while (IDirectDrawSurface3_GetFlipStatus
2088 if ( result != DD_OK ) { 2154 (dd_surface, DDGBS_ISBLTDONE) == DDERR_WASSTILLDRAWING);
2089 SetDDerror("DirectDrawSurface3::Flip", result); 2155 result = IDirectDrawSurface3_Flip (dd_surface, NULL, DDFLIP_WAIT);
2090 return(-1); 2156 }
2091 } 2157 if (result != DD_OK) {
2092 return(0); 2158 SetDDerror ("DirectDrawSurface3::Flip", result);
2093 } 2159 return (-1);
2094 2160 }
2095 static void DX5_FreeHWSurface(_THIS, SDL_Surface *surface) 2161 return (0);
2096 { 2162 }
2097 if ( surface->hwdata ) { 2163
2098 if ( surface->hwdata->dd_surface != SDL_primary ) { 2164 static void
2099 IDirectDrawSurface3_Release(surface->hwdata->dd_surface); 2165 DX5_FreeHWSurface (_THIS, SDL_Surface * surface)
2100 } 2166 {
2101 SDL_free(surface->hwdata); 2167 if (surface->hwdata) {
2102 surface->hwdata = NULL; 2168 if (surface->hwdata->dd_surface != SDL_primary) {
2103 } 2169 IDirectDrawSurface3_Release (surface->hwdata->dd_surface);
2104 } 2170 }
2105 2171 SDL_free (surface->hwdata);
2106 void DX5_WindowUpdate(_THIS, int numrects, SDL_Rect *rects) 2172 surface->hwdata = NULL;
2107 { 2173 }
2108 HRESULT result; 2174 }
2109 int i; 2175
2110 RECT src, dst; 2176 void
2111 2177 DX5_WindowUpdate (_THIS, int numrects, SDL_Rect * rects)
2112 for ( i=0; i<numrects; ++i ) { 2178 {
2113 src.top = (LONG)rects[i].y; 2179 HRESULT result;
2114 src.bottom = (LONG)rects[i].y+rects[i].h; 2180 int i;
2115 src.left = (LONG)rects[i].x; 2181 RECT src, dst;
2116 src.right = (LONG)rects[i].x+rects[i].w; 2182
2117 dst.top = SDL_bounds.top+src.top; 2183 for (i = 0; i < numrects; ++i) {
2118 dst.left = SDL_bounds.left+src.left; 2184 src.top = (LONG) rects[i].y;
2119 dst.bottom = SDL_bounds.top+src.bottom; 2185 src.bottom = (LONG) rects[i].y + rects[i].h;
2120 dst.right = SDL_bounds.left+src.right; 2186 src.left = (LONG) rects[i].x;
2121 result = IDirectDrawSurface3_Blt(SDL_primary, &dst, 2187 src.right = (LONG) rects[i].x + rects[i].w;
2122 this->screen->hwdata->dd_surface, &src, 2188 dst.top = SDL_bounds.top + src.top;
2123 DDBLT_WAIT, NULL); 2189 dst.left = SDL_bounds.left + src.left;
2124 /* Doh! Check for lost surface and restore it */ 2190 dst.bottom = SDL_bounds.top + src.bottom;
2125 if ( result == DDERR_SURFACELOST ) { 2191 dst.right = SDL_bounds.left + src.right;
2126 IDirectDrawSurface3_Restore(SDL_primary); 2192 result = IDirectDrawSurface3_Blt (SDL_primary, &dst,
2127 IDirectDrawSurface3_Blt(SDL_primary, &dst, 2193 this->screen->hwdata->dd_surface,
2128 this->screen->hwdata->dd_surface, &src, 2194 &src, DDBLT_WAIT, NULL);
2129 DDBLT_WAIT, NULL); 2195 /* Doh! Check for lost surface and restore it */
2130 } 2196 if (result == DDERR_SURFACELOST) {
2131 } 2197 IDirectDrawSurface3_Restore (SDL_primary);
2132 } 2198 IDirectDrawSurface3_Blt (SDL_primary, &dst,
2133 2199 this->screen->hwdata->dd_surface,
2134 void DX5_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) 2200 &src, DDBLT_WAIT, NULL);
2201 }
2202 }
2203 }
2204
2205 void
2206 DX5_DirectUpdate (_THIS, int numrects, SDL_Rect * rects)
2135 { 2207 {
2136 } 2208 }
2137 2209
2138 /* Compress a full palette into the limited number of colors given to us 2210 /* Compress a full palette into the limited number of colors given to us
2139 by windows. 2211 by windows.
2159 int r = (A.r - B.r); \ 2231 int r = (A.r - B.r); \
2160 int g = (A.g - B.g); \ 2232 int g = (A.g - B.g); \
2161 int b = (A.b - B.b); \ 2233 int b = (A.b - B.b); \
2162 (r*r + g*g + b*b); \ 2234 (r*r + g*g + b*b); \
2163 }) 2235 })
2164 static void DX5_CompressPalette(_THIS, SDL_Color *colors, int ncolors, int maxcolors) 2236 static void
2237 DX5_CompressPalette (_THIS, SDL_Color * colors, int ncolors, int maxcolors)
2165 { 2238 {
2166 #ifdef SIMPLE_COMPRESSION 2239 #ifdef SIMPLE_COMPRESSION
2167 int i, j; 2240 int i, j;
2168 #else 2241 #else
2169 static SDL_Color zero = { 0, 0, 0, 0 }; 2242 static SDL_Color zero = { 0, 0, 0, 0 };
2170 int i, j; 2243 int i, j;
2171 int max, dist; 2244 int max, dist;
2172 int prev, next; 2245 int prev, next;
2173 int *pool; 2246 int *pool;
2174 int *seen, *order; 2247 int *seen, *order;
2175 #endif 2248 #endif
2176 2249
2177 /* Does this happen? */ 2250 /* Does this happen? */
2178 if ( maxcolors > ncolors ) { 2251 if (maxcolors > ncolors) {
2179 maxcolors = ncolors; 2252 maxcolors = ncolors;
2180 } 2253 }
2181
2182 #ifdef SIMPLE_COMPRESSION 2254 #ifdef SIMPLE_COMPRESSION
2183 /* Just copy the first "maxcolors" colors */ 2255 /* Just copy the first "maxcolors" colors */
2184 for ( j=10, i=0; i<maxcolors; ++i, ++j ) { 2256 for (j = 10, i = 0; i < maxcolors; ++i, ++j) {
2185 SDL_colors[j].peRed = colors[i].r; 2257 SDL_colors[j].peRed = colors[i].r;
2186 SDL_colors[j].peGreen = colors[i].g; 2258 SDL_colors[j].peGreen = colors[i].g;
2187 SDL_colors[j].peBlue = colors[i].b; 2259 SDL_colors[j].peBlue = colors[i].b;
2188 } 2260 }
2189 #else 2261 #else
2190 /* Allocate memory for the arrays we use */ 2262 /* Allocate memory for the arrays we use */
2191 pool = SDL_stack_alloc(int, 2*ncolors); 2263 pool = SDL_stack_alloc (int, 2 * ncolors);
2192 if ( pool == NULL ) { 2264 if (pool == NULL) {
2193 /* No worries, just return */; 2265 /* No worries, just return */ ;
2194 return; 2266 return;
2195 } 2267 }
2196 seen = pool; 2268 seen = pool;
2197 SDL_memset(seen, 0, ncolors*sizeof(int)); 2269 SDL_memset (seen, 0, ncolors * sizeof (int));
2198 order = pool+ncolors; 2270 order = pool + ncolors;
2199 2271
2200 /* Start with the brightest color */ 2272 /* Start with the brightest color */
2201 max = 0; 2273 max = 0;
2202 for ( i=0; i<ncolors; ++i ) { 2274 for (i = 0; i < ncolors; ++i) {
2203 dist = CS_CS_DIST(zero, colors[i]); 2275 dist = CS_CS_DIST (zero, colors[i]);
2204 if ( dist >= max ) { 2276 if (dist >= max) {
2205 max = dist; 2277 max = dist;
2206 next = i; 2278 next = i;
2207 } 2279 }
2208 } 2280 }
2209 j = 0; 2281 j = 0;
2210 order[j++] = next; 2282 order[j++] = next;
2211 seen[next] = 1; 2283 seen[next] = 1;
2212 prev = next; 2284 prev = next;
2213 2285
2214 /* Keep going through all the colors */ 2286 /* Keep going through all the colors */
2215 while ( j < maxcolors ) { 2287 while (j < maxcolors) {
2216 max = 0; 2288 max = 0;
2217 for ( i=0; i<ncolors; ++i ) { 2289 for (i = 0; i < ncolors; ++i) {
2218 if ( seen[i] ) { 2290 if (seen[i]) {
2219 continue; 2291 continue;
2220 } 2292 }
2221 dist = CS_CS_DIST(colors[i], colors[prev]); 2293 dist = CS_CS_DIST (colors[i], colors[prev]);
2222 if ( dist >= max ) { 2294 if (dist >= max) {
2223 max = dist; 2295 max = dist;
2224 next = i; 2296 next = i;
2225 } 2297 }
2226 } 2298 }
2227 order[j++] = next; 2299 order[j++] = next;
2228 seen[next] = 1; 2300 seen[next] = 1;
2229 prev = next; 2301 prev = next;
2230 } 2302 }
2231 2303
2232 /* Compress the colors to the palette */ 2304 /* Compress the colors to the palette */
2233 for ( j=10, i=0; i<maxcolors; ++i, ++j ) { 2305 for (j = 10, i = 0; i < maxcolors; ++i, ++j) {
2234 SDL_colors[j].peRed = colors[order[i]].r; 2306 SDL_colors[j].peRed = colors[order[i]].r;
2235 SDL_colors[j].peGreen = colors[order[i]].g; 2307 SDL_colors[j].peGreen = colors[order[i]].g;
2236 SDL_colors[j].peBlue = colors[order[i]].b; 2308 SDL_colors[j].peBlue = colors[order[i]].b;
2237 } 2309 }
2238 SDL_stack_free(pool); 2310 SDL_stack_free (pool);
2239 #endif /* SIMPLE_COMPRESSION */ 2311 #endif /* SIMPLE_COMPRESSION */
2240 } 2312 }
2241 2313
2242 /* Set the system colormap in both fullscreen and windowed modes */ 2314 /* Set the system colormap in both fullscreen and windowed modes */
2243 int DX5_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) 2315 int
2244 { 2316 DX5_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
2245 int i; 2317 {
2246 int alloct_all; 2318 int i;
2247 2319 int alloct_all;
2248 /* Copy palette colors into display palette */ 2320
2249 alloct_all = 0; 2321 /* Copy palette colors into display palette */
2250 if ( SDL_palette != NULL ) { 2322 alloct_all = 0;
2251 if ( (this->screen->flags&SDL_FULLSCREEN) == SDL_FULLSCREEN ) { 2323 if (SDL_palette != NULL) {
2252 /* We can set all entries explicitly */ 2324 if ((this->screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
2253 for ( i=0; i< ncolors; ++i ) { 2325 /* We can set all entries explicitly */
2254 int j = firstcolor + i; 2326 for (i = 0; i < ncolors; ++i) {
2255 SDL_colors[j].peRed = colors[i].r; 2327 int j = firstcolor + i;
2256 SDL_colors[j].peGreen = colors[i].g; 2328 SDL_colors[j].peRed = colors[i].r;
2257 SDL_colors[j].peBlue = colors[i].b; 2329 SDL_colors[j].peGreen = colors[i].g;
2258 } 2330 SDL_colors[j].peBlue = colors[i].b;
2259 IDirectDrawPalette_SetEntries(SDL_palette, 0, 2331 }
2260 firstcolor, ncolors, &SDL_colors[firstcolor]); 2332 IDirectDrawPalette_SetEntries (SDL_palette, 0,
2261 alloct_all = 1; 2333 firstcolor, ncolors,
2262 } else { 2334 &SDL_colors[firstcolor]);
2263 /* Grab the 236 most diverse colors in the palette */ 2335 alloct_all = 1;
2264 DX5_CompressPalette(this, colors, ncolors, 236); 2336 } else {
2265 /* This sends an WM_PALETTECHANGED message to us */ 2337 /* Grab the 236 most diverse colors in the palette */
2266 colorchange_expected = 1; 2338 DX5_CompressPalette (this, colors, ncolors, 236);
2267 IDirectDrawPalette_SetEntries(SDL_palette, 0, 2339 /* This sends an WM_PALETTECHANGED message to us */
2268 0, 256, SDL_colors); 2340 colorchange_expected = 1;
2269 } 2341 IDirectDrawPalette_SetEntries (SDL_palette, 0,
2270 } 2342 0, 256, SDL_colors);
2271 return(alloct_all); 2343 }
2344 }
2345 return (alloct_all);
2272 } 2346 }
2273 2347
2274 /* Gamma code is only available on DirectX 7 and newer */ 2348 /* Gamma code is only available on DirectX 7 and newer */
2275 static int DX5_SetGammaRamp(_THIS, Uint16 *ramp) 2349 static int
2350 DX5_SetGammaRamp (_THIS, Uint16 * ramp)
2276 { 2351 {
2277 #ifdef IDirectDrawGammaControl_SetGammaRamp 2352 #ifdef IDirectDrawGammaControl_SetGammaRamp
2278 LPDIRECTDRAWGAMMACONTROL gamma; 2353 LPDIRECTDRAWGAMMACONTROL gamma;
2279 DDGAMMARAMP gamma_ramp; 2354 DDGAMMARAMP gamma_ramp;
2280 HRESULT result; 2355 HRESULT result;
2281 #endif 2356 #endif
2282 2357
2283 /* In windowed or OpenGL mode, use windib gamma code */ 2358 /* In windowed or OpenGL mode, use windib gamma code */
2284 if ( ! DDRAW_FULLSCREEN() ) { 2359 if (!DDRAW_FULLSCREEN ()) {
2285 return DIB_SetGammaRamp(this, ramp); 2360 return DIB_SetGammaRamp (this, ramp);
2286 } 2361 }
2287
2288 #ifndef IDirectDrawGammaControl_SetGammaRamp 2362 #ifndef IDirectDrawGammaControl_SetGammaRamp
2289 SDL_SetError("SDL compiled without DirectX gamma ramp support"); 2363 SDL_SetError ("SDL compiled without DirectX gamma ramp support");
2290 return -1; 2364 return -1;
2291 #else 2365 #else
2292 /* Check for a video mode! */ 2366 /* Check for a video mode! */
2293 if ( ! SDL_primary ) { 2367 if (!SDL_primary) {
2294 SDL_SetError("A video mode must be set for gamma correction"); 2368 SDL_SetError ("A video mode must be set for gamma correction");
2295 return(-1); 2369 return (-1);
2296 } 2370 }
2297 2371
2298 /* Get the gamma control object */ 2372 /* Get the gamma control object */
2299 result = IDirectDrawSurface3_QueryInterface(SDL_primary, 2373 result = IDirectDrawSurface3_QueryInterface (SDL_primary,
2300 &IID_IDirectDrawGammaControl, (LPVOID *)&gamma); 2374 &IID_IDirectDrawGammaControl,
2301 if ( result != DD_OK ) { 2375 (LPVOID *) & gamma);
2302 SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result); 2376 if (result != DD_OK) {
2303 return(-1); 2377 SetDDerror ("DirectDrawSurface3::QueryInterface(GAMMA)", result);
2304 } 2378 return (-1);
2305 2379 }
2306 /* Set up the gamma ramp */ 2380
2307 SDL_memcpy(gamma_ramp.red, &ramp[0*256], 256*sizeof(*ramp)); 2381 /* Set up the gamma ramp */
2308 SDL_memcpy(gamma_ramp.green, &ramp[1*256], 256*sizeof(*ramp)); 2382 SDL_memcpy (gamma_ramp.red, &ramp[0 * 256], 256 * sizeof (*ramp));
2309 SDL_memcpy(gamma_ramp.blue, &ramp[2*256], 256*sizeof(*ramp)); 2383 SDL_memcpy (gamma_ramp.green, &ramp[1 * 256], 256 * sizeof (*ramp));
2310 result = IDirectDrawGammaControl_SetGammaRamp(gamma, 0, &gamma_ramp); 2384 SDL_memcpy (gamma_ramp.blue, &ramp[2 * 256], 256 * sizeof (*ramp));
2311 if ( result != DD_OK ) { 2385 result = IDirectDrawGammaControl_SetGammaRamp (gamma, 0, &gamma_ramp);
2312 SetDDerror("DirectDrawGammaControl::SetGammaRamp()", result); 2386 if (result != DD_OK) {
2313 } 2387 SetDDerror ("DirectDrawGammaControl::SetGammaRamp()", result);
2314 2388 }
2315 /* Release the interface and return */ 2389
2316 IDirectDrawGammaControl_Release(gamma); 2390 /* Release the interface and return */
2317 return (result == DD_OK) ? 0 : -1; 2391 IDirectDrawGammaControl_Release (gamma);
2392 return (result == DD_OK) ? 0 : -1;
2318 #endif /* !IDirectDrawGammaControl_SetGammaRamp */ 2393 #endif /* !IDirectDrawGammaControl_SetGammaRamp */
2319 } 2394 }
2320 2395
2321 static int DX5_GetGammaRamp(_THIS, Uint16 *ramp) 2396 static int
2397 DX5_GetGammaRamp (_THIS, Uint16 * ramp)
2322 { 2398 {
2323 #ifdef IDirectDrawGammaControl_SetGammaRamp 2399 #ifdef IDirectDrawGammaControl_SetGammaRamp
2324 LPDIRECTDRAWGAMMACONTROL gamma; 2400 LPDIRECTDRAWGAMMACONTROL gamma;
2325 DDGAMMARAMP gamma_ramp; 2401 DDGAMMARAMP gamma_ramp;
2326 HRESULT result; 2402 HRESULT result;
2327 #endif 2403 #endif
2328 2404
2329 /* In windowed or OpenGL mode, use windib gamma code */ 2405 /* In windowed or OpenGL mode, use windib gamma code */
2330 if ( ! DDRAW_FULLSCREEN() ) { 2406 if (!DDRAW_FULLSCREEN ()) {
2331 return DIB_GetGammaRamp(this, ramp); 2407 return DIB_GetGammaRamp (this, ramp);
2332 } 2408 }
2333
2334 #ifndef IDirectDrawGammaControl_SetGammaRamp 2409 #ifndef IDirectDrawGammaControl_SetGammaRamp
2335 SDL_SetError("SDL compiled without DirectX gamma ramp support"); 2410 SDL_SetError ("SDL compiled without DirectX gamma ramp support");
2336 return -1; 2411 return -1;
2337 #else 2412 #else
2338 /* Check for a video mode! */ 2413 /* Check for a video mode! */
2339 if ( ! SDL_primary ) { 2414 if (!SDL_primary) {
2340 SDL_SetError("A video mode must be set for gamma correction"); 2415 SDL_SetError ("A video mode must be set for gamma correction");
2341 return(-1); 2416 return (-1);
2342 } 2417 }
2343 2418
2344 /* Get the gamma control object */ 2419 /* Get the gamma control object */
2345 result = IDirectDrawSurface3_QueryInterface(SDL_primary, 2420 result = IDirectDrawSurface3_QueryInterface (SDL_primary,
2346 &IID_IDirectDrawGammaControl, (LPVOID *)&gamma); 2421 &IID_IDirectDrawGammaControl,
2347 if ( result != DD_OK ) { 2422 (LPVOID *) & gamma);
2348 SetDDerror("DirectDrawSurface3::QueryInterface(GAMMA)", result); 2423 if (result != DD_OK) {
2349 return(-1); 2424 SetDDerror ("DirectDrawSurface3::QueryInterface(GAMMA)", result);
2350 } 2425 return (-1);
2351 2426 }
2352 /* Set up the gamma ramp */ 2427
2353 result = IDirectDrawGammaControl_GetGammaRamp(gamma, 0, &gamma_ramp); 2428 /* Set up the gamma ramp */
2354 if ( result == DD_OK ) { 2429 result = IDirectDrawGammaControl_GetGammaRamp (gamma, 0, &gamma_ramp);
2355 SDL_memcpy(&ramp[0*256], gamma_ramp.red, 256*sizeof(*ramp)); 2430 if (result == DD_OK) {
2356 SDL_memcpy(&ramp[1*256], gamma_ramp.green, 256*sizeof(*ramp)); 2431 SDL_memcpy (&ramp[0 * 256], gamma_ramp.red, 256 * sizeof (*ramp));
2357 SDL_memcpy(&ramp[2*256], gamma_ramp.blue, 256*sizeof(*ramp)); 2432 SDL_memcpy (&ramp[1 * 256], gamma_ramp.green, 256 * sizeof (*ramp));
2358 } else { 2433 SDL_memcpy (&ramp[2 * 256], gamma_ramp.blue, 256 * sizeof (*ramp));
2359 SetDDerror("DirectDrawGammaControl::GetGammaRamp()", result); 2434 } else {
2360 } 2435 SetDDerror ("DirectDrawGammaControl::GetGammaRamp()", result);
2361 2436 }
2362 /* Release the interface and return */ 2437
2363 IDirectDrawGammaControl_Release(gamma); 2438 /* Release the interface and return */
2364 return (result == DD_OK) ? 0 : -1; 2439 IDirectDrawGammaControl_Release (gamma);
2440 return (result == DD_OK) ? 0 : -1;
2365 #endif /* !IDirectDrawGammaControl_SetGammaRamp */ 2441 #endif /* !IDirectDrawGammaControl_SetGammaRamp */
2366 } 2442 }
2367 2443
2368 void DX5_VideoQuit(_THIS) 2444 void
2369 { 2445 DX5_VideoQuit (_THIS)
2370 int i, j; 2446 {
2371 2447 int i, j;
2372 /* If we're fullscreen GL, we need to reset the display */ 2448
2373 if ( this->screen != NULL ) { 2449 /* If we're fullscreen GL, we need to reset the display */
2450 if (this->screen != NULL) {
2374 #ifndef NO_CHANGEDISPLAYSETTINGS 2451 #ifndef NO_CHANGEDISPLAYSETTINGS
2375 if ( (this->screen->flags & (SDL_INTERNALOPENGL|SDL_FULLSCREEN)) == 2452 if ((this->screen->flags & (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) ==
2376 (SDL_INTERNALOPENGL|SDL_FULLSCREEN) ) { 2453 (SDL_INTERNALOPENGL | SDL_FULLSCREEN)) {
2377 ChangeDisplaySettings(NULL, 0); 2454 ChangeDisplaySettings (NULL, 0);
2378 ShowWindow(SDL_Window, SW_HIDE); 2455 ShowWindow (SDL_Window, SW_HIDE);
2379 } 2456 }
2380 #endif 2457 #endif
2381 if ( this->screen->flags & SDL_INTERNALOPENGL ) { 2458 if (this->screen->flags & SDL_INTERNALOPENGL) {
2382 WIN_GL_ShutDown(this); 2459 WIN_GL_ShutDown (this);
2383 } 2460 }
2384 } 2461 }
2385 2462
2386 /* Free any palettes we used */ 2463 /* Free any palettes we used */
2387 if ( SDL_palette != NULL ) { 2464 if (SDL_palette != NULL) {
2388 IDirectDrawPalette_Release(SDL_palette); 2465 IDirectDrawPalette_Release (SDL_palette);
2389 SDL_palette = NULL; 2466 SDL_palette = NULL;
2390 } 2467 }
2391 2468
2392 /* Allow the primary surface to be freed */ 2469 /* Allow the primary surface to be freed */
2393 if ( SDL_primary != NULL ) { 2470 if (SDL_primary != NULL) {
2394 SDL_primary = NULL; 2471 SDL_primary = NULL;
2395 } 2472 }
2396 2473
2397 /* Free video mode lists */ 2474 /* Free video mode lists */
2398 for ( i=0; i<NUM_MODELISTS; ++i ) { 2475 for (i = 0; i < NUM_MODELISTS; ++i) {
2399 if ( SDL_modelist[i] != NULL ) { 2476 if (SDL_modelist[i] != NULL) {
2400 for ( j=0; SDL_modelist[i][j]; ++j ) 2477 for (j = 0; SDL_modelist[i][j]; ++j)
2401 SDL_free(SDL_modelist[i][j]); 2478 SDL_free (SDL_modelist[i][j]);
2402 SDL_free(SDL_modelist[i]); 2479 SDL_free (SDL_modelist[i]);
2403 SDL_modelist[i] = NULL; 2480 SDL_modelist[i] = NULL;
2404 } 2481 }
2405 } 2482 }
2406 2483
2407 /* Free the window */ 2484 /* Free the window */
2408 DIB_QuitGamma(this); 2485 DIB_QuitGamma (this);
2409 if ( SDL_Window ) { 2486 if (SDL_Window) {
2410 DX5_DestroyWindow(this); 2487 DX5_DestroyWindow (this);
2411 } 2488 }
2412 2489
2413 /* Free our window icon */ 2490 /* Free our window icon */
2414 if ( screen_icn ) { 2491 if (screen_icn) {
2415 DestroyIcon(screen_icn); 2492 DestroyIcon (screen_icn);
2416 screen_icn = NULL; 2493 screen_icn = NULL;
2417 } 2494 }
2418 } 2495 }
2419 2496
2420 /* Exported for the windows message loop only */ 2497 /* Exported for the windows message loop only */
2421 void DX5_RealizePalette(_THIS) 2498 void
2422 { 2499 DX5_RealizePalette (_THIS)
2423 if ( SDL_palette ) { 2500 {
2424 IDirectDrawSurface3_SetPalette(SDL_primary, SDL_palette); 2501 if (SDL_palette) {
2425 } 2502 IDirectDrawSurface3_SetPalette (SDL_primary, SDL_palette);
2426 } 2503 }
2427 static void DX5_Recolor8Bit(_THIS, SDL_Surface *surface, Uint8 *mapping) 2504 }
2428 { 2505 static void
2429 int row, col; 2506 DX5_Recolor8Bit (_THIS, SDL_Surface * surface, Uint8 * mapping)
2430 Uint8 *pixels; 2507 {
2431 2508 int row, col;
2432 if ( surface->w && surface->h ) { 2509 Uint8 *pixels;
2433 if ( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { 2510
2434 if ( this->LockHWSurface(this, surface) < 0 ) { 2511 if (surface->w && surface->h) {
2435 return; 2512 if ((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
2436 } 2513 if (this->LockHWSurface (this, surface) < 0) {
2437 } 2514 return;
2438 for ( row=0; row<surface->h; ++row ) { 2515 }
2439 pixels = (Uint8 *)surface->pixels+row*surface->pitch; 2516 }
2440 for ( col=0; col<surface->w; ++col, ++pixels ) { 2517 for (row = 0; row < surface->h; ++row) {
2441 *pixels = mapping[*pixels]; 2518 pixels = (Uint8 *) surface->pixels + row * surface->pitch;
2442 } 2519 for (col = 0; col < surface->w; ++col, ++pixels) {
2443 } 2520 *pixels = mapping[*pixels];
2444 if ( (surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { 2521 }
2445 this->UnlockHWSurface(this, surface); 2522 }
2446 } 2523 if ((surface->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
2447 SDL_UpdateRect(surface, 0, 0, 0, 0); 2524 this->UnlockHWSurface (this, surface);
2448 } 2525 }
2449 } 2526 SDL_UpdateRect (surface, 0, 0, 0, 0);
2450 void DX5_PaletteChanged(_THIS, HWND window) 2527 }
2451 { 2528 }
2452 SDL_Palette *palette; 2529 void
2453 SDL_Color *saved = NULL; 2530 DX5_PaletteChanged (_THIS, HWND window)
2454 HDC hdc; 2531 {
2455 int i; 2532 SDL_Palette *palette;
2456 PALETTEENTRY *entries; 2533 SDL_Color *saved = NULL;
2457 2534 HDC hdc;
2458 /* This is true when the window is closing */ 2535 int i;
2459 if ( (SDL_primary == NULL) || (SDL_VideoSurface == NULL) ) 2536 PALETTEENTRY *entries;
2460 return; 2537
2461 2538 /* This is true when the window is closing */
2462 /* We need to get the colors as they were set */ 2539 if ((SDL_primary == NULL) || (SDL_VideoSurface == NULL))
2463 palette = this->physpal; 2540 return;
2464 if(!palette) 2541
2465 palette = SDL_VideoSurface->format->palette; 2542 /* We need to get the colors as they were set */
2466 if ( palette == NULL ) { /* Sometimes we don't have a palette */ 2543 palette = this->physpal;
2467 return; 2544 if (!palette)
2468 } 2545 palette = SDL_VideoSurface->format->palette;
2469 entries = SDL_stack_alloc(PALETTEENTRY, palette->ncolors); 2546 if (palette == NULL) { /* Sometimes we don't have a palette */
2470 hdc = GetDC(window); 2547 return;
2471 GetSystemPaletteEntries(hdc, 0, palette->ncolors, entries); 2548 }
2472 ReleaseDC(window, hdc); 2549 entries = SDL_stack_alloc (PALETTEENTRY, palette->ncolors);
2473 if ( ! colorchange_expected ) { 2550 hdc = GetDC (window);
2474 saved = SDL_stack_alloc(SDL_Color, palette->ncolors); 2551 GetSystemPaletteEntries (hdc, 0, palette->ncolors, entries);
2475 SDL_memcpy(saved, palette->colors, 2552 ReleaseDC (window, hdc);
2476 palette->ncolors*sizeof(SDL_Color)); 2553 if (!colorchange_expected) {
2477 } 2554 saved = SDL_stack_alloc (SDL_Color, palette->ncolors);
2478 for ( i=0; i<palette->ncolors; ++i ) { 2555 SDL_memcpy (saved, palette->colors,
2479 palette->colors[i].r = entries[i].peRed; 2556 palette->ncolors * sizeof (SDL_Color));
2480 palette->colors[i].g = entries[i].peGreen; 2557 }
2481 palette->colors[i].b = entries[i].peBlue; 2558 for (i = 0; i < palette->ncolors; ++i) {
2482 } 2559 palette->colors[i].r = entries[i].peRed;
2483 SDL_stack_free(entries); 2560 palette->colors[i].g = entries[i].peGreen;
2484 if ( ! colorchange_expected ) { 2561 palette->colors[i].b = entries[i].peBlue;
2485 Uint8 mapping[256]; 2562 }
2486 2563 SDL_stack_free (entries);
2487 SDL_memset(mapping, 0, sizeof(mapping)); 2564 if (!colorchange_expected) {
2488 for ( i=0; i<palette->ncolors; ++i ) { 2565 Uint8 mapping[256];
2489 mapping[i] = SDL_FindColor(palette, 2566
2490 saved[i].r, saved[i].g, saved[i].b); 2567 SDL_memset (mapping, 0, sizeof (mapping));
2491 } 2568 for (i = 0; i < palette->ncolors; ++i) {
2492 DX5_Recolor8Bit(this, SDL_VideoSurface, mapping); 2569 mapping[i] = SDL_FindColor (palette,
2493 SDL_stack_free(saved); 2570 saved[i].r, saved[i].g, saved[i].b);
2494 } 2571 }
2495 colorchange_expected = 0; 2572 DX5_Recolor8Bit (this, SDL_VideoSurface, mapping);
2496 2573 SDL_stack_free (saved);
2497 /* Notify all mapped surfaces of the change */ 2574 }
2498 SDL_FormatChanged(SDL_VideoSurface); 2575 colorchange_expected = 0;
2576
2577 /* Notify all mapped surfaces of the change */
2578 SDL_FormatChanged (SDL_VideoSurface);
2499 } 2579 }
2500 2580
2501 /* Exported for the windows message loop only */ 2581 /* Exported for the windows message loop only */
2502 void DX5_WinPAINT(_THIS, HDC hdc) 2582 void
2503 { 2583 DX5_WinPAINT (_THIS, HDC hdc)
2504 SDL_UpdateRect(SDL_PublicSurface, 0, 0, 0, 0); 2584 {
2505 } 2585 SDL_UpdateRect (SDL_PublicSurface, 0, 0, 0, 0);
2586 }
2587
2588 /* vi: set ts=4 sw=4 expandtab: */