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

#define DEFAULT_WINDOW_HEIGHT   480

Definition at line 42 of file SDL_test_common.h.

Referenced by main(), and SDLTest_CommonCreateState().

#define DEFAULT_WINDOW_WIDTH   640

Definition at line 41 of file SDL_test_common.h.

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

#define VERBOSE_AUDIO   0x00000010

Definition at line 49 of file SDL_test_common.h.

Referenced by SDLTest_CommonInit().

#define VERBOSE_EVENT   0x00000008

Definition at line 48 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonEvent().

#define VERBOSE_MODES   0x00000002

Definition at line 46 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonInit().

#define VERBOSE_RENDER   0x00000004

Definition at line 47 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonInit().

#define VERBOSE_VIDEO   0x00000001

Definition at line 45 of file SDL_test_common.h.

Referenced by SDLTest_CommonArg(), and SDLTest_CommonInit().

Function Documentation

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:121
#define SDL_WINDOWPOS_CENTERED
Definition: SDL_video.h:129
#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:130
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:119
#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:139
#define SDL_atoi
GLuint index
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X)
Definition: SDL_video.h:128
#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:147
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_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:120
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
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 1295 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_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_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_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().

1296 {
1297  int i;
1298  static SDL_MouseMotionEvent lastEvent;
1299 
1300  if (state->verbose & VERBOSE_EVENT) {
1301  SDLTest_PrintEvent(event);
1302  }
1303 
1304  switch (event->type) {
1305  case SDL_WINDOWEVENT:
1306  switch (event->window.event) {
1307  case SDL_WINDOWEVENT_CLOSE:
1308  {
1310  if (window) {
1311  for (i = 0; i < state->num_windows; ++i) {
1312  if (window == state->windows[i]) {
1313  if (state->targets[i]) {
1314  SDL_DestroyTexture(state->targets[i]);
1315  state->targets[i] = NULL;
1316  }
1317  if (state->renderers[i]) {
1318  SDL_DestroyRenderer(state->renderers[i]);
1319  state->renderers[i] = NULL;
1320  }
1321  SDL_DestroyWindow(state->windows[i]);
1322  state->windows[i] = NULL;
1323  break;
1324  }
1325  }
1326  }
1327  }
1328  break;
1329  }
1330  break;
1331  case SDL_KEYDOWN: {
1332  SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
1333  SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
1334  SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
1335 
1336  switch (event->key.keysym.sym) {
1337  /* Add hotkeys here */
1338  case SDLK_PRINTSCREEN: {
1339  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1340  if (window) {
1341  for (i = 0; i < state->num_windows; ++i) {
1342  if (window == state->windows[i]) {
1343  SDLTest_ScreenShot(state->renderers[i]);
1344  }
1345  }
1346  }
1347  }
1348  break;
1349  case SDLK_EQUALS:
1350  if (withControl) {
1351  /* Ctrl-+ double the size of the window */
1352  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1353  if (window) {
1354  int w, h;
1355  SDL_GetWindowSize(window, &w, &h);
1356  SDL_SetWindowSize(window, w*2, h*2);
1357  }
1358  }
1359  break;
1360  case SDLK_MINUS:
1361  if (withControl) {
1362  /* Ctrl-- half the size of the window */
1363  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1364  if (window) {
1365  int w, h;
1366  SDL_GetWindowSize(window, &w, &h);
1367  SDL_SetWindowSize(window, w/2, h/2);
1368  }
1369  }
1370  break;
1371  case SDLK_c:
1372  if (withControl) {
1373  /* Ctrl-C copy awesome text! */
1374  SDL_SetClipboardText("SDL rocks!\nYou know it!");
1375  printf("Copied text to clipboard\n");
1376  }
1377  if (withAlt) {
1378  /* Alt-C toggle a render clip rectangle */
1379  for (i = 0; i < state->num_windows; ++i) {
1380  int w, h;
1381  if (state->renderers[i]) {
1382  SDL_Rect clip;
1383  SDL_GetWindowSize(state->windows[i], &w, &h);
1384  SDL_RenderGetClipRect(state->renderers[i], &clip);
1385  if (SDL_RectEmpty(&clip)) {
1386  clip.x = w/4;
1387  clip.y = h/4;
1388  clip.w = w/2;
1389  clip.h = h/2;
1390  SDL_RenderSetClipRect(state->renderers[i], &clip);
1391  } else {
1392  SDL_RenderSetClipRect(state->renderers[i], NULL);
1393  }
1394  }
1395  }
1396  }
1397  if (withShift) {
1398  SDL_Window *current_win = SDL_GetKeyboardFocus();
1399  if (current_win) {
1400  const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
1401  const int rc = SDL_CaptureMouse(shouldCapture);
1402  SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
1403  }
1404  }
1405  break;
1406  case SDLK_v:
1407  if (withControl) {
1408  /* Ctrl-V paste awesome text! */
1409  char *text = SDL_GetClipboardText();
1410  if (*text) {
1411  printf("Clipboard: %s\n", text);
1412  } else {
1413  printf("Clipboard is empty\n");
1414  }
1415  SDL_free(text);
1416  }
1417  break;
1418  case SDLK_g:
1419  if (withControl) {
1420  /* Ctrl-G toggle grab */
1421  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1422  if (window) {
1423  SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
1424  }
1425  }
1426  break;
1427  case SDLK_m:
1428  if (withControl) {
1429  /* Ctrl-M maximize */
1430  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1431  if (window) {
1432  Uint32 flags = SDL_GetWindowFlags(window);
1433  if (flags & SDL_WINDOW_MAXIMIZED) {
1434  SDL_RestoreWindow(window);
1435  } else {
1436  SDL_MaximizeWindow(window);
1437  }
1438  }
1439  }
1440  break;
1441  case SDLK_r:
1442  if (withControl) {
1443  /* Ctrl-R toggle mouse relative mode */
1445  }
1446  break;
1447  case SDLK_z:
1448  if (withControl) {
1449  /* Ctrl-Z minimize */
1450  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1451  if (window) {
1452  SDL_MinimizeWindow(window);
1453  }
1454  }
1455  break;
1456  case SDLK_RETURN:
1457  if (withControl) {
1458  /* Ctrl-Enter toggle fullscreen */
1459  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1460  if (window) {
1461  Uint32 flags = SDL_GetWindowFlags(window);
1462  if (flags & SDL_WINDOW_FULLSCREEN) {
1464  } else {
1465  SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
1466  }
1467  }
1468  } else if (withAlt) {
1469  /* Alt-Enter toggle fullscreen desktop */
1470  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1471  if (window) {
1472  Uint32 flags = SDL_GetWindowFlags(window);
1473  if (flags & SDL_WINDOW_FULLSCREEN) {
1475  } else {
1477  }
1478  }
1479  } else if (withShift) {
1480  /* Shift-Enter toggle fullscreen desktop / fullscreen */
1481  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1482  if (window) {
1483  Uint32 flags = SDL_GetWindowFlags(window);
1484  if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
1486  } else {
1487  SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1488  }
1489  }
1490  }
1491 
1492  break;
1493  case SDLK_b:
1494  if (withControl) {
1495  /* Ctrl-B toggle window border */
1496  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1497  if (window) {
1498  const Uint32 flags = SDL_GetWindowFlags(window);
1499  const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
1500  SDL_SetWindowBordered(window, b);
1501  }
1502  }
1503  break;
1504  case SDLK_a:
1505  if (withControl) {
1506  /* Ctrl-A reports absolute mouse position. */
1507  int x, y;
1508  const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
1509  SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
1510  (mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
1511  (mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
1512  (mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
1513  (mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
1514  (mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
1515  }
1516  break;
1517  case SDLK_0:
1518  if (withControl) {
1519  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1520  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
1521  }
1522  break;
1523  case SDLK_1:
1524  if (withControl) {
1525  FullscreenTo(0, event->key.windowID);
1526  }
1527  break;
1528  case SDLK_2:
1529  if (withControl) {
1530  FullscreenTo(1, event->key.windowID);
1531  }
1532  break;
1533  case SDLK_ESCAPE:
1534  *done = 1;
1535  break;
1536  case SDLK_SPACE:
1537  {
1538  char message[256];
1539  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1540 
1541  SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
1542  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
1543  break;
1544  }
1545  default:
1546  break;
1547  }
1548  break;
1549  }
1550  case SDL_QUIT:
1551  *done = 1;
1552  break;
1553  case SDL_MOUSEMOTION:
1554  lastEvent = event->motion;
1555  break;
1556  }
1557 }
SDL_Texture ** targets
#define SDL_RenderGetClipRect
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
#define SDL_SetWindowFullscreen
#define SDL_BUTTON_RMASK
Definition: SDL_mouse.h:287
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:289
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
#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_bool
Definition: SDL_stdinc.h:126
SDL_WindowEvent window
Definition: SDL_events.h:525
#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_BUTTON_X1MASK
Definition: SDL_mouse.h:288
#define SDL_BUTTON_LMASK
Definition: SDL_mouse.h:285
int x
Definition: SDL_rect.h:66
SDL_Keysym keysym
Definition: SDL_events.h:196
#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:42
#define NULL
Definition: begin_code.h:143
#define SDL_SetWindowBordered
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:34
Mouse motion event structure (event.motion.*)
Definition: SDL_events.h:229
SDL_KeyboardEvent key
Definition: SDL_events.h:526
#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:286
#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:523
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
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
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
#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
GLenum mode
#define SDL_GetDisplayBounds
#define SDL_zero(x)
Definition: SDL_stdinc.h:355
#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:42
#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:93
#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
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:42
const char * window_title
#define SDL_GetPixelFormatName
void SDLTest_CommonQuit ( SDLTest_CommonState state)

Close test window.

Parameters
stateThe common state used to create test window.

Definition at line 1560 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().

1561 {
1562  int i;
1563 
1564  SDL_free(state->windows);
1565  if (state->targets) {
1566  for (i = 0; i < state->num_windows; ++i) {
1567  if (state->targets[i]) {
1568  SDL_DestroyTexture(state->targets[i]);
1569  }
1570  }
1571  SDL_free(state->targets);
1572  }
1573  if (state->renderers) {
1574  for (i = 0; i < state->num_windows; ++i) {
1575  if (state->renderers[i]) {
1576  SDL_DestroyRenderer(state->renderers[i]);
1577  }
1578  }
1579  SDL_free(state->renderers);
1580  }
1581  if (state->flags & SDL_INIT_VIDEO) {
1582  SDL_VideoQuit();
1583  }
1584  if (state->flags & SDL_INIT_AUDIO) {
1585  SDL_AudioQuit();
1586  }
1587  SDL_free(state);
1588  SDL_Quit();
1589 }
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:42
#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
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