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...
 
void SDLTest_CommonLogUsage (SDLTest_CommonState *state, const char *argv0, const char **options)
 Logs command line usage info. More...
 
SDL_bool SDLTest_CommonInit (SDLTest_CommonState *state)
 Open test window. More...
 
SDL_bool SDLTest_CommonDefaultArgs (SDLTest_CommonState *state, const int argc, char **argv)
 Easy argument handling when test app doesn't need any custom args. 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.

◆ DEFAULT_WINDOW_WIDTH

#define DEFAULT_WINDOW_WIDTH   640

Definition at line 41 of file SDL_test_common.h.

◆ VERBOSE_AUDIO

#define VERBOSE_AUDIO   0x00000010

Definition at line 49 of file SDL_test_common.h.

◆ VERBOSE_EVENT

#define VERBOSE_EVENT   0x00000008

Definition at line 48 of file SDL_test_common.h.

◆ VERBOSE_MODES

#define VERBOSE_MODES   0x00000002

Definition at line 46 of file SDL_test_common.h.

◆ VERBOSE_RENDER

#define VERBOSE_RENDER   0x00000004

Definition at line 47 of file SDL_test_common.h.

◆ VERBOSE_VIDEO

#define VERBOSE_VIDEO   0x00000001

Definition at line 45 of file SDL_test_common.h.

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 117 of file SDL_test_common.c.

118 {
119  char **argv = state->argv;
120 
121  if (SDL_strcasecmp(argv[index], "--video") == 0) {
122  ++index;
123  if (!argv[index]) {
124  return -1;
125  }
126  state->videodriver = argv[index];
127  return 2;
128  }
129  if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
130  ++index;
131  if (!argv[index]) {
132  return -1;
133  }
134  state->renderdriver = argv[index];
135  return 2;
136  }
137  if (SDL_strcasecmp(argv[index], "--gldebug") == 0) {
138  state->gl_debug = 1;
139  return 1;
140  }
141  if (SDL_strcasecmp(argv[index], "--info") == 0) {
142  ++index;
143  if (!argv[index]) {
144  return -1;
145  }
146  if (SDL_strcasecmp(argv[index], "all") == 0) {
147  state->verbose |=
149  VERBOSE_EVENT);
150  return 2;
151  }
152  if (SDL_strcasecmp(argv[index], "video") == 0) {
153  state->verbose |= VERBOSE_VIDEO;
154  return 2;
155  }
156  if (SDL_strcasecmp(argv[index], "modes") == 0) {
157  state->verbose |= VERBOSE_MODES;
158  return 2;
159  }
160  if (SDL_strcasecmp(argv[index], "render") == 0) {
161  state->verbose |= VERBOSE_RENDER;
162  return 2;
163  }
164  if (SDL_strcasecmp(argv[index], "event") == 0) {
165  state->verbose |= VERBOSE_EVENT;
166  return 2;
167  }
168  return -1;
169  }
170  if (SDL_strcasecmp(argv[index], "--log") == 0) {
171  ++index;
172  if (!argv[index]) {
173  return -1;
174  }
175  if (SDL_strcasecmp(argv[index], "all") == 0) {
177  return 2;
178  }
179  if (SDL_strcasecmp(argv[index], "error") == 0) {
181  return 2;
182  }
183  if (SDL_strcasecmp(argv[index], "system") == 0) {
185  return 2;
186  }
187  if (SDL_strcasecmp(argv[index], "audio") == 0) {
189  return 2;
190  }
191  if (SDL_strcasecmp(argv[index], "video") == 0) {
193  return 2;
194  }
195  if (SDL_strcasecmp(argv[index], "render") == 0) {
197  return 2;
198  }
199  if (SDL_strcasecmp(argv[index], "input") == 0) {
201  return 2;
202  }
203  return -1;
204  }
205  if (SDL_strcasecmp(argv[index], "--display") == 0) {
206  ++index;
207  if (!argv[index]) {
208  return -1;
209  }
210  state->display = SDL_atoi(argv[index]);
211  if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) {
212  state->window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
213  state->window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
214  }
215  if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) {
216  state->window_x = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
217  state->window_y = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
218  }
219  return 2;
220  }
221  if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
222  state->window_flags |= SDL_WINDOW_FULLSCREEN;
223  state->num_windows = 1;
224  return 1;
225  }
226  if (SDL_strcasecmp(argv[index], "--fullscreen-desktop") == 0) {
227  state->window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
228  state->num_windows = 1;
229  return 1;
230  }
231  if (SDL_strcasecmp(argv[index], "--allow-highdpi") == 0) {
232  state->window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
233  return 1;
234  }
235  if (SDL_strcasecmp(argv[index], "--windows") == 0) {
236  ++index;
237  if (!argv[index] || !SDL_isdigit(*argv[index])) {
238  return -1;
239  }
240  if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
241  state->num_windows = SDL_atoi(argv[index]);
242  }
243  return 2;
244  }
245  if (SDL_strcasecmp(argv[index], "--title") == 0) {
246  ++index;
247  if (!argv[index]) {
248  return -1;
249  }
250  state->window_title = argv[index];
251  return 2;
252  }
253  if (SDL_strcasecmp(argv[index], "--icon") == 0) {
254  ++index;
255  if (!argv[index]) {
256  return -1;
257  }
258  state->window_icon = argv[index];
259  return 2;
260  }
261  if (SDL_strcasecmp(argv[index], "--center") == 0) {
262  state->window_x = SDL_WINDOWPOS_CENTERED;
263  state->window_y = SDL_WINDOWPOS_CENTERED;
264  return 1;
265  }
266  if (SDL_strcasecmp(argv[index], "--position") == 0) {
267  char *x, *y;
268  ++index;
269  if (!argv[index]) {
270  return -1;
271  }
272  x = argv[index];
273  y = argv[index];
274  while (*y && *y != ',') {
275  ++y;
276  }
277  if (!*y) {
278  return -1;
279  }
280  *y++ = '\0';
281  state->window_x = SDL_atoi(x);
282  state->window_y = SDL_atoi(y);
283  return 2;
284  }
285  if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
286  char *w, *h;
287  ++index;
288  if (!argv[index]) {
289  return -1;
290  }
291  w = argv[index];
292  h = argv[index];
293  while (*h && *h != 'x') {
294  ++h;
295  }
296  if (!*h) {
297  return -1;
298  }
299  *h++ = '\0';
300  state->window_w = SDL_atoi(w);
301  state->window_h = SDL_atoi(h);
302  return 2;
303  }
304  if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) {
305  char *w, *h;
306  ++index;
307  if (!argv[index]) {
308  return -1;
309  }
310  w = argv[index];
311  h = argv[index];
312  while (*h && *h != 'x') {
313  ++h;
314  }
315  if (!*h) {
316  return -1;
317  }
318  *h++ = '\0';
319  state->window_minW = SDL_atoi(w);
320  state->window_minH = SDL_atoi(h);
321  return 2;
322  }
323  if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) {
324  char *w, *h;
325  ++index;
326  if (!argv[index]) {
327  return -1;
328  }
329  w = argv[index];
330  h = argv[index];
331  while (*h && *h != 'x') {
332  ++h;
333  }
334  if (!*h) {
335  return -1;
336  }
337  *h++ = '\0';
338  state->window_maxW = SDL_atoi(w);
339  state->window_maxH = SDL_atoi(h);
340  return 2;
341  }
342  if (SDL_strcasecmp(argv[index], "--logical") == 0) {
343  char *w, *h;
344  ++index;
345  if (!argv[index]) {
346  return -1;
347  }
348  w = argv[index];
349  h = argv[index];
350  while (*h && *h != 'x') {
351  ++h;
352  }
353  if (!*h) {
354  return -1;
355  }
356  *h++ = '\0';
357  state->logical_w = SDL_atoi(w);
358  state->logical_h = SDL_atoi(h);
359  return 2;
360  }
361  if (SDL_strcasecmp(argv[index], "--scale") == 0) {
362  ++index;
363  if (!argv[index]) {
364  return -1;
365  }
366  state->scale = (float)SDL_atof(argv[index]);
367  return 2;
368  }
369  if (SDL_strcasecmp(argv[index], "--depth") == 0) {
370  ++index;
371  if (!argv[index]) {
372  return -1;
373  }
374  state->depth = SDL_atoi(argv[index]);
375  return 2;
376  }
377  if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
378  ++index;
379  if (!argv[index]) {
380  return -1;
381  }
382  state->refresh_rate = SDL_atoi(argv[index]);
383  return 2;
384  }
385  if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
386  state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
387  return 1;
388  }
389  if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
390  state->window_flags |= SDL_WINDOW_BORDERLESS;
391  return 1;
392  }
393  if (SDL_strcasecmp(argv[index], "--resize") == 0) {
394  state->window_flags |= SDL_WINDOW_RESIZABLE;
395  return 1;
396  }
397  if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
398  state->window_flags |= SDL_WINDOW_MINIMIZED;
399  return 1;
400  }
401  if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
402  state->window_flags |= SDL_WINDOW_MAXIMIZED;
403  return 1;
404  }
405  if (SDL_strcasecmp(argv[index], "--grab") == 0) {
406  state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
407  return 1;
408  }
409  if (SDL_strcasecmp(argv[index], "--rate") == 0) {
410  ++index;
411  if (!argv[index]) {
412  return -1;
413  }
414  state->audiospec.freq = SDL_atoi(argv[index]);
415  return 2;
416  }
417  if (SDL_strcasecmp(argv[index], "--format") == 0) {
418  ++index;
419  if (!argv[index]) {
420  return -1;
421  }
422  if (SDL_strcasecmp(argv[index], "U8") == 0) {
423  state->audiospec.format = AUDIO_U8;
424  return 2;
425  }
426  if (SDL_strcasecmp(argv[index], "S8") == 0) {
427  state->audiospec.format = AUDIO_S8;
428  return 2;
429  }
430  if (SDL_strcasecmp(argv[index], "U16") == 0) {
431  state->audiospec.format = AUDIO_U16;
432  return 2;
433  }
434  if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
435  state->audiospec.format = AUDIO_U16LSB;
436  return 2;
437  }
438  if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
439  state->audiospec.format = AUDIO_U16MSB;
440  return 2;
441  }
442  if (SDL_strcasecmp(argv[index], "S16") == 0) {
443  state->audiospec.format = AUDIO_S16;
444  return 2;
445  }
446  if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
447  state->audiospec.format = AUDIO_S16LSB;
448  return 2;
449  }
450  if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
451  state->audiospec.format = AUDIO_S16MSB;
452  return 2;
453  }
454  return -1;
455  }
456  if (SDL_strcasecmp(argv[index], "--channels") == 0) {
457  ++index;
458  if (!argv[index]) {
459  return -1;
460  }
461  state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
462  return 2;
463  }
464  if (SDL_strcasecmp(argv[index], "--samples") == 0) {
465  ++index;
466  if (!argv[index]) {
467  return -1;
468  }
469  state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
470  return 2;
471  }
472  if (SDL_strcasecmp(argv[index], "--trackmem") == 0) {
473  /* Already handled in SDLTest_CommonCreateState() */
474  return 1;
475  }
476  if ((SDL_strcasecmp(argv[index], "-h") == 0)
477  || (SDL_strcasecmp(argv[index], "--help") == 0)) {
478  /* Print the usage message */
479  return -1;
480  }
481  if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) {
482  /* Debug flag sent by Xcode */
483  return 2;
484  }
485  return 0;
486 }

References AUDIO_S16, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S8, AUDIO_U16, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, 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, state, VERBOSE_EVENT, VERBOSE_MODES, VERBOSE_RENDER, and VERBOSE_VIDEO.

Referenced by main(), and SDLTest_CommonDefaultArgs().

◆ 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 59 of file SDL_test_common.c.

60 {
61  int i;
63 
64  /* Do this first so we catch all allocations */
65  for (i = 1; argv[i]; ++i) {
66  if (SDL_strcasecmp(argv[i], "--trackmem") == 0) {
68  break;
69  }
70  }
71 
72  state = (SDLTest_CommonState *)SDL_calloc(1, sizeof(*state));
73  if (!state) {
75  return NULL;
76  }
77 
78  /* Initialize some defaults */
79  state->argv = argv;
80  state->flags = flags;
81  state->window_title = argv[0];
82  state->window_flags = 0;
83  state->window_x = SDL_WINDOWPOS_UNDEFINED;
84  state->window_y = SDL_WINDOWPOS_UNDEFINED;
85  state->window_w = DEFAULT_WINDOW_WIDTH;
86  state->window_h = DEFAULT_WINDOW_HEIGHT;
87  state->num_windows = 1;
88  state->audiospec.freq = 22050;
89  state->audiospec.format = AUDIO_S16;
90  state->audiospec.channels = 2;
91  state->audiospec.samples = 2048;
92 
93  /* Set some very sane GL defaults */
94  state->gl_red_size = 3;
95  state->gl_green_size = 3;
96  state->gl_blue_size = 2;
97  state->gl_alpha_size = 0;
98  state->gl_buffer_size = 0;
99  state->gl_depth_size = 16;
100  state->gl_stencil_size = 0;
101  state->gl_double_buffer = 1;
102  state->gl_accum_red_size = 0;
103  state->gl_accum_green_size = 0;
104  state->gl_accum_blue_size = 0;
105  state->gl_accum_alpha_size = 0;
106  state->gl_stereo = 0;
107  state->gl_multisamplebuffers = 0;
108  state->gl_multisamplesamples = 0;
109  state->gl_retained_backing = 1;
110  state->gl_accelerated = -1;
111  state->gl_debug = 0;
112 
113  return state;
114 }

References AUDIO_S16, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH, i, NULL, SDL_calloc, SDL_OutOfMemory, SDL_strcasecmp, SDL_WINDOWPOS_UNDEFINED, SDLTest_TrackAllocations(), and state.

Referenced by main().

◆ SDLTest_CommonDefaultArgs()

SDL_bool SDLTest_CommonDefaultArgs ( SDLTest_CommonState state,
const int  argc,
char **  argv 
)

Easy argument handling when test app doesn't need any custom args.

Parameters
stateThe common state describing the test window to create.
argcargc, as supplied to SDL_main
argvargv, as supplied to SDL_main
Returns
False if app should quit, true otherwise.

Definition at line 516 of file SDL_test_common.c.

517 {
518  int i = 1;
519  while (i < argc) {
520  const int consumed = SDLTest_CommonArg(state, i);
521  if (consumed == 0) {
522  SDLTest_CommonLogUsage(state, argv[0], NULL);
523  return SDL_FALSE;
524  }
525  i += consumed;
526  }
527  return SDL_TRUE;
528 }

References i, NULL, SDL_FALSE, SDL_TRUE, SDLTest_CommonArg(), SDLTest_CommonLogUsage(), and state.

Referenced by main().

◆ 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 1501 of file SDL_test_common.c.

1502 {
1503  int i;
1504  static SDL_MouseMotionEvent lastEvent;
1505 
1506  if (state->verbose & VERBOSE_EVENT) {
1508  }
1509 
1510  switch (event->type) {
1511  case SDL_WINDOWEVENT:
1512  switch (event->window.event) {
1513  case SDL_WINDOWEVENT_CLOSE:
1514  {
1515  SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
1516  if (window) {
1517  for (i = 0; i < state->num_windows; ++i) {
1518  if (window == state->windows[i]) {
1519  if (state->targets[i]) {
1520  SDL_DestroyTexture(state->targets[i]);
1521  state->targets[i] = NULL;
1522  }
1523  if (state->renderers[i]) {
1524  SDL_DestroyRenderer(state->renderers[i]);
1525  state->renderers[i] = NULL;
1526  }
1527  SDL_DestroyWindow(state->windows[i]);
1528  state->windows[i] = NULL;
1529  break;
1530  }
1531  }
1532  }
1533  }
1534  break;
1535  }
1536  break;
1537  case SDL_KEYDOWN: {
1538  SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
1539  SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
1540  SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
1541 
1542  switch (event->key.keysym.sym) {
1543  /* Add hotkeys here */
1544  case SDLK_PRINTSCREEN: {
1545  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1546  if (window) {
1547  for (i = 0; i < state->num_windows; ++i) {
1548  if (window == state->windows[i]) {
1549  SDLTest_ScreenShot(state->renderers[i]);
1550  }
1551  }
1552  }
1553  }
1554  break;
1555  case SDLK_EQUALS:
1556  if (withControl) {
1557  /* Ctrl-+ double the size of the window */
1558  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1559  if (window) {
1560  int w, h;
1561  SDL_GetWindowSize(window, &w, &h);
1562  SDL_SetWindowSize(window, w*2, h*2);
1563  }
1564  }
1565  break;
1566  case SDLK_MINUS:
1567  if (withControl) {
1568  /* Ctrl-- half the size of the window */
1569  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1570  if (window) {
1571  int w, h;
1572  SDL_GetWindowSize(window, &w, &h);
1573  SDL_SetWindowSize(window, w/2, h/2);
1574  }
1575  }
1576  break;
1577  case SDLK_UP:
1578  case SDLK_DOWN:
1579  case SDLK_LEFT:
1580  case SDLK_RIGHT:
1581  if (withAlt) {
1582  /* Alt-Up/Down/Left/Right switches between displays */
1583  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1584  if (window) {
1585  int currentIndex = SDL_GetWindowDisplayIndex(window);
1586  int numDisplays = SDL_GetNumVideoDisplays();
1587 
1588  if (currentIndex >= 0 && numDisplays >= 1) {
1589  int dest;
1590  if (event->key.keysym.sym == SDLK_UP || event->key.keysym.sym == SDLK_LEFT) {
1591  dest = (currentIndex + numDisplays - 1) % numDisplays;
1592  } else {
1593  dest = (currentIndex + numDisplays + 1) % numDisplays;
1594  }
1595  SDL_Log("Centering on display %d\n", dest);
1599  }
1600  }
1601  }
1602  if (withShift) {
1603  /* Shift-Up/Down/Left/Right shift the window by 100px */
1604  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1605  if (window) {
1606  const int delta = 100;
1607  int x, y;
1609 
1610  if (event->key.keysym.sym == SDLK_UP) y -= delta;
1611  if (event->key.keysym.sym == SDLK_DOWN) y += delta;
1612  if (event->key.keysym.sym == SDLK_LEFT) x -= delta;
1613  if (event->key.keysym.sym == SDLK_RIGHT) x += delta;
1614 
1615  SDL_Log("Setting position to (%d, %d)\n", x, y);
1617  }
1618  }
1619  break;
1620  case SDLK_o:
1621  if (withControl) {
1622  /* Ctrl-O (or Ctrl-Shift-O) changes window opacity. */
1623  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1624  if (window) {
1625  float opacity;
1626  if (SDL_GetWindowOpacity(window, &opacity) == 0) {
1627  if (withShift) {
1628  opacity += 0.20f;
1629  } else {
1630  opacity -= 0.20f;
1631  }
1632  SDL_SetWindowOpacity(window, opacity);
1633  }
1634  }
1635  }
1636  break;
1637 
1638  case SDLK_c:
1639  if (withControl) {
1640  /* Ctrl-C copy awesome text! */
1641  SDL_SetClipboardText("SDL rocks!\nYou know it!");
1642  printf("Copied text to clipboard\n");
1643  }
1644  if (withAlt) {
1645  /* Alt-C toggle a render clip rectangle */
1646  for (i = 0; i < state->num_windows; ++i) {
1647  int w, h;
1648  if (state->renderers[i]) {
1649  SDL_Rect clip;
1650  SDL_GetWindowSize(state->windows[i], &w, &h);
1651  SDL_RenderGetClipRect(state->renderers[i], &clip);
1652  if (SDL_RectEmpty(&clip)) {
1653  clip.x = w/4;
1654  clip.y = h/4;
1655  clip.w = w/2;
1656  clip.h = h/2;
1657  SDL_RenderSetClipRect(state->renderers[i], &clip);
1658  } else {
1659  SDL_RenderSetClipRect(state->renderers[i], NULL);
1660  }
1661  }
1662  }
1663  }
1664  if (withShift) {
1665  SDL_Window *current_win = SDL_GetKeyboardFocus();
1666  if (current_win) {
1667  const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
1668  const int rc = SDL_CaptureMouse(shouldCapture);
1669  SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
1670  }
1671  }
1672  break;
1673  case SDLK_v:
1674  if (withControl) {
1675  /* Ctrl-V paste awesome text! */
1676  char *text = SDL_GetClipboardText();
1677  if (*text) {
1678  printf("Clipboard: %s\n", text);
1679  } else {
1680  printf("Clipboard is empty\n");
1681  }
1682  SDL_free(text);
1683  }
1684  break;
1685  case SDLK_g:
1686  if (withControl) {
1687  /* Ctrl-G toggle grab */
1688  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1689  if (window) {
1691  }
1692  }
1693  break;
1694  case SDLK_m:
1695  if (withControl) {
1696  /* Ctrl-M maximize */
1697  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1698  if (window) {
1700  if (flags & SDL_WINDOW_MAXIMIZED) {
1702  } else {
1704  }
1705  }
1706  }
1707  break;
1708  case SDLK_r:
1709  if (withControl) {
1710  /* Ctrl-R toggle mouse relative mode */
1712  }
1713  break;
1714  case SDLK_z:
1715  if (withControl) {
1716  /* Ctrl-Z minimize */
1717  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1718  if (window) {
1720  }
1721  }
1722  break;
1723  case SDLK_RETURN:
1724  if (withControl) {
1725  /* Ctrl-Enter toggle fullscreen */
1726  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1727  if (window) {
1729  if (flags & SDL_WINDOW_FULLSCREEN) {
1731  } else {
1733  }
1734  }
1735  } else if (withAlt) {
1736  /* Alt-Enter toggle fullscreen desktop */
1737  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1738  if (window) {
1740  if (flags & SDL_WINDOW_FULLSCREEN) {
1742  } else {
1744  }
1745  }
1746  } else if (withShift) {
1747  /* Shift-Enter toggle fullscreen desktop / fullscreen */
1748  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1749  if (window) {
1753  } else {
1755  }
1756  }
1757  }
1758 
1759  break;
1760  case SDLK_b:
1761  if (withControl) {
1762  /* Ctrl-B toggle window border */
1763  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1764  if (window) {
1766  const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
1768  }
1769  }
1770  break;
1771  case SDLK_a:
1772  if (withControl) {
1773  /* Ctrl-A reports absolute mouse position. */
1774  int x, y;
1775  const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
1776  SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
1777  (mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
1778  (mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
1779  (mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
1780  (mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
1781  (mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
1782  }
1783  break;
1784  case SDLK_0:
1785  if (withControl) {
1786  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1787  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
1788  }
1789  break;
1790  case SDLK_1:
1791  if (withControl) {
1792  FullscreenTo(0, event->key.windowID);
1793  }
1794  break;
1795  case SDLK_2:
1796  if (withControl) {
1797  FullscreenTo(1, event->key.windowID);
1798  }
1799  break;
1800  case SDLK_ESCAPE:
1801  *done = 1;
1802  break;
1803  case SDLK_SPACE:
1804  {
1805  char message[256];
1806  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1807 
1808  SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
1810  break;
1811  }
1812  default:
1813  break;
1814  }
1815  break;
1816  }
1817  case SDL_QUIT:
1818  *done = 1;
1819  break;
1820  case SDL_MOUSEMOTION:
1821  lastEvent = event->motion;
1822  break;
1823 
1824  case SDL_DROPFILE:
1825  case SDL_DROPTEXT:
1826  SDL_free(event->drop.file);
1827  break;
1828  }
1829 }

References done, FullscreenTo(), SDL_Rect::h, i, KMOD_ALT, KMOD_CTRL, KMOD_SHIFT, NULL, SDL_BUTTON_LMASK, SDL_BUTTON_MMASK, SDL_BUTTON_RMASK, SDL_BUTTON_X1MASK, SDL_BUTTON_X2MASK, SDL_CaptureMouse, SDL_DestroyRenderer, SDL_DestroyTexture, SDL_DestroyWindow, SDL_DROPFILE, SDL_DROPTEXT, SDL_FALSE, SDL_free, SDL_GetClipboardText, SDL_GetGlobalMouseState, SDL_GetKeyboardFocus, SDL_GetNumVideoDisplays, SDL_GetRelativeMouseMode, SDL_GetWindowDisplayIndex, SDL_GetWindowFlags, SDL_GetWindowFromID, SDL_GetWindowGrab, SDL_GetWindowOpacity, SDL_GetWindowPosition, 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_SetWindowPosition, 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, SDL_WINDOWPOS_CENTERED_DISPLAY, SDLK_0, SDLK_1, SDLK_2, SDLK_a, SDLK_b, SDLK_c, SDLK_DOWN, SDLK_EQUALS, SDLK_ESCAPE, SDLK_g, SDLK_LEFT, SDLK_m, SDLK_MINUS, SDLK_o, SDLK_PRINTSCREEN, SDLK_r, SDLK_RETURN, SDLK_RIGHT, SDLK_SPACE, SDLK_UP, SDLK_v, SDLK_z, SDLTest_PrintEvent(), SDLTest_ScreenShot(), state, text, VERBOSE_EVENT, SDL_Rect::w, SDL_Rect::x, SDL_MouseMotionEvent::x, SDL_MouseMotionEvent::xrel, SDL_Rect::y, SDL_MouseMotionEvent::y, and SDL_MouseMotionEvent::yrel.

Referenced by loop(), and main().

◆ 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 764 of file SDL_test_common.c.

765 {
766  int i, j, m, n, w, h;
767  SDL_DisplayMode fullscreen_mode;
768  char text[1024];
769 
770  if (state->flags & SDL_INIT_VIDEO) {
771  if (state->verbose & VERBOSE_VIDEO) {
773  if (n == 0) {
774  SDL_Log("No built-in video drivers\n");
775  } else {
776  SDL_snprintf(text, sizeof(text), "Built-in video drivers:");
777  for (i = 0; i < n; ++i) {
778  if (i > 0) {
779  SDL_snprintfcat(text, sizeof(text), ",");
780  }
781  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetVideoDriver(i));
782  }
783  SDL_Log("%s\n", text);
784  }
785  }
786  if (SDL_VideoInit(state->videodriver) < 0) {
787  SDL_Log("Couldn't initialize video driver: %s\n",
788  SDL_GetError());
789  return SDL_FALSE;
790  }
791  if (state->verbose & VERBOSE_VIDEO) {
792  SDL_Log("Video driver: %s\n",
794  }
795 
796  /* Upload GL settings */
801  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer);
802  SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size);
804  SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size);
805  SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size);
806  SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size);
807  SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size);
808  SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size);
810  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers);
811  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples);
812  if (state->gl_accelerated >= 0) {
814  state->gl_accelerated);
815  }
816  SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing);
817  if (state->gl_major_version) {
820  }
821  if (state->gl_debug) {
823  }
824  if (state->gl_profile_mask) {
826  }
827 
828  if (state->verbose & VERBOSE_MODES) {
829  SDL_Rect bounds, usablebounds;
830  float hdpi = 0;
831  float vdpi = 0;
833  int bpp;
834  Uint32 Rmask, Gmask, Bmask, Amask;
835 #if SDL_VIDEO_DRIVER_WINDOWS
836  int adapterIndex = 0;
837  int outputIndex = 0;
838 #endif
840  SDL_Log("Number of displays: %d\n", n);
841  for (i = 0; i < n; ++i) {
842  SDL_Log("Display %d: %s\n", i, SDL_GetDisplayName(i));
843 
844  SDL_zero(bounds);
845  SDL_GetDisplayBounds(i, &bounds);
846 
847  SDL_zero(usablebounds);
848  SDL_GetDisplayUsableBounds(i, &usablebounds);
849 
850  SDL_GetDisplayDPI(i, NULL, &hdpi, &vdpi);
851 
852  SDL_Log("Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
853  SDL_Log("Usable bounds: %dx%d at %d,%d\n", usablebounds.w, usablebounds.h, usablebounds.x, usablebounds.y);
854  SDL_Log("DPI: %fx%f\n", hdpi, vdpi);
855 
857  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
858  &Bmask, &Amask);
859  SDL_Log(" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
860  mode.w, mode.h, mode.refresh_rate, bpp,
861  SDL_GetPixelFormatName(mode.format));
862  if (Rmask || Gmask || Bmask) {
863  SDL_Log(" Red Mask = 0x%.8x\n", Rmask);
864  SDL_Log(" Green Mask = 0x%.8x\n", Gmask);
865  SDL_Log(" Blue Mask = 0x%.8x\n", Bmask);
866  if (Amask)
867  SDL_Log(" Alpha Mask = 0x%.8x\n", Amask);
868  }
869 
870  /* Print available fullscreen video modes */
872  if (m == 0) {
873  SDL_Log("No available fullscreen video modes\n");
874  } else {
875  SDL_Log(" Fullscreen video modes:\n");
876  for (j = 0; j < m; ++j) {
878  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
879  &Gmask, &Bmask, &Amask);
880  SDL_Log(" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
881  j, mode.w, mode.h, mode.refresh_rate, bpp,
882  SDL_GetPixelFormatName(mode.format));
883  if (Rmask || Gmask || Bmask) {
884  SDL_Log(" Red Mask = 0x%.8x\n",
885  Rmask);
886  SDL_Log(" Green Mask = 0x%.8x\n",
887  Gmask);
888  SDL_Log(" Blue Mask = 0x%.8x\n",
889  Bmask);
890  if (Amask)
891  SDL_Log(" Alpha Mask = 0x%.8x\n",
892  Amask);
893  }
894  }
895  }
896 
897 #if SDL_VIDEO_DRIVER_WINDOWS
898  /* Print the D3D9 adapter index */
899  adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
900  SDL_Log("D3D9 Adapter Index: %d", adapterIndex);
901 
902  /* Print the DXGI adapter and output indices */
903  SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
904  SDL_Log("DXGI Adapter Index: %d Output Index: %d", adapterIndex, outputIndex);
905 #endif
906  }
907  }
908 
909  if (state->verbose & VERBOSE_RENDER) {
910  SDL_RendererInfo info;
911 
913  if (n == 0) {
914  SDL_Log("No built-in render drivers\n");
915  } else {
916  SDL_Log("Built-in render drivers:\n");
917  for (i = 0; i < n; ++i) {
918  SDL_GetRenderDriverInfo(i, &info);
919  SDLTest_PrintRenderer(&info);
920  }
921  }
922  }
923 
924  SDL_zero(fullscreen_mode);
925  switch (state->depth) {
926  case 8:
927  fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
928  break;
929  case 15:
930  fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
931  break;
932  case 16:
933  fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
934  break;
935  case 24:
936  fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
937  break;
938  default:
939  fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
940  break;
941  }
942  fullscreen_mode.refresh_rate = state->refresh_rate;
943 
944  state->windows =
945  (SDL_Window **) SDL_calloc(state->num_windows,
946  sizeof(*state->windows));
947  state->renderers =
948  (SDL_Renderer **) SDL_calloc(state->num_windows,
949  sizeof(*state->renderers));
950  state->targets =
951  (SDL_Texture **) SDL_calloc(state->num_windows,
952  sizeof(*state->targets));
953  if (!state->windows || !state->renderers) {
954  SDL_Log("Out of memory!\n");
955  return SDL_FALSE;
956  }
957  for (i = 0; i < state->num_windows; ++i) {
958  char title[1024];
959 
960  if (state->num_windows > 1) {
961  SDL_snprintf(title, SDL_arraysize(title), "%s %d",
962  state->window_title, i + 1);
963  } else {
964  SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
965  }
966  state->windows[i] =
967  SDL_CreateWindow(title, state->window_x, state->window_y,
968  state->window_w, state->window_h,
969  state->window_flags);
970  if (!state->windows[i]) {
971  SDL_Log("Couldn't create window: %s\n",
972  SDL_GetError());
973  return SDL_FALSE;
974  }
975  if (state->window_minW || state->window_minH) {
976  SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
977  }
978  if (state->window_maxW || state->window_maxH) {
979  SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
980  }
981  SDL_GetWindowSize(state->windows[i], &w, &h);
982  if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
983  (w != state->window_w || h != state->window_h)) {
984  printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
985  state->window_w = w;
986  state->window_h = h;
987  }
988  if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
989  SDL_Log("Can't set up fullscreen display mode: %s\n",
990  SDL_GetError());
991  return SDL_FALSE;
992  }
993 
994  /* Add resize/drag areas for windows that are borderless and resizable */
995  if ((state->window_flags & (SDL_WINDOW_RESIZABLE|SDL_WINDOW_BORDERLESS)) ==
998  }
999 
1000  if (state->window_icon) {
1001  SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
1002  if (icon) {
1003  SDL_SetWindowIcon(state->windows[i], icon);
1004  SDL_FreeSurface(icon);
1005  }
1006  }
1007 
1008  SDL_ShowWindow(state->windows[i]);
1009 
1010  if (!state->skip_renderer
1011  && (state->renderdriver
1012  || !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN)))) {
1013  m = -1;
1014  if (state->renderdriver) {
1015  SDL_RendererInfo info;
1017  for (j = 0; j < n; ++j) {
1018  SDL_GetRenderDriverInfo(j, &info);
1019  if (SDL_strcasecmp(info.name, state->renderdriver) ==
1020  0) {
1021  m = j;
1022  break;
1023  }
1024  }
1025  if (m == -1) {
1026  SDL_Log("Couldn't find render driver named %s",
1027  state->renderdriver);
1028  return SDL_FALSE;
1029  }
1030  }
1031  state->renderers[i] = SDL_CreateRenderer(state->windows[i],
1032  m, state->render_flags);
1033  if (!state->renderers[i]) {
1034  SDL_Log("Couldn't create renderer: %s\n",
1035  SDL_GetError());
1036  return SDL_FALSE;
1037  }
1038  if (state->logical_w && state->logical_h) {
1039  SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
1040  } else if (state->scale != 0.) {
1041  SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
1042  }
1043  if (state->verbose & VERBOSE_RENDER) {
1044  SDL_RendererInfo info;
1045 
1046  SDL_Log("Current renderer:\n");
1047  SDL_GetRendererInfo(state->renderers[i], &info);
1048  SDLTest_PrintRenderer(&info);
1049  }
1050  }
1051  }
1052  }
1053 
1054  if (state->flags & SDL_INIT_AUDIO) {
1055  if (state->verbose & VERBOSE_AUDIO) {
1057  if (n == 0) {
1058  SDL_Log("No built-in audio drivers\n");
1059  } else {
1060  SDL_snprintf(text, sizeof(text), "Built-in audio drivers:");
1061  for (i = 0; i < n; ++i) {
1062  if (i > 0) {
1063  SDL_snprintfcat(text, sizeof(text), ",");
1064  }
1065  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetAudioDriver(i));
1066  }
1067  SDL_Log("%s\n", text);
1068  }
1069  }
1070  if (SDL_AudioInit(state->audiodriver) < 0) {
1071  SDL_Log("Couldn't initialize audio driver: %s\n",
1072  SDL_GetError());
1073  return SDL_FALSE;
1074  }
1075  if (state->verbose & VERBOSE_VIDEO) {
1076  SDL_Log("Audio driver: %s\n",
1078  }
1079 
1080  if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
1081  SDL_Log("Couldn't open audio: %s\n", SDL_GetError());
1082  return SDL_FALSE;
1083  }
1084  }
1085 
1086  return SDL_TRUE;
1087 }

References SDL_DisplayMode::format, SDL_Rect::h, i, j, SDL_RendererInfo::name, NULL, SDL_DisplayMode::refresh_rate, SDL_arraysize, SDL_AudioInit, SDL_calloc, SDL_CreateRenderer, SDL_CreateWindow, SDL_Direct3D9GetAdapterIndex(), SDL_DXGIGetOutputInfo(), SDL_FALSE, SDL_FreeSurface, SDL_GetAudioDriver, SDL_GetCurrentAudioDriver, SDL_GetCurrentVideoDriver, SDL_GetDesktopDisplayMode, SDL_GetDisplayBounds, SDL_GetDisplayDPI, SDL_GetDisplayMode, SDL_GetDisplayName, SDL_GetDisplayUsableBounds, 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_Log, 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_SetWindowHitTest, SDL_SetWindowIcon, SDL_SetWindowMaximumSize, SDL_SetWindowMinimumSize, SDL_ShowWindow, SDL_snprintf, SDL_snprintfcat(), SDL_strcasecmp, SDL_strlcpy, SDL_TRUE, SDL_VideoInit, SDL_WINDOW_BORDERLESS, SDL_WINDOW_OPENGL, SDL_WINDOW_RESIZABLE, SDL_WINDOW_VULKAN, SDL_zero, SDLTest_ExampleHitTestCallback(), SDLTest_LoadIcon(), SDLTest_PrintRenderer(), state, text, VERBOSE_AUDIO, VERBOSE_MODES, VERBOSE_RENDER, VERBOSE_VIDEO, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by main().

◆ SDLTest_CommonLogUsage()

void SDLTest_CommonLogUsage ( SDLTest_CommonState state,
const char *  argv0,
const char **  options 
)

Logs command line usage info.

This logs the appropriate command line options for the subsystems in use plus other common options, and then any application-specific options. This uses the SDL_Log() function and splits up output to be friendly to 80-character-wide terminals.

Parameters
stateThe common state describing the test window for the app.
argv0argv[0], as passed to main/SDL_main.
optionsan array of strings for application specific options. The last element of the array should be NULL.

Definition at line 489 of file SDL_test_common.c.

490 {
491  int i;
492 
493  SDL_Log("USAGE: %s", argv0);
494  SDL_Log(" %s", "[--trackmem]");
495 
496  if (state->flags & SDL_INIT_VIDEO) {
497  for (i = 0; i < SDL_arraysize(video_usage); i++) {
498  SDL_Log(" %s", video_usage[i]);
499  }
500  }
501 
502  if (state->flags & SDL_INIT_AUDIO) {
503  for (i = 0; i < SDL_arraysize(audio_usage); i++) {
504  SDL_Log(" %s", audio_usage[i]);
505  }
506  }
507 
508  if (options) {
509  for (i = 0; options[i] != NULL; i++) {
510  SDL_Log(" %s", options[i]);
511  }
512  }
513 }

References audio_usage, i, NULL, SDL_arraysize, SDL_INIT_AUDIO, SDL_INIT_VIDEO, SDL_Log, state, and video_usage.

Referenced by main(), and SDLTest_CommonDefaultArgs().

◆ SDLTest_CommonQuit()

void SDLTest_CommonQuit ( SDLTest_CommonState state)

Close test window.

Parameters
stateThe common state used to create test window.

Definition at line 1832 of file SDL_test_common.c.

1833 {
1834  int i;
1835 
1836  SDL_free(state->windows);
1837  if (state->targets) {
1838  for (i = 0; i < state->num_windows; ++i) {
1839  if (state->targets[i]) {
1840  SDL_DestroyTexture(state->targets[i]);
1841  }
1842  }
1843  SDL_free(state->targets);
1844  }
1845  if (state->renderers) {
1846  for (i = 0; i < state->num_windows; ++i) {
1847  if (state->renderers[i]) {
1848  SDL_DestroyRenderer(state->renderers[i]);
1849  }
1850  }
1851  SDL_free(state->renderers);
1852  }
1853  if (state->flags & SDL_INIT_VIDEO) {
1854  SDL_VideoQuit();
1855  }
1856  if (state->flags & SDL_INIT_AUDIO) {
1857  SDL_AudioQuit();
1858  }
1859  SDL_free(state);
1860  SDL_Quit();
1862 }

References i, SDL_AudioQuit, SDL_DestroyRenderer, SDL_DestroyTexture, SDL_free, SDL_INIT_AUDIO, SDL_INIT_VIDEO, SDL_Quit, SDL_VideoQuit, SDLTest_LogAllocations(), and state.

Referenced by main(), and quit().

SDL_GL_STENCIL_SIZE
Definition: SDL_video.h:207
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
SDL_WINDOW_MOUSE_CAPTURE
Definition: SDL_video.h:116
SDL_GL_ACCUM_RED_SIZE
Definition: SDL_video.h:208
SDL_GetWindowDisplayIndex
#define SDL_GetWindowDisplayIndex
Definition: SDL_dynapi_overrides.h:510
VERBOSE_VIDEO
#define VERBOSE_VIDEO
Definition: SDL_test_common.h:45
SDL_OpenAudio
#define SDL_OpenAudio
Definition: SDL_dynapi_overrides.h:78
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:113
SDL_SetClipboardText
#define SDL_SetClipboardText
Definition: SDL_dynapi_overrides.h:98
SDL_GetPixelFormatName
#define SDL_GetPixelFormatName
Definition: SDL_dynapi_overrides.h:277
SDL_DisplayMode::format
Uint32 format
Definition: SDL_video.h:55
SDL_WINDOW_ALLOW_HIGHDPI
Definition: SDL_video.h:113
SDL_GL_DEPTH_SIZE
Definition: SDL_video.h:206
SDL_DXGIGetOutputInfo
SDL_bool SDL_DXGIGetOutputInfo(int displayIndex, int *adapterIndex, int *outputIndex)
Returns the DXGI Adapter and Output indices for the specified display index.
SDL_strlcpy
#define SDL_strlcpy
Definition: SDL_dynapi_overrides.h:394
SDL_MouseMotionEvent::y
Sint32 y
Definition: SDL_events.h:261
SDL_GL_CONTEXT_PROFILE_MASK
Definition: SDL_video.h:221
SDL_SetWindowMinimumSize
#define SDL_SetWindowMinimumSize
Definition: SDL_dynapi_overrides.h:528
SDL_AudioInit
#define SDL_AudioInit
Definition: SDL_dynapi_overrides.h:75
SDL_MouseMotionEvent
Mouse motion event structure (event.motion.*)
Definition: SDL_events.h:253
mask
GLenum GLint GLuint mask
Definition: SDL_opengl_glext.h:657
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:70
SDL_ShowWindow
#define SDL_ShowWindow
Definition: SDL_dynapi_overrides.h:533
AUDIO_U16LSB
#define AUDIO_U16LSB
Definition: SDL_audio.h:91
SDLK_2
Definition: SDL_keycode.h:76
SDL_WINDOWPOS_CENTERED
#define SDL_WINDOWPOS_CENTERED
Definition: SDL_video.h:139
SDL_WINDOW_MINIMIZED
Definition: SDL_video.h:106
SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:236
SDL_GL_ALPHA_SIZE
Definition: SDL_video.h:203
SDL_GetNumVideoDrivers
#define SDL_GetNumVideoDrivers
Definition: SDL_dynapi_overrides.h:496
SDL_SetWindowSize
#define SDL_SetWindowSize
Definition: SDL_dynapi_overrides.h:526
SDL_RenderGetClipRect
#define SDL_RenderGetClipRect
Definition: SDL_dynapi_overrides.h:327
SDL_GL_BUFFER_SIZE
Definition: SDL_video.h:204
NULL
#define NULL
Definition: begin_code.h:167
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
message
GLuint GLsizei const GLchar * message
Definition: SDL_opengl_glext.h:2483
SDL_GetNumRenderDrivers
#define SDL_GetNumRenderDrivers
Definition: SDL_dynapi_overrides.h:298
SDL_GetDisplayMode
#define SDL_GetDisplayMode
Definition: SDL_dynapi_overrides.h:506
SDLTest_CommonLogUsage
void SDLTest_CommonLogUsage(SDLTest_CommonState *state, const char *argv0, const char **options)
Logs command line usage info.
Definition: SDL_test_common.c:489
SDLTest_CommonState
Definition: SDL_test_common.h:51
SDL_WINDOWEVENT_CLOSE
Definition: SDL_video.h:167
mode
GLenum mode
Definition: SDL_opengl_glext.h:1122
SDL_SetWindowDisplayMode
#define SDL_SetWindowDisplayMode
Definition: SDL_dynapi_overrides.h:511
SDL_GetDisplayName
#define SDL_GetDisplayName
Definition: SDL_dynapi_overrides.h:502
SDL_snprintfcat
static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
Definition: SDL_test_common.c:46
SDL_BUTTON_RMASK
#define SDL_BUTTON_RMASK
Definition: SDL_mouse.h:289
SDL_SetWindowFullscreen
#define SDL_SetWindowFullscreen
Definition: SDL_dynapi_overrides.h:539
SDL_GetWindowFlags
#define SDL_GetWindowFlags
Definition: SDL_dynapi_overrides.h:518
SDLTest_ScreenShot
static void SDLTest_ScreenShot(SDL_Renderer *renderer)
Definition: SDL_test_common.c:1442
SDL_WINDOW_FULLSCREEN
Definition: SDL_video.h:100
SDL_GL_BLUE_SIZE
Definition: SDL_video.h:202
SDL_WINDOW_OPENGL
Definition: SDL_video.h:101
SDLK_DOWN
Definition: SDL_keycode.h:153
SDL_BUTTON_X2MASK
#define SDL_BUTTON_X2MASK
Definition: SDL_mouse.h:291
SDL_WINDOW_FULLSCREEN_DESKTOP
Definition: SDL_video.h:111
SDL_WINDOWPOS_UNDEFINED
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:130
SDL_GetDesktopDisplayMode
#define SDL_GetDesktopDisplayMode
Definition: SDL_dynapi_overrides.h:507
SDL_LOG_CATEGORY_INPUT
Definition: SDL_log.h:73
SDL_LOG_CATEGORY_AUDIO
Definition: SDL_log.h:70
SDLK_UP
Definition: SDL_keycode.h:154
SDL_RectEmpty
SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
Returns true if the rectangle has no area.
Definition: SDL_rect.h:108
SDL_GL_MULTISAMPLESAMPLES
Definition: SDL_video.h:214
SDL_LOG_CATEGORY_SYSTEM
Definition: SDL_log.h:69
SDL_WINDOWPOS_ISCENTERED
#define SDL_WINDOWPOS_ISCENTERED(X)
Definition: SDL_video.h:140
SDL_PIXELFORMAT_RGB565
Definition: SDL_pixels.h:224
SDL_WINDOW_MAXIMIZED
Definition: SDL_video.h:107
VERBOSE_MODES
#define VERBOSE_MODES
Definition: SDL_test_common.h:46
index
GLuint index
Definition: SDL_opengl_glext.h:660
SDLTest_CommonArg
int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
Process one common argument.
Definition: SDL_test_common.c:117
SDL_GetDisplayUsableBounds
#define SDL_GetDisplayUsableBounds
Definition: SDL_dynapi_overrides.h:596
SDL_AudioQuit
#define SDL_AudioQuit
Definition: SDL_dynapi_overrides.h:76
SDL_KEYDOWN
Definition: SDL_events.h:96
SDL_CreateWindow
#define SDL_CreateWindow
Definition: SDL_dynapi_overrides.h:514
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
SDL_Rect::x
int x
Definition: SDL_rect.h:79
SDLK_LEFT
Definition: SDL_keycode.h:152
SDL_SetWindowIcon
#define SDL_SetWindowIcon
Definition: SDL_dynapi_overrides.h:521
SDL_GetNumVideoDisplays
#define SDL_GetNumVideoDisplays
Definition: SDL_dynapi_overrides.h:501
SDL_RendererInfo
Information on the capabilities of a render driver or context.
Definition: SDL_render.h:78
SDLK_m
Definition: SDL_keycode.h:112
SDL_WINDOW_RESIZABLE
Definition: SDL_video.h:105
video_usage
static const char * video_usage[]
Definition: SDL_test_common.c:29
SDL_Rect::w
int w
Definition: SDL_rect.h:80
SDL_SetRelativeMouseMode
#define SDL_SetRelativeMouseMode
Definition: SDL_dynapi_overrides.h:249
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:73
SDL_GetRenderDriverInfo
#define SDL_GetRenderDriverInfo
Definition: SDL_dynapi_overrides.h:299
SDL_DisplayMode
The structure that defines a display mode.
Definition: SDL_video.h:53
SDL_GetKeyboardFocus
#define SDL_GetKeyboardFocus
Definition: SDL_dynapi_overrides.h:216
n
GLdouble n
Definition: SDL_opengl_glext.h:1952
SDL_strcasecmp
#define SDL_strcasecmp
Definition: SDL_dynapi_overrides.h:419
SDLTest_LoadIcon
static SDL_Surface * SDLTest_LoadIcon(const char *file)
Definition: SDL_test_common.c:698
SDLK_v
Definition: SDL_keycode.h:121
SDL_GL_ACCELERATED_VISUAL
Definition: SDL_video.h:215
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDLK_ESCAPE
Definition: SDL_keycode.h:55
SDL_MinimizeWindow
#define SDL_MinimizeWindow
Definition: SDL_dynapi_overrides.h:537
SDL_GL_RED_SIZE
Definition: SDL_video.h:200
SDLK_g
Definition: SDL_keycode.h:106
SDL_GL_CONTEXT_DEBUG_FLAG
Definition: SDL_video.h:238
SDL_ShowSimpleMessageBox
#define SDL_ShowSimpleMessageBox
Definition: SDL_dynapi_overrides.h:244
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDL_Renderer
Definition: SDL_sysrender.h:122
done
int done
Definition: checkkeys.c:28
SDL_MOUSEMOTION
Definition: SDL_events.h:105
SDL_SetWindowGrab
#define SDL_SetWindowGrab
Definition: SDL_dynapi_overrides.h:543
SDL_atof
#define SDL_atof
Definition: SDL_dynapi_overrides.h:411
SDLTest_LogAllocations
void SDLTest_LogAllocations(void)
Print a log of any outstanding allocations.
Definition: SDL_test_memory.c:222
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1573
window
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
SDL_Log
#define SDL_Log
Definition: SDL_dynapi_overrides.h:31
SDL_GL_SetAttribute
#define SDL_GL_SetAttribute
Definition: SDL_dynapi_overrides.h:557
SDL_GL_STEREO
Definition: SDL_video.h:212
SDL_Rect::y
int y
Definition: SDL_rect.h:79
SDL_GetRelativeMouseMode
#define SDL_GetRelativeMouseMode
Definition: SDL_dynapi_overrides.h:250
SDL_Rect::h
int h
Definition: SDL_rect.h:80
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
SDL_LOG_CATEGORY_ERROR
Definition: SDL_log.h:67
SDL_MouseMotionEvent::xrel
Sint32 xrel
Definition: SDL_events.h:262
SDL_DROPTEXT
Definition: SDL_events.h:142
SDL_GL_CONTEXT_MAJOR_VERSION
Definition: SDL_video.h:217
SDLTest_PrintRenderer
static void SDLTest_PrintRenderer(SDL_RendererInfo *info)
Definition: SDL_test_common.c:659
SDL_GetClipboardText
#define SDL_GetClipboardText
Definition: SDL_dynapi_overrides.h:99
DEFAULT_WINDOW_HEIGHT
#define DEFAULT_WINDOW_HEIGHT
Definition: SDL_test_common.h:42
SDL_QUIT
Definition: SDL_events.h:60
SDL_DisplayMode::refresh_rate
int refresh_rate
Definition: SDL_video.h:58
SDL_FALSE
Definition: SDL_stdinc.h:163
SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
SDL_WINDOWPOS_UNDEFINED_DISPLAY
#define SDL_WINDOWPOS_UNDEFINED_DISPLAY(X)
Definition: SDL_video.h:129
SDL_Direct3D9GetAdapterIndex
int SDL_Direct3D9GetAdapterIndex(int displayIndex)
Returns the D3D9 adapter index that matches the specified display index.
DEFAULT_WINDOW_WIDTH
#define DEFAULT_WINDOW_WIDTH
Definition: SDL_test_common.h:41
SDLK_SPACE
Definition: SDL_keycode.h:58
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:446
SDL_isdigit
#define SDL_isdigit
Definition: SDL_dynapi_overrides.h:382
SDLK_z
Definition: SDL_keycode.h:125
SDL_LOG_CATEGORY_VIDEO
Definition: SDL_log.h:71
SDL_PixelFormatEnumToMasks
#define SDL_PixelFormatEnumToMasks
Definition: SDL_dynapi_overrides.h:278
SDL_VideoInit
#define SDL_VideoInit
Definition: SDL_dynapi_overrides.h:498
SDL_GetWindowFromID
#define SDL_GetWindowFromID
Definition: SDL_dynapi_overrides.h:517
SDL_BUTTON_LMASK
#define SDL_BUTTON_LMASK
Definition: SDL_mouse.h:287
SDLK_a
Definition: SDL_keycode.h:100
SDL_Quit
#define SDL_Quit
Definition: SDL_dynapi_overrides.h:58
SDL_GetWindowPosition
#define SDL_GetWindowPosition
Definition: SDL_dynapi_overrides.h:525
SDL_GL_CONTEXT_FLAGS
Definition: SDL_video.h:220
text
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
SDL_WINDOW_INPUT_GRABBED
Definition: SDL_video.h:108
SDLK_0
Definition: SDL_keycode.h:74
SDL_GL_GREEN_SIZE
Definition: SDL_video.h:201
SDL_RenderSetLogicalSize
#define SDL_RenderSetLogicalSize
Definition: SDL_dynapi_overrides.h:322
SDL_GetDisplayBounds
#define SDL_GetDisplayBounds
Definition: SDL_dynapi_overrides.h:503
SDL_RestoreWindow
#define SDL_RestoreWindow
Definition: SDL_dynapi_overrides.h:538
KMOD_SHIFT
#define KMOD_SHIFT
Definition: SDL_keycode.h:343
SDLTest_ExampleHitTestCallback
static SDL_HitTestResult SDLTest_ExampleHitTestCallback(SDL_Window *win, const SDL_Point *area, void *data)
Definition: SDL_test_common.c:718
SDL_BUTTON_X1MASK
#define SDL_BUTTON_X1MASK
Definition: SDL_mouse.h:290
SDL_SetWindowOpacity
#define SDL_SetWindowOpacity
Definition: SDL_dynapi_overrides.h:598
SDL_GL_CONTEXT_MINOR_VERSION
Definition: SDL_video.h:218
SDL_WINDOWPOS_CENTERED_DISPLAY
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X)
Definition: SDL_video.h:138
SDLTest_TrackAllocations
int SDLTest_TrackAllocations(void)
Start tracking SDL memory allocations.
Definition: SDL_test_memory.c:197
SDL_GetAudioDriver
#define SDL_GetAudioDriver
Definition: SDL_dynapi_overrides.h:74
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_GetCurrentAudioDriver
#define SDL_GetCurrentAudioDriver
Definition: SDL_dynapi_overrides.h:77
SDL_MESSAGEBOX_INFORMATION
Definition: SDL_messagebox.h:41
VERBOSE_RENDER
#define VERBOSE_RENDER
Definition: SDL_test_common.h:47
SDL_GetWindowOpacity
#define SDL_GetWindowOpacity
Definition: SDL_dynapi_overrides.h:599
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1573
SDL_LOG_CATEGORY_RENDER
Definition: SDL_log.h:72
SDL_GetVideoDriver
#define SDL_GetVideoDriver
Definition: SDL_dynapi_overrides.h:497
SDL_RenderSetScale
#define SDL_RenderSetScale
Definition: SDL_dynapi_overrides.h:328
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_DestroyTexture
#define SDL_DestroyTexture
Definition: SDL_dynapi_overrides.h:347
SDL_atoi
#define SDL_atoi
Definition: SDL_dynapi_overrides.h:410
SDL_PIXELFORMAT_RGB555
Definition: SDL_pixels.h:194
m
const GLfloat * m
Definition: SDL_opengl_glext.h:6092
SDL_INIT_VIDEO
#define SDL_INIT_VIDEO
Definition: SDL.h:79
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:161
SDLK_RETURN
Definition: SDL_keycode.h:54
SDLK_MINUS
Definition: SDL_keycode.h:71
SDL_GL_DOUBLEBUFFER
Definition: SDL_video.h:205
SDL_GetWindowGrab
#define SDL_GetWindowGrab
Definition: SDL_dynapi_overrides.h:544
SDL_GetCurrentVideoDriver
#define SDL_GetCurrentVideoDriver
Definition: SDL_dynapi_overrides.h:500
SDL_MouseMotionEvent::x
Sint32 x
Definition: SDL_events.h:260
SDL_SetWindowHitTest
#define SDL_SetWindowHitTest
Definition: SDL_dynapi_overrides.h:585
SDL_LogSetPriority
#define SDL_LogSetPriority
Definition: SDL_dynapi_overrides.h:236
SDL_SetWindowBordered
#define SDL_SetWindowBordered
Definition: SDL_dynapi_overrides.h:532
AUDIO_S16
#define AUDIO_S16
Definition: SDL_audio.h:96
SDL_snprintf
#define SDL_snprintf
Definition: SDL_dynapi_overrides.h:40
SDL_Rect
A rectangle, with the origin at the upper left (integer).
Definition: SDL_rect.h:77
j
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
VERBOSE_AUDIO
#define VERBOSE_AUDIO
Definition: SDL_test_common.h:49
KMOD_ALT
#define KMOD_ALT
Definition: SDL_keycode.h:344
SDL_TRUE
Definition: SDL_stdinc.h:164
SDL_Texture
Definition: SDL_sysrender.h:43
SDL_PIXELFORMAT_RGB24
Definition: SDL_pixels.h:230
SDL_LOG_PRIORITY_VERBOSE
Definition: SDL_log.h:104
SDLK_EQUALS
Definition: SDL_keycode.h:87
SDL_MaximizeWindow
#define SDL_MaximizeWindow
Definition: SDL_dynapi_overrides.h:536
KMOD_CTRL
#define KMOD_CTRL
Definition: SDL_keycode.h:342
AUDIO_S16MSB
#define AUDIO_S16MSB
Definition: SDL_audio.h:94
SDLK_c
Definition: SDL_keycode.h:102
SDL_GL_ACCUM_GREEN_SIZE
Definition: SDL_video.h:209
SDL_GetGlobalMouseState
#define SDL_GetGlobalMouseState
Definition: SDL_dynapi_overrides.h:586
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDL_CaptureMouse
#define SDL_CaptureMouse
Definition: SDL_dynapi_overrides.h:584
SDLTest_PrintEvent
static void SDLTest_PrintEvent(SDL_Event *event)
Definition: SDL_test_common.c:1151
AUDIO_S16LSB
#define AUDIO_S16LSB
Definition: SDL_audio.h:92
SDL_GetDisplayDPI
#define SDL_GetDisplayDPI
Definition: SDL_dynapi_overrides.h:504
SDL_RendererInfo::name
const char * name
Definition: SDL_render.h:80
SDL_VideoQuit
#define SDL_VideoQuit
Definition: SDL_dynapi_overrides.h:499
SDL_GL_MULTISAMPLEBUFFERS
Definition: SDL_video.h:213
SDL_WINDOWEVENT
Definition: SDL_events.h:92
AUDIO_S8
#define AUDIO_S8
Definition: SDL_audio.h:90
SDL_PIXELFORMAT_INDEX8
Definition: SDL_pixels.h:186
SDL_LogSetAllPriority
#define SDL_LogSetAllPriority
Definition: SDL_dynapi_overrides.h:235
SDL_GL_ACCUM_ALPHA_SIZE
Definition: SDL_video.h:211
SDL_MouseMotionEvent::yrel
Sint32 yrel
Definition: SDL_events.h:263
SDLK_RIGHT
Definition: SDL_keycode.h:151
SDL_CreateRenderer
#define SDL_CreateRenderer
Definition: SDL_dynapi_overrides.h:301
SDL_RenderSetClipRect
#define SDL_RenderSetClipRect
Definition: SDL_dynapi_overrides.h:326
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
SDLK_o
Definition: SDL_keycode.h:114
VERBOSE_EVENT
#define VERBOSE_EVENT
Definition: SDL_test_common.h:48
SDL_DestroyRenderer
#define SDL_DestroyRenderer
Definition: SDL_dynapi_overrides.h:348
SDL_GetNumDisplayModes
#define SDL_GetNumDisplayModes
Definition: SDL_dynapi_overrides.h:505
SDL_SetWindowPosition
#define SDL_SetWindowPosition
Definition: SDL_dynapi_overrides.h:524
FullscreenTo
static void FullscreenTo(int index, int windowId)
Definition: SDL_test_common.c:1479
SDLK_r
Definition: SDL_keycode.h:117
SDL_GL_ACCUM_BLUE_SIZE
Definition: SDL_video.h:210
SDL_GL_RETAINED_BACKING
Definition: SDL_video.h:216
state
struct xkb_state * state
Definition: SDL_waylandsym.h:113
AUDIO_U16MSB
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
i
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
SDLK_1
Definition: SDL_keycode.h:75
audio_usage
static const char * audio_usage[]
Definition: SDL_test_common.c:41
AUDIO_U16
#define AUDIO_U16
Definition: SDL_audio.h:95
SDL_BUTTON_MMASK
#define SDL_BUTTON_MMASK
Definition: SDL_mouse.h:288
SDLK_b
Definition: SDL_keycode.h:101
SDL_DROPFILE
Definition: SDL_events.h:141
SDL_SetWindowMaximumSize
#define SDL_SetWindowMaximumSize
Definition: SDL_dynapi_overrides.h:530
SDL_DestroyWindow
#define SDL_DestroyWindow
Definition: SDL_dynapi_overrides.h:549
SDL_WINDOWPOS_ISUNDEFINED
#define SDL_WINDOWPOS_ISUNDEFINED(X)
Definition: SDL_video.h:131
SDLK_PRINTSCREEN
Definition: SDL_keycode.h:142
SDL_GetNumAudioDrivers
#define SDL_GetNumAudioDrivers
Definition: SDL_dynapi_overrides.h:73
Uint16
uint16_t Uint16
Definition: SDL_stdinc.h:191
SDL_WINDOW_BORDERLESS
Definition: SDL_video.h:104
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
SDL_GetRendererInfo
#define SDL_GetRendererInfo
Definition: SDL_dynapi_overrides.h:304
SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:78