SDL  2.0
SDL_test_common.h File Reference
#include "SDL.h"
#include "begin_code.h"
#include "close_code.h"
+ Include dependency graph for SDL_test_common.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  SDLTest_CommonState
 

Macros

#define DEFAULT_WINDOW_WIDTH   640
 
#define DEFAULT_WINDOW_HEIGHT   480
 
#define VERBOSE_VIDEO   0x00000001
 
#define VERBOSE_MODES   0x00000002
 
#define VERBOSE_RENDER   0x00000004
 
#define VERBOSE_EVENT   0x00000008
 
#define VERBOSE_AUDIO   0x00000010
 

Functions

SDLTest_CommonStateSDLTest_CommonCreateState (char **argv, Uint32 flags)
 Parse command line parameters and create common state. More...
 
int SDLTest_CommonArg (SDLTest_CommonState *state, int index)
 Process one common argument. More...
 
const char * SDLTest_CommonUsage (SDLTest_CommonState *state)
 Returns common usage information. More...
 
SDL_bool SDLTest_CommonInit (SDLTest_CommonState *state)
 Open test window. More...
 
void SDLTest_CommonEvent (SDLTest_CommonState *state, SDL_Event *event, int *done)
 Common event handler for test windows. More...
 
void SDLTest_CommonQuit (SDLTest_CommonState *state)
 Close test window. More...
 

Detailed Description

Include file for SDL test framework.

This code is a part of the SDL2_test library, not the main SDL library.

Definition in file SDL_test_common.h.

Macro Definition Documentation

§ DEFAULT_WINDOW_HEIGHT

#define DEFAULT_WINDOW_HEIGHT   480

Definition at line 42 of file SDL_test_common.h.

Referenced by main(), and SDLTest_CommonCreateState().

§ DEFAULT_WINDOW_WIDTH

#define DEFAULT_WINDOW_WIDTH   640

Definition at line 41 of file SDL_test_common.h.

Referenced by InitInput(), main(), and SDLTest_CommonCreateState().

§ VERBOSE_AUDIO

#define VERBOSE_AUDIO   0x00000010

Definition at line 49 of file SDL_test_common.h.

Referenced by SDLTest_CommonInit().

§ VERBOSE_EVENT

#define VERBOSE_EVENT   0x00000008

Definition at line 48 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonEvent().

§ VERBOSE_MODES

#define VERBOSE_MODES   0x00000002

Definition at line 46 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonInit().

§ VERBOSE_RENDER

#define VERBOSE_RENDER   0x00000004

Definition at line 47 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonInit().

§ VERBOSE_VIDEO

#define VERBOSE_VIDEO   0x00000001

Definition at line 45 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonInit().

Function Documentation

§ SDLTest_CommonArg()

int SDLTest_CommonArg ( SDLTest_CommonState state,
int  index 
)

Process one common argument.

Parameters
stateThe common state describing the test window to create.
indexThe index of the argument to process in argv[].
Returns
The number of arguments processed (i.e. 1 for –fullscreen, 2 for –video [videodriver], or -1 on error.

Definition at line 83 of file SDL_test_common.c.

References SDLTest_CommonState::argv, AUDIO_S16, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S8, AUDIO_U16, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, SDLTest_CommonState::audiospec, SDL_AudioSpec::channels, SDLTest_CommonState::depth, SDLTest_CommonState::display, SDL_AudioSpec::format, SDL_AudioSpec::freq, SDLTest_CommonState::gl_debug, SDLTest_CommonState::logical_h, SDLTest_CommonState::logical_w, SDLTest_CommonState::num_windows, SDLTest_CommonState::refresh_rate, SDLTest_CommonState::render_flags, SDLTest_CommonState::renderdriver, SDL_AudioSpec::samples, SDLTest_CommonState::scale, SDL_atof, SDL_atoi, SDL_isdigit, SDL_LOG_CATEGORY_AUDIO, SDL_LOG_CATEGORY_ERROR, SDL_LOG_CATEGORY_INPUT, SDL_LOG_CATEGORY_RENDER, SDL_LOG_CATEGORY_SYSTEM, SDL_LOG_CATEGORY_VIDEO, SDL_LOG_PRIORITY_VERBOSE, SDL_LogSetAllPriority, SDL_LogSetPriority, SDL_RENDERER_PRESENTVSYNC, SDL_strcasecmp, SDL_strcmp, SDL_WINDOW_ALLOW_HIGHDPI, SDL_WINDOW_BORDERLESS, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSCREEN_DESKTOP, SDL_WINDOW_INPUT_GRABBED, SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MINIMIZED, SDL_WINDOW_RESIZABLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED_DISPLAY, SDL_WINDOWPOS_ISCENTERED, SDL_WINDOWPOS_ISUNDEFINED, SDL_WINDOWPOS_UNDEFINED_DISPLAY, SDLTest_CommonState::verbose, VERBOSE_EVENT, VERBOSE_MODES, VERBOSE_RENDER, VERBOSE_VIDEO, SDLTest_CommonState::videodriver, SDLTest_CommonState::window_flags, SDLTest_CommonState::window_h, SDLTest_CommonState::window_icon, SDLTest_CommonState::window_maxH, SDLTest_CommonState::window_maxW, SDLTest_CommonState::window_minH, SDLTest_CommonState::window_minW, SDLTest_CommonState::window_title, SDLTest_CommonState::window_w, SDLTest_CommonState::window_x, and SDLTest_CommonState::window_y.

Referenced by main().

84 {
85  char **argv = state->argv;
86 
87  if (SDL_strcasecmp(argv[index], "--video") == 0) {
88  ++index;
89  if (!argv[index]) {
90  return -1;
91  }
92  state->videodriver = argv[index];
93  return 2;
94  }
95  if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
96  ++index;
97  if (!argv[index]) {
98  return -1;
99  }
100  state->renderdriver = argv[index];
101  return 2;
102  }
103  if (SDL_strcasecmp(argv[index], "--gldebug") == 0) {
104  state->gl_debug = 1;
105  return 1;
106  }
107  if (SDL_strcasecmp(argv[index], "--info") == 0) {
108  ++index;
109  if (!argv[index]) {
110  return -1;
111  }
112  if (SDL_strcasecmp(argv[index], "all") == 0) {
113  state->verbose |=
115  VERBOSE_EVENT);
116  return 2;
117  }
118  if (SDL_strcasecmp(argv[index], "video") == 0) {
119  state->verbose |= VERBOSE_VIDEO;
120  return 2;
121  }
122  if (SDL_strcasecmp(argv[index], "modes") == 0) {
123  state->verbose |= VERBOSE_MODES;
124  return 2;
125  }
126  if (SDL_strcasecmp(argv[index], "render") == 0) {
127  state->verbose |= VERBOSE_RENDER;
128  return 2;
129  }
130  if (SDL_strcasecmp(argv[index], "event") == 0) {
131  state->verbose |= VERBOSE_EVENT;
132  return 2;
133  }
134  return -1;
135  }
136  if (SDL_strcasecmp(argv[index], "--log") == 0) {
137  ++index;
138  if (!argv[index]) {
139  return -1;
140  }
141  if (SDL_strcasecmp(argv[index], "all") == 0) {
143  return 2;
144  }
145  if (SDL_strcasecmp(argv[index], "error") == 0) {
147  return 2;
148  }
149  if (SDL_strcasecmp(argv[index], "system") == 0) {
151  return 2;
152  }
153  if (SDL_strcasecmp(argv[index], "audio") == 0) {
155  return 2;
156  }
157  if (SDL_strcasecmp(argv[index], "video") == 0) {
159  return 2;
160  }
161  if (SDL_strcasecmp(argv[index], "render") == 0) {
163  return 2;
164  }
165  if (SDL_strcasecmp(argv[index], "input") == 0) {
167  return 2;
168  }
169  return -1;
170  }
171  if (SDL_strcasecmp(argv[index], "--display") == 0) {
172  ++index;
173  if (!argv[index]) {
174  return -1;
175  }
176  state->display = SDL_atoi(argv[index]);
177  if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) {
180  }
181  if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) {
184  }
185  return 2;
186  }
187  if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
189  state->num_windows = 1;
190  return 1;
191  }
192  if (SDL_strcasecmp(argv[index], "--fullscreen-desktop") == 0) {
194  state->num_windows = 1;
195  return 1;
196  }
197  if (SDL_strcasecmp(argv[index], "--allow-highdpi") == 0) {
199  return 1;
200  }
201  if (SDL_strcasecmp(argv[index], "--windows") == 0) {
202  ++index;
203  if (!argv[index] || !SDL_isdigit(*argv[index])) {
204  return -1;
205  }
206  if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
207  state->num_windows = SDL_atoi(argv[index]);
208  }
209  return 2;
210  }
211  if (SDL_strcasecmp(argv[index], "--title") == 0) {
212  ++index;
213  if (!argv[index]) {
214  return -1;
215  }
216  state->window_title = argv[index];
217  return 2;
218  }
219  if (SDL_strcasecmp(argv[index], "--icon") == 0) {
220  ++index;
221  if (!argv[index]) {
222  return -1;
223  }
224  state->window_icon = argv[index];
225  return 2;
226  }
227  if (SDL_strcasecmp(argv[index], "--center") == 0) {
230  return 1;
231  }
232  if (SDL_strcasecmp(argv[index], "--position") == 0) {
233  char *x, *y;
234  ++index;
235  if (!argv[index]) {
236  return -1;
237  }
238  x = argv[index];
239  y = argv[index];
240  while (*y && *y != ',') {
241  ++y;
242  }
243  if (!*y) {
244  return -1;
245  }
246  *y++ = '\0';
247  state->window_x = SDL_atoi(x);
248  state->window_y = SDL_atoi(y);
249  return 2;
250  }
251  if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
252  char *w, *h;
253  ++index;
254  if (!argv[index]) {
255  return -1;
256  }
257  w = argv[index];
258  h = argv[index];
259  while (*h && *h != 'x') {
260  ++h;
261  }
262  if (!*h) {
263  return -1;
264  }
265  *h++ = '\0';
266  state->window_w = SDL_atoi(w);
267  state->window_h = SDL_atoi(h);
268  return 2;
269  }
270  if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) {
271  char *w, *h;
272  ++index;
273  if (!argv[index]) {
274  return -1;
275  }
276  w = argv[index];
277  h = argv[index];
278  while (*h && *h != 'x') {
279  ++h;
280  }
281  if (!*h) {
282  return -1;
283  }
284  *h++ = '\0';
285  state->window_minW = SDL_atoi(w);
286  state->window_minH = SDL_atoi(h);
287  return 2;
288  }
289  if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) {
290  char *w, *h;
291  ++index;
292  if (!argv[index]) {
293  return -1;
294  }
295  w = argv[index];
296  h = argv[index];
297  while (*h && *h != 'x') {
298  ++h;
299  }
300  if (!*h) {
301  return -1;
302  }
303  *h++ = '\0';
304  state->window_maxW = SDL_atoi(w);
305  state->window_maxH = SDL_atoi(h);
306  return 2;
307  }
308  if (SDL_strcasecmp(argv[index], "--logical") == 0) {
309  char *w, *h;
310  ++index;
311  if (!argv[index]) {
312  return -1;
313  }
314  w = argv[index];
315  h = argv[index];
316  while (*h && *h != 'x') {
317  ++h;
318  }
319  if (!*h) {
320  return -1;
321  }
322  *h++ = '\0';
323  state->logical_w = SDL_atoi(w);
324  state->logical_h = SDL_atoi(h);
325  return 2;
326  }
327  if (SDL_strcasecmp(argv[index], "--scale") == 0) {
328  ++index;
329  if (!argv[index]) {
330  return -1;
331  }
332  state->scale = (float)SDL_atof(argv[index]);
333  return 2;
334  }
335  if (SDL_strcasecmp(argv[index], "--depth") == 0) {
336  ++index;
337  if (!argv[index]) {
338  return -1;
339  }
340  state->depth = SDL_atoi(argv[index]);
341  return 2;
342  }
343  if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
344  ++index;
345  if (!argv[index]) {
346  return -1;
347  }
348  state->refresh_rate = SDL_atoi(argv[index]);
349  return 2;
350  }
351  if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
353  return 1;
354  }
355  if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
357  return 1;
358  }
359  if (SDL_strcasecmp(argv[index], "--resize") == 0) {
361  return 1;
362  }
363  if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
365  return 1;
366  }
367  if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
369  return 1;
370  }
371  if (SDL_strcasecmp(argv[index], "--grab") == 0) {
373  return 1;
374  }
375  if (SDL_strcasecmp(argv[index], "--rate") == 0) {
376  ++index;
377  if (!argv[index]) {
378  return -1;
379  }
380  state->audiospec.freq = SDL_atoi(argv[index]);
381  return 2;
382  }
383  if (SDL_strcasecmp(argv[index], "--format") == 0) {
384  ++index;
385  if (!argv[index]) {
386  return -1;
387  }
388  if (SDL_strcasecmp(argv[index], "U8") == 0) {
389  state->audiospec.format = AUDIO_U8;
390  return 2;
391  }
392  if (SDL_strcasecmp(argv[index], "S8") == 0) {
393  state->audiospec.format = AUDIO_S8;
394  return 2;
395  }
396  if (SDL_strcasecmp(argv[index], "U16") == 0) {
397  state->audiospec.format = AUDIO_U16;
398  return 2;
399  }
400  if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
401  state->audiospec.format = AUDIO_U16LSB;
402  return 2;
403  }
404  if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
405  state->audiospec.format = AUDIO_U16MSB;
406  return 2;
407  }
408  if (SDL_strcasecmp(argv[index], "S16") == 0) {
409  state->audiospec.format = AUDIO_S16;
410  return 2;
411  }
412  if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
413  state->audiospec.format = AUDIO_S16LSB;
414  return 2;
415  }
416  if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
417  state->audiospec.format = AUDIO_S16MSB;
418  return 2;
419  }
420  return -1;
421  }
422  if (SDL_strcasecmp(argv[index], "--channels") == 0) {
423  ++index;
424  if (!argv[index]) {
425  return -1;
426  }
427  state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
428  return 2;
429  }
430  if (SDL_strcasecmp(argv[index], "--samples") == 0) {
431  ++index;
432  if (!argv[index]) {
433  return -1;
434  }
435  state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
436  return 2;
437  }
438  if ((SDL_strcasecmp(argv[index], "-h") == 0)
439  || (SDL_strcasecmp(argv[index], "--help") == 0)) {
440  /* Print the usage message */
441  return -1;
442  }
443  if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) {
444  /* Debug flag sent by Xcode */
445  return 2;
446  }
447  return 0;
448 }
#define SDL_WINDOWPOS_ISUNDEFINED(X)
Definition: SDL_video.h:128
#define SDL_WINDOWPOS_CENTERED
Definition: SDL_video.h:136
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1567
const char * window_icon
#define SDL_WINDOWPOS_ISCENTERED(X)
Definition: SDL_video.h:137
Uint16 samples
Definition: SDL_audio.h:174
const char * renderdriver
#define VERBOSE_EVENT
#define SDL_strcasecmp
SDL_AudioSpec audiospec
#define AUDIO_U8
Definition: SDL_audio.h:89
#define SDL_WINDOWPOS_UNDEFINED_DISPLAY(X)
Definition: SDL_video.h:126
#define SDL_atof
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1567
#define SDL_isdigit
Uint8 channels
Definition: SDL_audio.h:172
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:143
#define SDL_atoi
GLuint index
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X)
Definition: SDL_video.h:135
#define SDL_LogSetPriority
#define VERBOSE_MODES
#define VERBOSE_RENDER
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
SDL_AudioFormat format
Definition: SDL_audio.h:171
#define AUDIO_S16
Definition: SDL_audio.h:96
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
#define SDL_LogSetAllPriority
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:151
GLubyte GLubyte GLubyte GLubyte w
#define SDL_strcmp
#define AUDIO_U16
Definition: SDL_audio.h:95
#define VERBOSE_VIDEO
#define AUDIO_S8
Definition: SDL_audio.h:90
const char * videodriver
GLfloat GLfloat GLfloat GLfloat h
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
const char * window_title

§ SDLTest_CommonCreateState()

SDLTest_CommonState* SDLTest_CommonCreateState ( char **  argv,
Uint32  flags 
)

Parse command line parameters and create common state.

Parameters
argvArray of command line parameters
flagsFlags indicating which subsystem to initialize (i.e. SDL_INIT_VIDEO | SDL_INIT_AUDIO)
Returns
Returns a newly allocated common state object.

Definition at line 36 of file SDL_test_common.c.

References SDLTest_CommonState::argv, AUDIO_S16, SDLTest_CommonState::audiospec, SDL_AudioSpec::channels, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH, SDLTest_CommonState::flags, SDL_AudioSpec::format, SDL_AudioSpec::freq, SDLTest_CommonState::gl_accelerated, SDLTest_CommonState::gl_accum_alpha_size, SDLTest_CommonState::gl_accum_blue_size, SDLTest_CommonState::gl_accum_green_size, SDLTest_CommonState::gl_accum_red_size, SDLTest_CommonState::gl_alpha_size, SDLTest_CommonState::gl_blue_size, SDLTest_CommonState::gl_buffer_size, SDLTest_CommonState::gl_debug, SDLTest_CommonState::gl_depth_size, SDLTest_CommonState::gl_double_buffer, SDLTest_CommonState::gl_green_size, SDLTest_CommonState::gl_multisamplebuffers, SDLTest_CommonState::gl_multisamplesamples, SDLTest_CommonState::gl_red_size, SDLTest_CommonState::gl_retained_backing, SDLTest_CommonState::gl_stencil_size, SDLTest_CommonState::gl_stereo, NULL, SDLTest_CommonState::num_windows, SDL_AudioSpec::samples, SDL_calloc(), SDL_OutOfMemory, SDL_WINDOWPOS_UNDEFINED, state, SDLTest_CommonState::window_flags, SDLTest_CommonState::window_h, SDLTest_CommonState::window_title, SDLTest_CommonState::window_w, SDLTest_CommonState::window_x, and SDLTest_CommonState::window_y.

Referenced by main().

37 {
39  if (!state) {
41  return NULL;
42  }
43 
44  /* Initialize some defaults */
45  state->argv = argv;
46  state->flags = flags;
47  state->window_title = argv[0];
48  state->window_flags = 0;
53  state->num_windows = 1;
54  state->audiospec.freq = 22050;
55  state->audiospec.format = AUDIO_S16;
56  state->audiospec.channels = 2;
57  state->audiospec.samples = 2048;
58 
59  /* Set some very sane GL defaults */
60  state->gl_red_size = 3;
61  state->gl_green_size = 3;
62  state->gl_blue_size = 2;
63  state->gl_alpha_size = 0;
64  state->gl_buffer_size = 0;
65  state->gl_depth_size = 16;
66  state->gl_stencil_size = 0;
67  state->gl_double_buffer = 1;
68  state->gl_accum_red_size = 0;
69  state->gl_accum_green_size = 0;
70  state->gl_accum_blue_size = 0;
71  state->gl_accum_alpha_size = 0;
72  state->gl_stereo = 0;
73  state->gl_multisamplebuffers = 0;
74  state->gl_multisamplesamples = 0;
75  state->gl_retained_backing = 1;
76  state->gl_accelerated = -1;
77  state->gl_debug = 0;
78 
79  return state;
80 }
struct xkb_state * state
Uint16 samples
Definition: SDL_audio.h:174
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:127
SDL_AudioSpec audiospec
void * SDL_calloc(size_t nmemb, size_t size)
Uint8 channels
Definition: SDL_audio.h:172
#define DEFAULT_WINDOW_HEIGHT
#define NULL
Definition: begin_code.h:143
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_AudioFormat format
Definition: SDL_audio.h:171
#define AUDIO_S16
Definition: SDL_audio.h:96
GLbitfield flags
#define DEFAULT_WINDOW_WIDTH
const char * window_title

§ SDLTest_CommonEvent()

void SDLTest_CommonEvent ( SDLTest_CommonState state,
SDL_Event event,
int *  done 
)

Common event handler for test windows.

Parameters
stateThe common state used to create test window.
eventThe event to handle.
doneFlag indicating we are done.

Definition at line 1301 of file SDL_test_common.c.

References SDL_WindowEvent::event, FullscreenTo(), SDL_Rect::h, i, SDL_Event::key, SDL_KeyboardEvent::keysym, KMOD_ALT, KMOD_CTRL, KMOD_SHIFT, NULL, SDLTest_CommonState::num_windows, SDLTest_CommonState::renderers, SDL_BUTTON_LMASK, SDL_BUTTON_MMASK, SDL_BUTTON_RMASK, SDL_BUTTON_X1MASK, SDL_BUTTON_X2MASK, SDL_CaptureMouse, SDL_DestroyRenderer, SDL_DestroyTexture, SDL_DestroyWindow, SDL_FALSE, SDL_free(), SDL_GetClipboardText, SDL_GetGlobalMouseState, SDL_GetKeyboardFocus, SDL_GetRelativeMouseMode, SDL_GetWindowFlags, SDL_GetWindowFromID, SDL_GetWindowGrab, SDL_GetWindowOpacity, SDL_GetWindowSize, SDL_KEYDOWN, SDL_Log, SDL_MaximizeWindow, SDL_MESSAGEBOX_INFORMATION, SDL_MinimizeWindow, SDL_MOUSEMOTION, SDL_QUIT, SDL_RectEmpty(), SDL_RenderGetClipRect, SDL_RenderSetClipRect, SDL_RestoreWindow, SDL_SetClipboardText, SDL_SetRelativeMouseMode, SDL_SetWindowBordered, SDL_SetWindowFullscreen, SDL_SetWindowGrab, SDL_SetWindowOpacity, SDL_SetWindowSize, SDL_ShowSimpleMessageBox, SDL_snprintf, SDL_TRUE, SDL_WINDOW_BORDERLESS, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSCREEN_DESKTOP, SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MOUSE_CAPTURE, SDL_WINDOWEVENT, SDL_WINDOWEVENT_CLOSE, SDLK_0, SDLK_1, SDLK_2, SDLK_a, SDLK_b, SDLK_c, SDLK_EQUALS, SDLK_ESCAPE, SDLK_g, SDLK_m, SDLK_MINUS, SDLK_o, SDLK_PRINTSCREEN, SDLK_r, SDLK_RETURN, SDLK_SPACE, SDLK_v, SDLK_z, SDLTest_PrintEvent(), SDLTest_ScreenShot(), SDL_Keysym::sym, SDLTest_CommonState::targets, text, SDL_Event::type, SDLTest_CommonState::verbose, VERBOSE_EVENT, SDL_Rect::w, window, SDL_Event::window, SDL_WindowEvent::windowID, SDL_KeyboardEvent::windowID, SDLTest_CommonState::windows, SDL_Rect::x, SDL_MouseMotionEvent::x, SDL_MouseMotionEvent::xrel, SDL_Rect::y, SDL_MouseMotionEvent::y, and SDL_MouseMotionEvent::yrel.

Referenced by loop(), and main().

1302 {
1303  int i;
1304  static SDL_MouseMotionEvent lastEvent;
1305 
1306  if (state->verbose & VERBOSE_EVENT) {
1307  SDLTest_PrintEvent(event);
1308  }
1309 
1310  switch (event->type) {
1311  case SDL_WINDOWEVENT:
1312  switch (event->window.event) {
1313  case SDL_WINDOWEVENT_CLOSE:
1314  {
1316  if (window) {
1317  for (i = 0; i < state->num_windows; ++i) {
1318  if (window == state->windows[i]) {
1319  if (state->targets[i]) {
1320  SDL_DestroyTexture(state->targets[i]);
1321  state->targets[i] = NULL;
1322  }
1323  if (state->renderers[i]) {
1324  SDL_DestroyRenderer(state->renderers[i]);
1325  state->renderers[i] = NULL;
1326  }
1327  SDL_DestroyWindow(state->windows[i]);
1328  state->windows[i] = NULL;
1329  break;
1330  }
1331  }
1332  }
1333  }
1334  break;
1335  }
1336  break;
1337  case SDL_KEYDOWN: {
1338  SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
1339  SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
1340  SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
1341 
1342  switch (event->key.keysym.sym) {
1343  /* Add hotkeys here */
1344  case SDLK_PRINTSCREEN: {
1345  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1346  if (window) {
1347  for (i = 0; i < state->num_windows; ++i) {
1348  if (window == state->windows[i]) {
1349  SDLTest_ScreenShot(state->renderers[i]);
1350  }
1351  }
1352  }
1353  }
1354  break;
1355  case SDLK_EQUALS:
1356  if (withControl) {
1357  /* Ctrl-+ double the size of the window */
1358  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1359  if (window) {
1360  int w, h;
1361  SDL_GetWindowSize(window, &w, &h);
1362  SDL_SetWindowSize(window, w*2, h*2);
1363  }
1364  }
1365  break;
1366  case SDLK_MINUS:
1367  if (withControl) {
1368  /* Ctrl-- half the size of the window */
1369  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1370  if (window) {
1371  int w, h;
1372  SDL_GetWindowSize(window, &w, &h);
1373  SDL_SetWindowSize(window, w/2, h/2);
1374  }
1375  }
1376  break;
1377  case SDLK_o:
1378  if (withControl) {
1379  /* Ctrl-O (or Ctrl-Shift-O) changes window opacity. */
1380  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1381  if (window) {
1382  float opacity;
1383  if (SDL_GetWindowOpacity(window, &opacity) == 0) {
1384  if (withShift) {
1385  opacity += 0.20f;
1386  } else {
1387  opacity -= 0.20f;
1388  }
1389  SDL_SetWindowOpacity(window, opacity);
1390  }
1391  }
1392  }
1393  break;
1394 
1395  case SDLK_c:
1396  if (withControl) {
1397  /* Ctrl-C copy awesome text! */
1398  SDL_SetClipboardText("SDL rocks!\nYou know it!");
1399  printf("Copied text to clipboard\n");
1400  }
1401  if (withAlt) {
1402  /* Alt-C toggle a render clip rectangle */
1403  for (i = 0; i < state->num_windows; ++i) {
1404  int w, h;
1405  if (state->renderers[i]) {
1406  SDL_Rect clip;
1407  SDL_GetWindowSize(state->windows[i], &w, &h);
1408  SDL_RenderGetClipRect(state->renderers[i], &clip);
1409  if (SDL_RectEmpty(&clip)) {
1410  clip.x = w/4;
1411  clip.y = h/4;
1412  clip.w = w/2;
1413  clip.h = h/2;
1414  SDL_RenderSetClipRect(state->renderers[i], &clip);
1415  } else {
1416  SDL_RenderSetClipRect(state->renderers[i], NULL);
1417  }
1418  }
1419  }
1420  }
1421  if (withShift) {
1422  SDL_Window *current_win = SDL_GetKeyboardFocus();
1423  if (current_win) {
1424  const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
1425  const int rc = SDL_CaptureMouse(shouldCapture);
1426  SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
1427  }
1428  }
1429  break;
1430  case SDLK_v:
1431  if (withControl) {
1432  /* Ctrl-V paste awesome text! */
1433  char *text = SDL_GetClipboardText();
1434  if (*text) {
1435  printf("Clipboard: %s\n", text);
1436  } else {
1437  printf("Clipboard is empty\n");
1438  }
1439  SDL_free(text);
1440  }
1441  break;
1442  case SDLK_g:
1443  if (withControl) {
1444  /* Ctrl-G toggle grab */
1445  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1446  if (window) {
1447  SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
1448  }
1449  }
1450  break;
1451  case SDLK_m:
1452  if (withControl) {
1453  /* Ctrl-M maximize */
1454  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1455  if (window) {
1456  Uint32 flags = SDL_GetWindowFlags(window);
1457  if (flags & SDL_WINDOW_MAXIMIZED) {
1458  SDL_RestoreWindow(window);
1459  } else {
1460  SDL_MaximizeWindow(window);
1461  }
1462  }
1463  }
1464  break;
1465  case SDLK_r:
1466  if (withControl) {
1467  /* Ctrl-R toggle mouse relative mode */
1469  }
1470  break;
1471  case SDLK_z:
1472  if (withControl) {
1473  /* Ctrl-Z minimize */
1474  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1475  if (window) {
1476  SDL_MinimizeWindow(window);
1477  }
1478  }
1479  break;
1480  case SDLK_RETURN:
1481  if (withControl) {
1482  /* Ctrl-Enter toggle fullscreen */
1483  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1484  if (window) {
1485  Uint32 flags = SDL_GetWindowFlags(window);
1486  if (flags & SDL_WINDOW_FULLSCREEN) {
1488  } else {
1489  SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
1490  }
1491  }
1492  } else if (withAlt) {
1493  /* Alt-Enter toggle fullscreen desktop */
1494  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1495  if (window) {
1496  Uint32 flags = SDL_GetWindowFlags(window);
1497  if (flags & SDL_WINDOW_FULLSCREEN) {
1499  } else {
1501  }
1502  }
1503  } else if (withShift) {
1504  /* Shift-Enter toggle fullscreen desktop / fullscreen */
1505  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1506  if (window) {
1507  Uint32 flags = SDL_GetWindowFlags(window);
1508  if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
1510  } else {
1511  SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1512  }
1513  }
1514  }
1515 
1516  break;
1517  case SDLK_b:
1518  if (withControl) {
1519  /* Ctrl-B toggle window border */
1520  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1521  if (window) {
1522  const Uint32 flags = SDL_GetWindowFlags(window);
1523  const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
1524  SDL_SetWindowBordered(window, b);
1525  }
1526  }
1527  break;
1528  case SDLK_a:
1529  if (withControl) {
1530  /* Ctrl-A reports absolute mouse position. */
1531  int x, y;
1532  const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
1533  SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
1534  (mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
1535  (mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
1536  (mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
1537  (mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
1538  (mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
1539  }
1540  break;
1541  case SDLK_0:
1542  if (withControl) {
1543  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1544  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
1545  }
1546  break;
1547  case SDLK_1:
1548  if (withControl) {
1549  FullscreenTo(0, event->key.windowID);
1550  }
1551  break;
1552  case SDLK_2:
1553  if (withControl) {
1554  FullscreenTo(1, event->key.windowID);
1555  }
1556  break;
1557  case SDLK_ESCAPE:
1558  *done = 1;
1559  break;
1560  case SDLK_SPACE:
1561  {
1562  char message[256];
1563  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1564 
1565  SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
1566  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
1567  break;
1568  }
1569  default:
1570  break;
1571  }
1572  break;
1573  }
1574  case SDL_QUIT:
1575  *done = 1;
1576  break;
1577  case SDL_MOUSEMOTION:
1578  lastEvent = event->motion;
1579  break;
1580  }
1581 }
SDL_Texture ** targets
#define SDL_RenderGetClipRect
#define SDL_SetWindowFullscreen
#define SDL_BUTTON_RMASK
Definition: SDL_mouse.h:289
GLuint GLsizei const GLchar * message
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1567
#define KMOD_CTRL
Definition: SDL_keycode.h:334
#define SDL_BUTTON_X2MASK
Definition: SDL_mouse.h:291
static SDL_Window * window
#define SDL_SetWindowSize
#define SDL_GetWindowFlags
#define KMOD_ALT
Definition: SDL_keycode.h:336
#define VERBOSE_EVENT
#define SDL_SetRelativeMouseMode
#define SDL_GetKeyboardFocus
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:159
#define SDL_MinimizeWindow
SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
Returns true if the rectangle has no area.
Definition: SDL_rect.h:82
SDL_Window ** windows
SDL_WindowEvent window
Definition: SDL_events.h:529
#define SDL_GetWindowSize
#define SDL_Log
#define SDL_GetRelativeMouseMode
#define SDL_ShowSimpleMessageBox
#define SDL_GetClipboardText
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1567
#define SDL_SetWindowGrab
#define KMOD_SHIFT
Definition: SDL_keycode.h:335
void SDL_free(void *mem)
int done
Definition: checkkeys.c:28
#define SDL_SetWindowOpacity
#define SDL_BUTTON_X1MASK
Definition: SDL_mouse.h:290
#define SDL_BUTTON_LMASK
Definition: SDL_mouse.h:287
int x
Definition: SDL_rect.h:66
SDL_Keysym keysym
Definition: SDL_events.h:199
#define SDL_GetWindowFromID
int w
Definition: SDL_rect.h:67
GLenum GLint GLuint mask
#define SDL_RestoreWindow
SDL_Renderer ** renderers
static void SDLTest_PrintEvent(SDL_Event *event)
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define SDL_GetWindowOpacity
#define NULL
Definition: begin_code.h:143
SDL_bool
Definition: SDL_stdinc.h:130
#define SDL_SetWindowBordered
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
Mouse motion event structure (event.motion.*)
Definition: SDL_events.h:232
SDL_KeyboardEvent key
Definition: SDL_events.h:530
#define SDL_DestroyTexture
int h
Definition: SDL_rect.h:67
The type used to identify a window.
Definition: SDL_sysvideo.h:71
#define SDL_GetWindowGrab
#define SDL_CaptureMouse
SDL_Keycode sym
Definition: SDL_keyboard.h:50
#define SDL_GetGlobalMouseState
static void SDLTest_ScreenShot(SDL_Renderer *renderer)
#define SDL_snprintf
GLbitfield flags
#define SDL_RenderSetClipRect
GLubyte GLubyte GLubyte GLubyte w
#define SDL_DestroyRenderer
#define SDL_MaximizeWindow
static void FullscreenTo(int index, int windowId)
#define SDL_BUTTON_MMASK
Definition: SDL_mouse.h:288
#define SDL_DestroyWindow
GLboolean GLboolean GLboolean b
int y
Definition: SDL_rect.h:66
GLfloat GLfloat GLfloat GLfloat h
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
#define SDL_SetClipboardText
Uint32 type
Definition: SDL_events.h:527

§ SDLTest_CommonInit()

SDL_bool SDLTest_CommonInit ( SDLTest_CommonState state)

Open test window.

Parameters
stateThe common state describing the test window to create.
Returns
True if initialization succeeded, false otherwise

Definition at line 645 of file SDL_test_common.c.

References SDLTest_CommonState::audiodriver, SDLTest_CommonState::audiospec, SDLTest_CommonState::depth, SDLTest_CommonState::flags, SDL_DisplayMode::format, SDLTest_CommonState::gl_accelerated, SDLTest_CommonState::gl_accum_alpha_size, SDLTest_CommonState::gl_accum_blue_size, SDLTest_CommonState::gl_accum_green_size, SDLTest_CommonState::gl_accum_red_size, SDLTest_CommonState::gl_alpha_size, SDLTest_CommonState::gl_blue_size, SDLTest_CommonState::gl_buffer_size, SDLTest_CommonState::gl_debug, SDLTest_CommonState::gl_depth_size, SDLTest_CommonState::gl_double_buffer, SDLTest_CommonState::gl_green_size, SDLTest_CommonState::gl_major_version, SDLTest_CommonState::gl_minor_version, SDLTest_CommonState::gl_multisamplebuffers, SDLTest_CommonState::gl_multisamplesamples, SDLTest_CommonState::gl_profile_mask, SDLTest_CommonState::gl_red_size, SDLTest_CommonState::gl_retained_backing, SDLTest_CommonState::gl_stencil_size, SDLTest_CommonState::gl_stereo, SDL_DisplayMode::h, SDL_Rect::h, i, j, SDLTest_CommonState::logical_h, SDLTest_CommonState::logical_w, SDL_RendererInfo::name, NULL, SDLTest_CommonState::num_windows, SDL_DisplayMode::refresh_rate, SDLTest_CommonState::refresh_rate, SDLTest_CommonState::render_flags, SDLTest_CommonState::renderdriver, SDLTest_CommonState::renderers, SDLTest_CommonState::scale, SDL_arraysize, SDL_AudioInit, SDL_CreateRenderer, SDL_CreateWindow, SDL_Direct3D9GetAdapterIndex(), SDL_DXGIGetOutputInfo(), SDL_FALSE, SDL_FreeSurface, SDL_GetAudioDriver, SDL_GetCurrentAudioDriver, SDL_GetCurrentVideoDriver, SDL_GetDesktopDisplayMode, SDL_GetDisplayBounds, SDL_GetDisplayMode, SDL_GetDisplayName, SDL_GetError, SDL_GetNumAudioDrivers, SDL_GetNumDisplayModes, SDL_GetNumRenderDrivers, SDL_GetNumVideoDisplays, SDL_GetNumVideoDrivers, SDL_GetPixelFormatName, SDL_GetRenderDriverInfo, SDL_GetRendererInfo, SDL_GetVideoDriver, SDL_GetWindowSize, SDL_GL_ACCELERATED_VISUAL, SDL_GL_ACCUM_ALPHA_SIZE, SDL_GL_ACCUM_BLUE_SIZE, SDL_GL_ACCUM_GREEN_SIZE, SDL_GL_ACCUM_RED_SIZE, SDL_GL_ALPHA_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_BUFFER_SIZE, SDL_GL_CONTEXT_DEBUG_FLAG, SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_MAJOR_VERSION, SDL_GL_CONTEXT_MINOR_VERSION, SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_DEPTH_SIZE, SDL_GL_DOUBLEBUFFER, SDL_GL_GREEN_SIZE, SDL_GL_MULTISAMPLEBUFFERS, SDL_GL_MULTISAMPLESAMPLES, SDL_GL_RED_SIZE, SDL_GL_RETAINED_BACKING, SDL_GL_SetAttribute, SDL_GL_STENCIL_SIZE, SDL_GL_STEREO, SDL_INIT_AUDIO, SDL_INIT_VIDEO, SDL_malloc, SDL_OpenAudio, SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_RGB24, SDL_PIXELFORMAT_RGB555, SDL_PIXELFORMAT_RGB565, SDL_PIXELFORMAT_RGB888, SDL_PixelFormatEnumToMasks, SDL_RenderSetLogicalSize, SDL_RenderSetScale, SDL_SetWindowDisplayMode, SDL_SetWindowIcon, SDL_SetWindowMaximumSize, SDL_SetWindowMinimumSize, SDL_ShowWindow, SDL_snprintf, SDL_strcasecmp, SDL_strlcpy, SDL_TRUE, SDL_VideoInit, SDL_WINDOW_OPENGL, SDL_WINDOW_RESIZABLE, SDL_zero, SDLTest_LoadIcon(), SDLTest_PrintRenderer(), SDLTest_CommonState::skip_renderer, SDLTest_CommonState::targets, SDLTest_CommonState::verbose, VERBOSE_AUDIO, VERBOSE_MODES, VERBOSE_RENDER, VERBOSE_VIDEO, SDLTest_CommonState::videodriver, SDL_DisplayMode::w, SDL_Rect::w, SDLTest_CommonState::window_flags, SDLTest_CommonState::window_h, SDLTest_CommonState::window_icon, SDLTest_CommonState::window_maxH, SDLTest_CommonState::window_maxW, SDLTest_CommonState::window_minH, SDLTest_CommonState::window_minW, SDLTest_CommonState::window_title, SDLTest_CommonState::window_w, SDLTest_CommonState::window_x, SDLTest_CommonState::window_y, SDLTest_CommonState::windows, SDL_Rect::x, and SDL_Rect::y.

Referenced by main().

646 {
647  int i, j, m, n, w, h;
648  SDL_DisplayMode fullscreen_mode;
649 
650  if (state->flags & SDL_INIT_VIDEO) {
651  if (state->verbose & VERBOSE_VIDEO) {
653  if (n == 0) {
654  fprintf(stderr, "No built-in video drivers\n");
655  } else {
656  fprintf(stderr, "Built-in video drivers:");
657  for (i = 0; i < n; ++i) {
658  if (i > 0) {
659  fprintf(stderr, ",");
660  }
661  fprintf(stderr, " %s", SDL_GetVideoDriver(i));
662  }
663  fprintf(stderr, "\n");
664  }
665  }
666  if (SDL_VideoInit(state->videodriver) < 0) {
667  fprintf(stderr, "Couldn't initialize video driver: %s\n",
668  SDL_GetError());
669  return SDL_FALSE;
670  }
671  if (state->verbose & VERBOSE_VIDEO) {
672  fprintf(stderr, "Video driver: %s\n",
674  }
675 
676  /* Upload GL settings */
692  if (state->gl_accelerated >= 0) {
694  state->gl_accelerated);
695  }
697  if (state->gl_major_version) {
700  }
701  if (state->gl_debug) {
703  }
704  if (state->gl_profile_mask) {
706  }
707 
708  if (state->verbose & VERBOSE_MODES) {
709  SDL_Rect bounds;
711  int bpp;
712  Uint32 Rmask, Gmask, Bmask, Amask;
713 #if SDL_VIDEO_DRIVER_WINDOWS
714  int adapterIndex = 0;
715  int outputIndex = 0;
716 #endif
718  fprintf(stderr, "Number of displays: %d\n", n);
719  for (i = 0; i < n; ++i) {
720  fprintf(stderr, "Display %d: %s\n", i, SDL_GetDisplayName(i));
721 
722  SDL_zero(bounds);
723  SDL_GetDisplayBounds(i, &bounds);
724  fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
725 
726  SDL_GetDesktopDisplayMode(i, &mode);
727  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
728  &Bmask, &Amask);
729  fprintf(stderr,
730  " Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
731  mode.w, mode.h, mode.refresh_rate, bpp,
733  if (Rmask || Gmask || Bmask) {
734  fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask);
735  fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask);
736  fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask);
737  if (Amask)
738  fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask);
739  }
740 
741  /* Print available fullscreen video modes */
742  m = SDL_GetNumDisplayModes(i);
743  if (m == 0) {
744  fprintf(stderr, "No available fullscreen video modes\n");
745  } else {
746  fprintf(stderr, " Fullscreen video modes:\n");
747  for (j = 0; j < m; ++j) {
748  SDL_GetDisplayMode(i, j, &mode);
749  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
750  &Gmask, &Bmask, &Amask);
751  fprintf(stderr,
752  " Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
753  j, mode.w, mode.h, mode.refresh_rate, bpp,
755  if (Rmask || Gmask || Bmask) {
756  fprintf(stderr, " Red Mask = 0x%.8x\n",
757  Rmask);
758  fprintf(stderr, " Green Mask = 0x%.8x\n",
759  Gmask);
760  fprintf(stderr, " Blue Mask = 0x%.8x\n",
761  Bmask);
762  if (Amask)
763  fprintf(stderr,
764  " Alpha Mask = 0x%.8x\n",
765  Amask);
766  }
767  }
768  }
769 
770 #if SDL_VIDEO_DRIVER_WINDOWS
771  /* Print the D3D9 adapter index */
772  adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
773  fprintf( stderr, "D3D9 Adapter Index: %d", adapterIndex );
774 
775  /* Print the DXGI adapter and output indices */
776  SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
777  fprintf( stderr, "DXGI Adapter Index: %d Output Index: %d", adapterIndex, outputIndex );
778 #endif
779  }
780  }
781 
782  if (state->verbose & VERBOSE_RENDER) {
783  SDL_RendererInfo info;
784 
786  if (n == 0) {
787  fprintf(stderr, "No built-in render drivers\n");
788  } else {
789  fprintf(stderr, "Built-in render drivers:\n");
790  for (i = 0; i < n; ++i) {
791  SDL_GetRenderDriverInfo(i, &info);
792  SDLTest_PrintRenderer(&info);
793  }
794  }
795  }
796 
797  SDL_zero(fullscreen_mode);
798  switch (state->depth) {
799  case 8:
800  fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
801  break;
802  case 15:
803  fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
804  break;
805  case 16:
806  fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
807  break;
808  case 24:
809  fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
810  break;
811  default:
812  fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
813  break;
814  }
815  fullscreen_mode.refresh_rate = state->refresh_rate;
816 
817  state->windows =
818  (SDL_Window **) SDL_malloc(state->num_windows *
819  sizeof(*state->windows));
820  state->renderers =
821  (SDL_Renderer **) SDL_malloc(state->num_windows *
822  sizeof(*state->renderers));
823  state->targets =
824  (SDL_Texture **) SDL_malloc(state->num_windows *
825  sizeof(*state->targets));
826  if (!state->windows || !state->renderers) {
827  fprintf(stderr, "Out of memory!\n");
828  return SDL_FALSE;
829  }
830  for (i = 0; i < state->num_windows; ++i) {
831  char title[1024];
832 
833  if (state->num_windows > 1) {
834  SDL_snprintf(title, SDL_arraysize(title), "%s %d",
835  state->window_title, i + 1);
836  } else {
837  SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
838  }
839  state->windows[i] =
840  SDL_CreateWindow(title, state->window_x, state->window_y,
841  state->window_w, state->window_h,
842  state->window_flags);
843  if (!state->windows[i]) {
844  fprintf(stderr, "Couldn't create window: %s\n",
845  SDL_GetError());
846  return SDL_FALSE;
847  }
848  if (state->window_minW || state->window_minH) {
849  SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
850  }
851  if (state->window_maxW || state->window_maxH) {
852  SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
853  }
854  SDL_GetWindowSize(state->windows[i], &w, &h);
855  if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
856  (w != state->window_w || h != state->window_h)) {
857  printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
858  state->window_w = w;
859  state->window_h = h;
860  }
861  if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
862  fprintf(stderr, "Can't set up fullscreen display mode: %s\n",
863  SDL_GetError());
864  return SDL_FALSE;
865  }
866 
867  if (state->window_icon) {
868  SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
869  if (icon) {
870  SDL_SetWindowIcon(state->windows[i], icon);
871  SDL_FreeSurface(icon);
872  }
873  }
874 
875  SDL_ShowWindow(state->windows[i]);
876 
877  state->renderers[i] = NULL;
878  state->targets[i] = NULL;
879 
880  if (!state->skip_renderer
881  && (state->renderdriver
882  || !(state->window_flags & SDL_WINDOW_OPENGL))) {
883  m = -1;
884  if (state->renderdriver) {
885  SDL_RendererInfo info;
887  for (j = 0; j < n; ++j) {
888  SDL_GetRenderDriverInfo(j, &info);
889  if (SDL_strcasecmp(info.name, state->renderdriver) ==
890  0) {
891  m = j;
892  break;
893  }
894  }
895  if (m == -1) {
896  fprintf(stderr,
897  "Couldn't find render driver named %s",
898  state->renderdriver);
899  return SDL_FALSE;
900  }
901  }
902  state->renderers[i] = SDL_CreateRenderer(state->windows[i],
903  m, state->render_flags);
904  if (!state->renderers[i]) {
905  fprintf(stderr, "Couldn't create renderer: %s\n",
906  SDL_GetError());
907  return SDL_FALSE;
908  }
909  if (state->logical_w && state->logical_h) {
910  SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
911  } else if (state->scale) {
912  SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
913  }
914  if (state->verbose & VERBOSE_RENDER) {
915  SDL_RendererInfo info;
916 
917  fprintf(stderr, "Current renderer:\n");
918  SDL_GetRendererInfo(state->renderers[i], &info);
919  SDLTest_PrintRenderer(&info);
920  }
921  }
922  }
923  }
924 
925  if (state->flags & SDL_INIT_AUDIO) {
926  if (state->verbose & VERBOSE_AUDIO) {
928  if (n == 0) {
929  fprintf(stderr, "No built-in audio drivers\n");
930  } else {
931  fprintf(stderr, "Built-in audio drivers:");
932  for (i = 0; i < n; ++i) {
933  if (i > 0) {
934  fprintf(stderr, ",");
935  }
936  fprintf(stderr, " %s", SDL_GetAudioDriver(i));
937  }
938  fprintf(stderr, "\n");
939  }
940  }
941  if (SDL_AudioInit(state->audiodriver) < 0) {
942  fprintf(stderr, "Couldn't initialize audio driver: %s\n",
943  SDL_GetError());
944  return SDL_FALSE;
945  }
946  if (state->verbose & VERBOSE_VIDEO) {
947  fprintf(stderr, "Audio driver: %s\n",
949  }
950 
951  if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
952  fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
953  return SDL_FALSE;
954  }
955  }
956 
957  return SDL_TRUE;
958 }
#define SDL_GetNumAudioDrivers
#define SDL_strlcpy
#define SDL_SetWindowMaximumSize
#define SDL_ShowWindow
SDL_Texture ** targets
#define SDL_GetError
#define SDL_GetNumVideoDrivers
#define SDL_SetWindowDisplayMode
#define SDL_OpenAudio
static SDL_Surface * SDLTest_LoadIcon(const char *file)
GLdouble n
#define SDL_GetDisplayMode
SDL_bool SDL_DXGIGetOutputInfo(int displayIndex, int *adapterIndex, int *outputIndex)
Returns the DXGI Adapter and Output indices for the specified display index.
#define SDL_SetWindowMinimumSize
#define SDL_AudioInit
const GLfloat * m
#define SDL_GetNumRenderDrivers
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_GetDesktopDisplayMode
#define SDL_GetDisplayName
const char * window_icon
The structure that defines a display mode.
Definition: SDL_video.h:53
#define SDL_CreateWindow
const char * renderdriver
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:159
#define SDL_strcasecmp
const char * name
Definition: SDL_render.h:80
#define SDL_GetRenderDriverInfo
SDL_AudioSpec audiospec
SDL_Window ** windows
#define SDL_SetWindowIcon
#define SDL_GetNumVideoDisplays
int SDL_Direct3D9GetAdapterIndex(int displayIndex)
Returns the D3D9 adapter index that matches the specified display index.
#define VERBOSE_AUDIO
#define SDL_GL_SetAttribute
#define SDL_GetWindowSize
#define SDL_VideoInit
static void SDLTest_PrintRenderer(SDL_RendererInfo *info)
#define SDL_FreeSurface
#define SDL_RenderSetLogicalSize
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int int in j)
Definition: SDL_x11sym.h:50
GLenum mode
#define SDL_GetDisplayBounds
#define SDL_zero(x)
Definition: SDL_stdinc.h:359
#define SDL_GetAudioDriver
#define SDL_PixelFormatEnumToMasks
int x
Definition: SDL_rect.h:66
int w
Definition: SDL_rect.h:67
#define SDL_RenderSetScale
SDL_Renderer ** renderers
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define SDL_GetCurrentAudioDriver
#define NULL
Definition: begin_code.h:143
#define SDL_GetCurrentVideoDriver
#define VERBOSE_MODES
Information on the capabilities of a render driver or context.
Definition: SDL_render.h:78
#define SDL_GetVideoDriver
#define VERBOSE_RENDER
const char * audiodriver
#define SDL_INIT_AUDIO
Definition: SDL.h:76
int h
Definition: SDL_rect.h:67
The type used to identify a window.
Definition: SDL_sysvideo.h:71
#define SDL_snprintf
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:90
#define SDL_malloc
#define SDL_GetNumDisplayModes
GLubyte GLubyte GLubyte GLubyte w
Uint32 format
Definition: SDL_video.h:55
#define VERBOSE_VIDEO
int y
Definition: SDL_rect.h:66
const char * videodriver
GLfloat GLfloat GLfloat GLfloat h
#define SDL_INIT_VIDEO
Definition: SDL.h:77
#define SDL_CreateRenderer
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
#define SDL_GetRendererInfo
const char * window_title
#define SDL_GetPixelFormatName

§ SDLTest_CommonQuit()

void SDLTest_CommonQuit ( SDLTest_CommonState state)

Close test window.

Parameters
stateThe common state used to create test window.

Definition at line 1584 of file SDL_test_common.c.

References SDLTest_CommonState::flags, i, SDLTest_CommonState::num_windows, SDLTest_CommonState::renderers, SDL_AudioQuit, SDL_DestroyRenderer, SDL_DestroyTexture, SDL_free(), SDL_INIT_AUDIO, SDL_INIT_VIDEO, SDL_Quit, SDL_VideoQuit, SDLTest_CommonState::targets, and SDLTest_CommonState::windows.

Referenced by main(), and quit().

1585 {
1586  int i;
1587 
1588  SDL_free(state->windows);
1589  if (state->targets) {
1590  for (i = 0; i < state->num_windows; ++i) {
1591  if (state->targets[i]) {
1592  SDL_DestroyTexture(state->targets[i]);
1593  }
1594  }
1595  SDL_free(state->targets);
1596  }
1597  if (state->renderers) {
1598  for (i = 0; i < state->num_windows; ++i) {
1599  if (state->renderers[i]) {
1600  SDL_DestroyRenderer(state->renderers[i]);
1601  }
1602  }
1603  SDL_free(state->renderers);
1604  }
1605  if (state->flags & SDL_INIT_VIDEO) {
1606  SDL_VideoQuit();
1607  }
1608  if (state->flags & SDL_INIT_AUDIO) {
1609  SDL_AudioQuit();
1610  }
1611  SDL_free(state);
1612  SDL_Quit();
1613 }
SDL_Texture ** targets
#define SDL_AudioQuit
SDL_Window ** windows
void SDL_free(void *mem)
#define SDL_Quit
SDL_Renderer ** renderers
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define SDL_INIT_AUDIO
Definition: SDL.h:76
#define SDL_DestroyTexture
#define SDL_VideoQuit
#define SDL_DestroyRenderer
#define SDL_INIT_VIDEO
Definition: SDL.h:77

§ SDLTest_CommonUsage()

const char* SDLTest_CommonUsage ( SDLTest_CommonState state)

Returns common usage information.

Parameters
stateThe common state describing the test window to create.
Returns
String with usage information

Definition at line 451 of file SDL_test_common.c.

References AUDIO_USAGE, SDLTest_CommonState::flags, SDL_INIT_AUDIO, SDL_INIT_VIDEO, and VIDEO_USAGE.

Referenced by main().

452 {
453  switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
454  case SDL_INIT_VIDEO:
455  return VIDEO_USAGE;
456  case SDL_INIT_AUDIO:
457  return AUDIO_USAGE;
459  return VIDEO_USAGE " " AUDIO_USAGE;
460  default:
461  return "";
462  }
463 }
#define AUDIO_USAGE
#define VIDEO_USAGE
#define SDL_INIT_AUDIO
Definition: SDL.h:76
#define SDL_INIT_VIDEO
Definition: SDL.h:77