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...
 
const char * SDLTest_CommonUsage (SDLTest_CommonState *state)
 Returns common usage information. 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], "--usable-bounds") == 0) {
286  /* !!! FIXME: this is a bit of a hack, but I don't want to add a
287  !!! FIXME: flag to the public structure in 2.0.x */
288  state->window_x = -1;
289  state->window_y = -1;
290  state->window_w = -1;
291  state->window_h = -1;
292  return 1;
293  }
294  if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
295  char *w, *h;
296  ++index;
297  if (!argv[index]) {
298  return -1;
299  }
300  w = argv[index];
301  h = argv[index];
302  while (*h && *h != 'x') {
303  ++h;
304  }
305  if (!*h) {
306  return -1;
307  }
308  *h++ = '\0';
309  state->window_w = SDL_atoi(w);
310  state->window_h = SDL_atoi(h);
311  return 2;
312  }
313  if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) {
314  char *w, *h;
315  ++index;
316  if (!argv[index]) {
317  return -1;
318  }
319  w = argv[index];
320  h = argv[index];
321  while (*h && *h != 'x') {
322  ++h;
323  }
324  if (!*h) {
325  return -1;
326  }
327  *h++ = '\0';
328  state->window_minW = SDL_atoi(w);
329  state->window_minH = SDL_atoi(h);
330  return 2;
331  }
332  if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) {
333  char *w, *h;
334  ++index;
335  if (!argv[index]) {
336  return -1;
337  }
338  w = argv[index];
339  h = argv[index];
340  while (*h && *h != 'x') {
341  ++h;
342  }
343  if (!*h) {
344  return -1;
345  }
346  *h++ = '\0';
347  state->window_maxW = SDL_atoi(w);
348  state->window_maxH = SDL_atoi(h);
349  return 2;
350  }
351  if (SDL_strcasecmp(argv[index], "--logical") == 0) {
352  char *w, *h;
353  ++index;
354  if (!argv[index]) {
355  return -1;
356  }
357  w = argv[index];
358  h = argv[index];
359  while (*h && *h != 'x') {
360  ++h;
361  }
362  if (!*h) {
363  return -1;
364  }
365  *h++ = '\0';
366  state->logical_w = SDL_atoi(w);
367  state->logical_h = SDL_atoi(h);
368  return 2;
369  }
370  if (SDL_strcasecmp(argv[index], "--scale") == 0) {
371  ++index;
372  if (!argv[index]) {
373  return -1;
374  }
375  state->scale = (float)SDL_atof(argv[index]);
376  return 2;
377  }
378  if (SDL_strcasecmp(argv[index], "--depth") == 0) {
379  ++index;
380  if (!argv[index]) {
381  return -1;
382  }
383  state->depth = SDL_atoi(argv[index]);
384  return 2;
385  }
386  if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
387  ++index;
388  if (!argv[index]) {
389  return -1;
390  }
391  state->refresh_rate = SDL_atoi(argv[index]);
392  return 2;
393  }
394  if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
395  state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
396  return 1;
397  }
398  if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
399  state->window_flags |= SDL_WINDOW_BORDERLESS;
400  return 1;
401  }
402  if (SDL_strcasecmp(argv[index], "--resize") == 0) {
403  state->window_flags |= SDL_WINDOW_RESIZABLE;
404  return 1;
405  }
406  if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
407  state->window_flags |= SDL_WINDOW_MINIMIZED;
408  return 1;
409  }
410  if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
411  state->window_flags |= SDL_WINDOW_MAXIMIZED;
412  return 1;
413  }
414  if (SDL_strcasecmp(argv[index], "--grab") == 0) {
415  state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
416  return 1;
417  }
418  if (SDL_strcasecmp(argv[index], "--rate") == 0) {
419  ++index;
420  if (!argv[index]) {
421  return -1;
422  }
423  state->audiospec.freq = SDL_atoi(argv[index]);
424  return 2;
425  }
426  if (SDL_strcasecmp(argv[index], "--format") == 0) {
427  ++index;
428  if (!argv[index]) {
429  return -1;
430  }
431  if (SDL_strcasecmp(argv[index], "U8") == 0) {
432  state->audiospec.format = AUDIO_U8;
433  return 2;
434  }
435  if (SDL_strcasecmp(argv[index], "S8") == 0) {
436  state->audiospec.format = AUDIO_S8;
437  return 2;
438  }
439  if (SDL_strcasecmp(argv[index], "U16") == 0) {
440  state->audiospec.format = AUDIO_U16;
441  return 2;
442  }
443  if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
444  state->audiospec.format = AUDIO_U16LSB;
445  return 2;
446  }
447  if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
448  state->audiospec.format = AUDIO_U16MSB;
449  return 2;
450  }
451  if (SDL_strcasecmp(argv[index], "S16") == 0) {
452  state->audiospec.format = AUDIO_S16;
453  return 2;
454  }
455  if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
456  state->audiospec.format = AUDIO_S16LSB;
457  return 2;
458  }
459  if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
460  state->audiospec.format = AUDIO_S16MSB;
461  return 2;
462  }
463  return -1;
464  }
465  if (SDL_strcasecmp(argv[index], "--channels") == 0) {
466  ++index;
467  if (!argv[index]) {
468  return -1;
469  }
470  state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
471  return 2;
472  }
473  if (SDL_strcasecmp(argv[index], "--samples") == 0) {
474  ++index;
475  if (!argv[index]) {
476  return -1;
477  }
478  state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
479  return 2;
480  }
481  if (SDL_strcasecmp(argv[index], "--trackmem") == 0) {
482  /* Already handled in SDLTest_CommonCreateState() */
483  return 1;
484  }
485  if ((SDL_strcasecmp(argv[index], "-h") == 0)
486  || (SDL_strcasecmp(argv[index], "--help") == 0)) {
487  /* Print the usage message */
488  return -1;
489  }
490  if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) {
491  /* Debug flag sent by Xcode */
492  return 2;
493  }
494  return 0;
495 }

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

585 {
586  int i = 1;
587  while (i < argc) {
588  const int consumed = SDLTest_CommonArg(state, i);
589  if (consumed == 0) {
590  SDLTest_CommonLogUsage(state, argv[0], NULL);
591  return SDL_FALSE;
592  }
593  i += consumed;
594  }
595  return SDL_TRUE;
596 }

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

1580 {
1581  int i;
1582  static SDL_MouseMotionEvent lastEvent;
1583 
1584  if (state->verbose & VERBOSE_EVENT) {
1586  }
1587 
1588  switch (event->type) {
1589  case SDL_WINDOWEVENT:
1590  switch (event->window.event) {
1591  case SDL_WINDOWEVENT_CLOSE:
1592  {
1593  SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
1594  if (window) {
1595  for (i = 0; i < state->num_windows; ++i) {
1596  if (window == state->windows[i]) {
1597  if (state->targets[i]) {
1598  SDL_DestroyTexture(state->targets[i]);
1599  state->targets[i] = NULL;
1600  }
1601  if (state->renderers[i]) {
1602  SDL_DestroyRenderer(state->renderers[i]);
1603  state->renderers[i] = NULL;
1604  }
1605  SDL_DestroyWindow(state->windows[i]);
1606  state->windows[i] = NULL;
1607  break;
1608  }
1609  }
1610  }
1611  }
1612  break;
1613  }
1614  break;
1615  case SDL_KEYDOWN: {
1616  SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
1617  SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
1618  SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
1619 
1620  switch (event->key.keysym.sym) {
1621  /* Add hotkeys here */
1622  case SDLK_PRINTSCREEN: {
1623  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1624  if (window) {
1625  for (i = 0; i < state->num_windows; ++i) {
1626  if (window == state->windows[i]) {
1627  SDLTest_ScreenShot(state->renderers[i]);
1628  }
1629  }
1630  }
1631  }
1632  break;
1633  case SDLK_EQUALS:
1634  if (withControl) {
1635  /* Ctrl-+ double the size of the window */
1636  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1637  if (window) {
1638  int w, h;
1639  SDL_GetWindowSize(window, &w, &h);
1640  SDL_SetWindowSize(window, w*2, h*2);
1641  }
1642  }
1643  break;
1644  case SDLK_MINUS:
1645  if (withControl) {
1646  /* Ctrl-- half the size of the window */
1647  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1648  if (window) {
1649  int w, h;
1650  SDL_GetWindowSize(window, &w, &h);
1651  SDL_SetWindowSize(window, w/2, h/2);
1652  }
1653  }
1654  break;
1655  case SDLK_UP:
1656  case SDLK_DOWN:
1657  case SDLK_LEFT:
1658  case SDLK_RIGHT:
1659  if (withAlt) {
1660  /* Alt-Up/Down/Left/Right switches between displays */
1661  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1662  if (window) {
1663  int currentIndex = SDL_GetWindowDisplayIndex(window);
1664  int numDisplays = SDL_GetNumVideoDisplays();
1665 
1666  if (currentIndex >= 0 && numDisplays >= 1) {
1667  int dest;
1668  if (event->key.keysym.sym == SDLK_UP || event->key.keysym.sym == SDLK_LEFT) {
1669  dest = (currentIndex + numDisplays - 1) % numDisplays;
1670  } else {
1671  dest = (currentIndex + numDisplays + 1) % numDisplays;
1672  }
1673  SDL_Log("Centering on display %d\n", dest);
1677  }
1678  }
1679  }
1680  if (withShift) {
1681  /* Shift-Up/Down/Left/Right shift the window by 100px */
1682  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1683  if (window) {
1684  const int delta = 100;
1685  int x, y;
1687 
1688  if (event->key.keysym.sym == SDLK_UP) y -= delta;
1689  if (event->key.keysym.sym == SDLK_DOWN) y += delta;
1690  if (event->key.keysym.sym == SDLK_LEFT) x -= delta;
1691  if (event->key.keysym.sym == SDLK_RIGHT) x += delta;
1692 
1693  SDL_Log("Setting position to (%d, %d)\n", x, y);
1695  }
1696  }
1697  break;
1698  case SDLK_o:
1699  if (withControl) {
1700  /* Ctrl-O (or Ctrl-Shift-O) changes window opacity. */
1701  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1702  if (window) {
1703  float opacity;
1704  if (SDL_GetWindowOpacity(window, &opacity) == 0) {
1705  if (withShift) {
1706  opacity += 0.20f;
1707  } else {
1708  opacity -= 0.20f;
1709  }
1710  SDL_SetWindowOpacity(window, opacity);
1711  }
1712  }
1713  }
1714  break;
1715 
1716  case SDLK_c:
1717  if (withControl) {
1718  /* Ctrl-C copy awesome text! */
1719  SDL_SetClipboardText("SDL rocks!\nYou know it!");
1720  printf("Copied text to clipboard\n");
1721  }
1722  if (withAlt) {
1723  /* Alt-C toggle a render clip rectangle */
1724  for (i = 0; i < state->num_windows; ++i) {
1725  int w, h;
1726  if (state->renderers[i]) {
1727  SDL_Rect clip;
1728  SDL_GetWindowSize(state->windows[i], &w, &h);
1729  SDL_RenderGetClipRect(state->renderers[i], &clip);
1730  if (SDL_RectEmpty(&clip)) {
1731  clip.x = w/4;
1732  clip.y = h/4;
1733  clip.w = w/2;
1734  clip.h = h/2;
1735  SDL_RenderSetClipRect(state->renderers[i], &clip);
1736  } else {
1737  SDL_RenderSetClipRect(state->renderers[i], NULL);
1738  }
1739  }
1740  }
1741  }
1742  if (withShift) {
1743  SDL_Window *current_win = SDL_GetKeyboardFocus();
1744  if (current_win) {
1745  const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
1746  const int rc = SDL_CaptureMouse(shouldCapture);
1747  SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
1748  }
1749  }
1750  break;
1751  case SDLK_v:
1752  if (withControl) {
1753  /* Ctrl-V paste awesome text! */
1754  char *text = SDL_GetClipboardText();
1755  if (*text) {
1756  printf("Clipboard: %s\n", text);
1757  } else {
1758  printf("Clipboard is empty\n");
1759  }
1760  SDL_free(text);
1761  }
1762  break;
1763  case SDLK_g:
1764  if (withControl) {
1765  /* Ctrl-G toggle grab */
1766  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1767  if (window) {
1769  }
1770  }
1771  break;
1772  case SDLK_m:
1773  if (withControl) {
1774  /* Ctrl-M maximize */
1775  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1776  if (window) {
1778  if (flags & SDL_WINDOW_MAXIMIZED) {
1780  } else {
1782  }
1783  }
1784  }
1785  break;
1786  case SDLK_r:
1787  if (withControl) {
1788  /* Ctrl-R toggle mouse relative mode */
1790  }
1791  break;
1792  case SDLK_z:
1793  if (withControl) {
1794  /* Ctrl-Z minimize */
1795  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1796  if (window) {
1798  }
1799  }
1800  break;
1801  case SDLK_RETURN:
1802  if (withControl) {
1803  /* Ctrl-Enter toggle fullscreen */
1804  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1805  if (window) {
1807  if (flags & SDL_WINDOW_FULLSCREEN) {
1809  } else {
1811  }
1812  }
1813  } else if (withAlt) {
1814  /* Alt-Enter toggle fullscreen desktop */
1815  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1816  if (window) {
1818  if (flags & SDL_WINDOW_FULLSCREEN) {
1820  } else {
1822  }
1823  }
1824  } else if (withShift) {
1825  /* Shift-Enter toggle fullscreen desktop / fullscreen */
1826  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1827  if (window) {
1831  } else {
1833  }
1834  }
1835  }
1836 
1837  break;
1838  case SDLK_b:
1839  if (withControl) {
1840  /* Ctrl-B toggle window border */
1841  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1842  if (window) {
1844  const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
1846  }
1847  }
1848  break;
1849  case SDLK_a:
1850  if (withControl) {
1851  /* Ctrl-A reports absolute mouse position. */
1852  int x, y;
1853  const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
1854  SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
1855  (mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
1856  (mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
1857  (mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
1858  (mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
1859  (mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
1860  }
1861  break;
1862  case SDLK_0:
1863  if (withControl) {
1864  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1865  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
1866  }
1867  break;
1868  case SDLK_1:
1869  if (withControl) {
1870  FullscreenTo(0, event->key.windowID);
1871  }
1872  break;
1873  case SDLK_2:
1874  if (withControl) {
1875  FullscreenTo(1, event->key.windowID);
1876  }
1877  break;
1878  case SDLK_ESCAPE:
1879  *done = 1;
1880  break;
1881  case SDLK_SPACE:
1882  {
1883  char message[256];
1884  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1885 
1886  SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
1888  break;
1889  }
1890  default:
1891  break;
1892  }
1893  break;
1894  }
1895  case SDL_QUIT:
1896  *done = 1;
1897  break;
1898  case SDL_MOUSEMOTION:
1899  lastEvent = event->motion;
1900  break;
1901 
1902  case SDL_DROPFILE:
1903  case SDL_DROPTEXT:
1904  SDL_free(event->drop.file);
1905  break;
1906  }
1907 }

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

836 {
837  int i, j, m, n, w, h;
838  SDL_DisplayMode fullscreen_mode;
839  char text[1024];
840 
841  if (state->flags & SDL_INIT_VIDEO) {
842  if (state->verbose & VERBOSE_VIDEO) {
844  if (n == 0) {
845  SDL_Log("No built-in video drivers\n");
846  } else {
847  SDL_snprintf(text, sizeof(text), "Built-in video drivers:");
848  for (i = 0; i < n; ++i) {
849  if (i > 0) {
850  SDL_snprintfcat(text, sizeof(text), ",");
851  }
852  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetVideoDriver(i));
853  }
854  SDL_Log("%s\n", text);
855  }
856  }
857  if (SDL_VideoInit(state->videodriver) < 0) {
858  SDL_Log("Couldn't initialize video driver: %s\n",
859  SDL_GetError());
860  return SDL_FALSE;
861  }
862  if (state->verbose & VERBOSE_VIDEO) {
863  SDL_Log("Video driver: %s\n",
865  }
866 
867  /* Upload GL settings */
872  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer);
873  SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size);
875  SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size);
876  SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size);
877  SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size);
878  SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size);
879  SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size);
881  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers);
882  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples);
883  if (state->gl_accelerated >= 0) {
885  state->gl_accelerated);
886  }
887  SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing);
888  if (state->gl_major_version) {
891  }
892  if (state->gl_debug) {
894  }
895  if (state->gl_profile_mask) {
897  }
898 
899  if (state->verbose & VERBOSE_MODES) {
900  SDL_Rect bounds, usablebounds;
901  float hdpi = 0;
902  float vdpi = 0;
904  int bpp;
905  Uint32 Rmask, Gmask, Bmask, Amask;
906 #if SDL_VIDEO_DRIVER_WINDOWS
907  int adapterIndex = 0;
908  int outputIndex = 0;
909 #endif
911  SDL_Log("Number of displays: %d\n", n);
912  for (i = 0; i < n; ++i) {
913  SDL_Log("Display %d: %s\n", i, SDL_GetDisplayName(i));
914 
915  SDL_zero(bounds);
916  SDL_GetDisplayBounds(i, &bounds);
917 
918  SDL_zero(usablebounds);
919  SDL_GetDisplayUsableBounds(i, &usablebounds);
920 
921  SDL_GetDisplayDPI(i, NULL, &hdpi, &vdpi);
922 
923  SDL_Log("Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
924  SDL_Log("Usable bounds: %dx%d at %d,%d\n", usablebounds.w, usablebounds.h, usablebounds.x, usablebounds.y);
925  SDL_Log("DPI: %fx%f\n", hdpi, vdpi);
926 
928  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
929  &Bmask, &Amask);
930  SDL_Log(" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
931  mode.w, mode.h, mode.refresh_rate, bpp,
932  SDL_GetPixelFormatName(mode.format));
933  if (Rmask || Gmask || Bmask) {
934  SDL_Log(" Red Mask = 0x%.8x\n", Rmask);
935  SDL_Log(" Green Mask = 0x%.8x\n", Gmask);
936  SDL_Log(" Blue Mask = 0x%.8x\n", Bmask);
937  if (Amask)
938  SDL_Log(" Alpha Mask = 0x%.8x\n", Amask);
939  }
940 
941  /* Print available fullscreen video modes */
943  if (m == 0) {
944  SDL_Log("No available fullscreen video modes\n");
945  } else {
946  SDL_Log(" Fullscreen video modes:\n");
947  for (j = 0; j < m; ++j) {
949  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
950  &Gmask, &Bmask, &Amask);
951  SDL_Log(" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
952  j, mode.w, mode.h, mode.refresh_rate, bpp,
953  SDL_GetPixelFormatName(mode.format));
954  if (Rmask || Gmask || Bmask) {
955  SDL_Log(" Red Mask = 0x%.8x\n",
956  Rmask);
957  SDL_Log(" Green Mask = 0x%.8x\n",
958  Gmask);
959  SDL_Log(" Blue Mask = 0x%.8x\n",
960  Bmask);
961  if (Amask)
962  SDL_Log(" Alpha Mask = 0x%.8x\n",
963  Amask);
964  }
965  }
966  }
967 
968 #if SDL_VIDEO_DRIVER_WINDOWS
969  /* Print the D3D9 adapter index */
970  adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
971  SDL_Log("D3D9 Adapter Index: %d", adapterIndex);
972 
973  /* Print the DXGI adapter and output indices */
974  SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
975  SDL_Log("DXGI Adapter Index: %d Output Index: %d", adapterIndex, outputIndex);
976 #endif
977  }
978  }
979 
980  if (state->verbose & VERBOSE_RENDER) {
981  SDL_RendererInfo info;
982 
984  if (n == 0) {
985  SDL_Log("No built-in render drivers\n");
986  } else {
987  SDL_Log("Built-in render drivers:\n");
988  for (i = 0; i < n; ++i) {
989  SDL_GetRenderDriverInfo(i, &info);
990  SDLTest_PrintRenderer(&info);
991  }
992  }
993  }
994 
995  SDL_zero(fullscreen_mode);
996  switch (state->depth) {
997  case 8:
998  fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
999  break;
1000  case 15:
1001  fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
1002  break;
1003  case 16:
1004  fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
1005  break;
1006  case 24:
1007  fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
1008  break;
1009  default:
1010  fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
1011  break;
1012  }
1013  fullscreen_mode.refresh_rate = state->refresh_rate;
1014 
1015  state->windows =
1016  (SDL_Window **) SDL_calloc(state->num_windows,
1017  sizeof(*state->windows));
1018  state->renderers =
1019  (SDL_Renderer **) SDL_calloc(state->num_windows,
1020  sizeof(*state->renderers));
1021  state->targets =
1022  (SDL_Texture **) SDL_calloc(state->num_windows,
1023  sizeof(*state->targets));
1024  if (!state->windows || !state->renderers) {
1025  SDL_Log("Out of memory!\n");
1026  return SDL_FALSE;
1027  }
1028  for (i = 0; i < state->num_windows; ++i) {
1029  char title[1024];
1030  SDL_Rect r = {
1031  state->window_x, state->window_y,
1032  state->window_w, state->window_h
1033  };
1034 
1035  /* !!! FIXME: hack to make --usable-bounds work for now. */
1036  if ((r.x == -1) && (r.y == -1) && (r.w == -1) && (r.h == -1)) {
1037  SDL_GetDisplayUsableBounds(state->display, &r);
1038  }
1039 
1040  if (state->num_windows > 1) {
1041  SDL_snprintf(title, SDL_arraysize(title), "%s %d",
1042  state->window_title, i + 1);
1043  } else {
1044  SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
1045  }
1046  state->windows[i] =
1047  SDL_CreateWindow(title, r.x, r.y, r.w, r.h, state->window_flags);
1048  if (!state->windows[i]) {
1049  SDL_Log("Couldn't create window: %s\n",
1050  SDL_GetError());
1051  return SDL_FALSE;
1052  }
1053  if (state->window_minW || state->window_minH) {
1054  SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
1055  }
1056  if (state->window_maxW || state->window_maxH) {
1057  SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
1058  }
1059  SDL_GetWindowSize(state->windows[i], &w, &h);
1060  if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
1061  (w != state->window_w || h != state->window_h)) {
1062  printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
1063  state->window_w = w;
1064  state->window_h = h;
1065  }
1066  if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
1067  SDL_Log("Can't set up fullscreen display mode: %s\n",
1068  SDL_GetError());
1069  return SDL_FALSE;
1070  }
1071 
1072  /* Add resize/drag areas for windows that are borderless and resizable */
1073  if ((state->window_flags & (SDL_WINDOW_RESIZABLE|SDL_WINDOW_BORDERLESS)) ==
1076  }
1077 
1078  if (state->window_icon) {
1079  SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
1080  if (icon) {
1081  SDL_SetWindowIcon(state->windows[i], icon);
1082  SDL_FreeSurface(icon);
1083  }
1084  }
1085 
1086  SDL_ShowWindow(state->windows[i]);
1087 
1088  if (!state->skip_renderer
1089  && (state->renderdriver
1090  || !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN)))) {
1091  m = -1;
1092  if (state->renderdriver) {
1093  SDL_RendererInfo info;
1095  for (j = 0; j < n; ++j) {
1096  SDL_GetRenderDriverInfo(j, &info);
1097  if (SDL_strcasecmp(info.name, state->renderdriver) ==
1098  0) {
1099  m = j;
1100  break;
1101  }
1102  }
1103  if (m == -1) {
1104  SDL_Log("Couldn't find render driver named %s",
1105  state->renderdriver);
1106  return SDL_FALSE;
1107  }
1108  }
1109  state->renderers[i] = SDL_CreateRenderer(state->windows[i],
1110  m, state->render_flags);
1111  if (!state->renderers[i]) {
1112  SDL_Log("Couldn't create renderer: %s\n",
1113  SDL_GetError());
1114  return SDL_FALSE;
1115  }
1116  if (state->logical_w && state->logical_h) {
1117  SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
1118  } else if (state->scale != 0.) {
1119  SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
1120  }
1121  if (state->verbose & VERBOSE_RENDER) {
1122  SDL_RendererInfo info;
1123 
1124  SDL_Log("Current renderer:\n");
1125  SDL_GetRendererInfo(state->renderers[i], &info);
1126  SDLTest_PrintRenderer(&info);
1127  }
1128  }
1129  }
1130  }
1131 
1132  if (state->flags & SDL_INIT_AUDIO) {
1133  if (state->verbose & VERBOSE_AUDIO) {
1135  if (n == 0) {
1136  SDL_Log("No built-in audio drivers\n");
1137  } else {
1138  SDL_snprintf(text, sizeof(text), "Built-in audio drivers:");
1139  for (i = 0; i < n; ++i) {
1140  if (i > 0) {
1141  SDL_snprintfcat(text, sizeof(text), ",");
1142  }
1143  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetAudioDriver(i));
1144  }
1145  SDL_Log("%s\n", text);
1146  }
1147  }
1148  if (SDL_AudioInit(state->audiodriver) < 0) {
1149  SDL_Log("Couldn't initialize audio driver: %s\n",
1150  SDL_GetError());
1151  return SDL_FALSE;
1152  }
1153  if (state->verbose & VERBOSE_AUDIO) {
1154  SDL_Log("Audio driver: %s\n",
1156  }
1157 
1158  if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
1159  SDL_Log("Couldn't open audio: %s\n", SDL_GetError());
1160  return SDL_FALSE;
1161  }
1162  }
1163 
1164  return SDL_TRUE;
1165 }

References bpp, 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 498 of file SDL_test_common.c.

499 {
500  int i;
501 
502  SDL_Log("USAGE: %s", argv0);
503  SDL_Log(" %s", "[--trackmem]");
504 
505  if (state->flags & SDL_INIT_VIDEO) {
506  for (i = 0; i < SDL_arraysize(video_usage); i++) {
507  SDL_Log(" %s", video_usage[i]);
508  }
509  }
510 
511  if (state->flags & SDL_INIT_AUDIO) {
512  for (i = 0; i < SDL_arraysize(audio_usage); i++) {
513  SDL_Log(" %s", audio_usage[i]);
514  }
515  }
516 
517  if (options) {
518  for (i = 0; options[i] != NULL; i++) {
519  SDL_Log(" %s", options[i]);
520  }
521  }
522 }

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

1911 {
1912  int i;
1913 
1920 
1921  SDL_free(state->windows);
1922  if (state->targets) {
1923  for (i = 0; i < state->num_windows; ++i) {
1924  if (state->targets[i]) {
1925  SDL_DestroyTexture(state->targets[i]);
1926  }
1927  }
1928  SDL_free(state->targets);
1929  }
1930  if (state->renderers) {
1931  for (i = 0; i < state->num_windows; ++i) {
1932  if (state->renderers[i]) {
1933  SDL_DestroyRenderer(state->renderers[i]);
1934  }
1935  }
1936  SDL_free(state->renderers);
1937  }
1938  if (state->flags & SDL_INIT_VIDEO) {
1939  SDL_VideoQuit();
1940  }
1941  if (state->flags & SDL_INIT_AUDIO) {
1942  SDL_AudioQuit();
1943  }
1944  SDL_free(state);
1945  SDL_Quit();
1947 }

References common_usage_audio, common_usage_video, common_usage_videoaudio, i, NULL, 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().

◆ SDLTest_CommonUsage()

const char* SDLTest_CommonUsage ( SDLTest_CommonState state)

Returns common usage information.

You should (probably) be using SDLTest_CommonLogUsage() instead, but this function remains for binary compatibility. Strings returned from this function are valid until SDLTest_CommonQuit() is called, in which case those strings' memory is freed and can no longer be used.

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

Definition at line 567 of file SDL_test_common.c.

References audio_usage, BuildCommonUsageString(), common_usage_audio, common_usage_video, common_usage_videoaudio, NULL, SDL_arraysize, SDL_INIT_AUDIO, SDL_INIT_VIDEO, state, and video_usage.

SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:418
SDL_WINDOW_MOUSE_CAPTURE
@ SDL_WINDOW_MOUSE_CAPTURE
Definition: SDL_video.h:115
SDL_GetWindowDisplayIndex
#define SDL_GetWindowDisplayIndex
Definition: SDL_dynapi_overrides.h:510
SDLK_SPACE
@ SDLK_SPACE
Definition: SDL_keycode.h:58
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
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
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
@ SDL_WINDOW_ALLOW_HIGHDPI
Definition: SDL_video.h:112
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_RETAINED_BACKING
@ SDL_GL_RETAINED_BACKING
Definition: SDL_video.h:215
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:660
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
SDL_WINDOWPOS_CENTERED
#define SDL_WINDOWPOS_CENTERED
Definition: SDL_video.h:138
SDL_WINDOW_MINIMIZED
@ SDL_WINDOW_MINIMIZED
Definition: SDL_video.h:105
SDL_PIXELFORMAT_RGB888
@ SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:239
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
NULL
#define NULL
Definition: begin_code.h:167
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1112
message
GLuint GLsizei const GLchar * message
Definition: SDL_opengl_glext.h:2486
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:498
SDL_GL_ACCELERATED_VISUAL
@ SDL_GL_ACCELERATED_VISUAL
Definition: SDL_video.h:214
SDLTest_CommonState
Definition: SDL_test_common.h:51
SDL_WINDOWEVENT_CLOSE
@ SDL_WINDOWEVENT_CLOSE
Definition: SDL_video.h:166
mode
GLenum mode
Definition: SDL_opengl_glext.h:1125
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
SDLK_ESCAPE
@ SDLK_ESCAPE
Definition: SDL_keycode.h:55
SDL_SetWindowFullscreen
#define SDL_SetWindowFullscreen
Definition: SDL_dynapi_overrides.h:539
SDL_GL_MULTISAMPLEBUFFERS
@ SDL_GL_MULTISAMPLEBUFFERS
Definition: SDL_video.h:212
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:1520
SDL_WINDOW_FULLSCREEN
@ SDL_WINDOW_FULLSCREEN
Definition: SDL_video.h:99
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
SDL_WINDOW_OPENGL
@ SDL_WINDOW_OPENGL
Definition: SDL_video.h:100
SDL_BUTTON_X2MASK
#define SDL_BUTTON_X2MASK
Definition: SDL_mouse.h:291
SDL_LOG_CATEGORY_INPUT
@ SDL_LOG_CATEGORY_INPUT
Definition: SDL_log.h:73
SDL_WINDOW_FULLSCREEN_DESKTOP
@ SDL_WINDOW_FULLSCREEN_DESKTOP
Definition: SDL_video.h:110
SDL_WINDOWPOS_UNDEFINED
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:129
SDL_GetDesktopDisplayMode
#define SDL_GetDesktopDisplayMode
Definition: SDL_dynapi_overrides.h:507
SDLK_z
@ SDLK_z
Definition: SDL_keycode.h:125
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_ACCUM_GREEN_SIZE
@ SDL_GL_ACCUM_GREEN_SIZE
Definition: SDL_video.h:208
SDL_WINDOWPOS_ISCENTERED
#define SDL_WINDOWPOS_ISCENTERED(X)
Definition: SDL_video.h:139
SDL_PIXELFORMAT_RGB565
@ SDL_PIXELFORMAT_RGB565
Definition: SDL_pixels.h:227
SDL_WINDOW_MAXIMIZED
@ SDL_WINDOW_MAXIMIZED
Definition: SDL_video.h:106
VERBOSE_MODES
#define VERBOSE_MODES
Definition: SDL_test_common.h:46
index
GLuint index
Definition: SDL_opengl_glext.h:663
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
@ SDL_KEYDOWN
Definition: SDL_events.h:96
SDL_CreateWindow
#define SDL_CreateWindow
Definition: SDL_dynapi_overrides.h:514
SDL_GL_CONTEXT_MINOR_VERSION
@ SDL_GL_CONTEXT_MINOR_VERSION
Definition: SDL_video.h:217
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1949
SDL_GL_CONTEXT_FLAGS
@ SDL_GL_CONTEXT_FLAGS
Definition: SDL_video.h:219
SDL_Rect::x
int x
Definition: SDL_rect.h:79
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
SDL_WINDOW_RESIZABLE
@ SDL_WINDOW_RESIZABLE
Definition: SDL_video.h:104
video_usage
static const char * video_usage[]
Definition: SDL_test_common.c:29
SDL_Rect::w
int w
Definition: SDL_rect.h:80
SDLK_1
@ SDLK_1
Definition: SDL_keycode.h:75
SDL_SetRelativeMouseMode
#define SDL_SetRelativeMouseMode
Definition: SDL_dynapi_overrides.h:249
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:74
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:1955
SDLK_r
@ SDLK_r
Definition: SDL_keycode.h:117
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:769
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
AUDIO_U8
#define AUDIO_U8
Definition: SDL_audio.h:89
SDL_MinimizeWindow
#define SDL_MinimizeWindow
Definition: SDL_dynapi_overrides.h:537
SDLK_c
@ SDLK_c
Definition: SDL_keycode.h:102
SDL_GL_ALPHA_SIZE
@ SDL_GL_ALPHA_SIZE
Definition: SDL_video.h:202
SDL_GL_CONTEXT_DEBUG_FLAG
@ SDL_GL_CONTEXT_DEBUG_FLAG
Definition: SDL_video.h:237
SDL_ShowSimpleMessageBox
#define SDL_ShowSimpleMessageBox
Definition: SDL_dynapi_overrides.h:244
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2652
SDL_Renderer
Definition: SDL_sysrender.h:109
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
done
int done
Definition: checkkeys.c:28
SDL_MOUSEMOTION
@ SDL_MOUSEMOTION
Definition: SDL_events.h:105
common_usage_audio
static char * common_usage_audio
Definition: SDL_test_common.c:563
SDLK_MINUS
@ SDLK_MINUS
Definition: SDL_keycode.h:71
SDL_LOG_CATEGORY_ERROR
@ SDL_LOG_CATEGORY_ERROR
Definition: SDL_log.h:67
SDL_SetWindowGrab
#define SDL_SetWindowGrab
Definition: SDL_dynapi_overrides.h:543
SDLK_m
@ SDLK_m
Definition: SDL_keycode.h:112
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
SDL_GL_ACCUM_ALPHA_SIZE
@ SDL_GL_ACCUM_ALPHA_SIZE
Definition: SDL_video.h:210
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
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_GREEN_SIZE
@ SDL_GL_GREEN_SIZE
Definition: SDL_video.h:200
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_MouseMotionEvent::xrel
Sint32 xrel
Definition: SDL_events.h:262
SDL_DROPTEXT
@ SDL_DROPTEXT
Definition: SDL_events.h:142
SDL_GL_ACCUM_BLUE_SIZE
@ SDL_GL_ACCUM_BLUE_SIZE
Definition: SDL_video.h:209
SDLTest_PrintRenderer
static void SDLTest_PrintRenderer(SDL_RendererInfo *info)
Definition: SDL_test_common.c:730
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
@ SDL_QUIT
Definition: SDL_events.h:60
SDL_GL_BUFFER_SIZE
@ SDL_GL_BUFFER_SIZE
Definition: SDL_video.h:203
SDL_GL_STEREO
@ SDL_GL_STEREO
Definition: SDL_video.h:211
SDLK_PRINTSCREEN
@ SDLK_PRINTSCREEN
Definition: SDL_keycode.h:142
SDL_DisplayMode::refresh_rate
int refresh_rate
Definition: SDL_video.h:58
SDL_RENDERER_PRESENTVSYNC
@ SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
SDL_WINDOWPOS_UNDEFINED_DISPLAY
#define SDL_WINDOWPOS_UNDEFINED_DISPLAY(X)
Definition: SDL_video.h:128
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
BuildCommonUsageString
static const char * BuildCommonUsageString(char **pstr, const char **strlist, const int numitems, const char **strlist2, const int numitems2)
Definition: SDL_test_common.c:525
SDL_FreeSurface
#define SDL_FreeSurface
Definition: SDL_dynapi_overrides.h:446
SDL_isdigit
#define SDL_isdigit
Definition: SDL_dynapi_overrides.h:382
SDLK_a
@ SDLK_a
Definition: SDL_keycode.h:100
Uint16
uint16_t Uint16
Definition: SDL_stdinc.h:191
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
common_usage_video
static char * common_usage_video
Definition: SDL_test_common.c:562
SDL_Quit
#define SDL_Quit
Definition: SDL_dynapi_overrides.h:58
SDL_GetWindowPosition
#define SDL_GetWindowPosition
Definition: SDL_dynapi_overrides.h:525
text
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
SDL_WINDOW_INPUT_GRABBED
@ SDL_WINDOW_INPUT_GRABBED
Definition: SDL_video.h:107
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:789
SDL_BUTTON_X1MASK
#define SDL_BUTTON_X1MASK
Definition: SDL_mouse.h:290
SDL_SetWindowOpacity
#define SDL_SetWindowOpacity
Definition: SDL_dynapi_overrides.h:598
SDL_WINDOWPOS_CENTERED_DISPLAY
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X)
Definition: SDL_video.h:137
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
SDLK_0
@ SDLK_0
Definition: SDL_keycode.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
@ SDL_MESSAGEBOX_INFORMATION
Definition: SDL_messagebox.h:41
VERBOSE_RENDER
#define VERBOSE_RENDER
Definition: SDL_test_common.h:47
SDL_GL_CONTEXT_MAJOR_VERSION
@ SDL_GL_CONTEXT_MAJOR_VERSION
Definition: SDL_video.h:216
SDL_GL_ACCUM_RED_SIZE
@ SDL_GL_ACCUM_RED_SIZE
Definition: SDL_video.h:207
SDL_GL_CONTEXT_PROFILE_MASK
@ SDL_GL_CONTEXT_PROFILE_MASK
Definition: SDL_video.h:220
SDL_GetWindowOpacity
#define SDL_GetWindowOpacity
Definition: SDL_dynapi_overrides.h:599
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_GetVideoDriver
#define SDL_GetVideoDriver
Definition: SDL_dynapi_overrides.h:497
SDL_RenderSetScale
#define SDL_RenderSetScale
Definition: SDL_dynapi_overrides.h:328
bpp
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp
Definition: pixman-arm-neon-asm.h:146
SDLK_LEFT
@ SDLK_LEFT
Definition: SDL_keycode.h:152
SDL_GL_DEPTH_SIZE
@ SDL_GL_DEPTH_SIZE
Definition: SDL_video.h:205
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
@ SDL_PIXELFORMAT_RGB555
Definition: SDL_pixels.h:197
m
const GLfloat * m
Definition: SDL_opengl_glext.h:6095
common_usage_videoaudio
static char * common_usage_videoaudio
Definition: SDL_test_common.c:564
SDL_INIT_VIDEO
#define SDL_INIT_VIDEO
Definition: SDL.h:80
SDLK_g
@ SDLK_g
Definition: SDL_keycode.h:106
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
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
SDLK_RETURN
@ SDLK_RETURN
Definition: SDL_keycode.h:54
SDL_SetWindowBordered
#define SDL_SetWindowBordered
Definition: SDL_dynapi_overrides.h:532
AUDIO_S16
#define AUDIO_S16
Definition: SDL_audio.h:96
SDL_GL_RED_SIZE
@ SDL_GL_RED_SIZE
Definition: SDL_video.h:199
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
VERBOSE_AUDIO
#define VERBOSE_AUDIO
Definition: SDL_test_common.h:49
KMOD_ALT
#define KMOD_ALT
Definition: SDL_keycode.h:344
SDL_Texture
Definition: SDL_sysrender.h:36
SDL_PIXELFORMAT_RGB24
@ SDL_PIXELFORMAT_RGB24
Definition: SDL_pixels.h:233
SDL_LOG_PRIORITY_VERBOSE
@ SDL_LOG_PRIORITY_VERBOSE
Definition: SDL_log.h:104
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
SDL_LOG_CATEGORY_SYSTEM
@ SDL_LOG_CATEGORY_SYSTEM
Definition: SDL_log.h:69
SDL_GL_DOUBLEBUFFER
@ SDL_GL_DOUBLEBUFFER
Definition: SDL_video.h:204
SDLK_RIGHT
@ SDLK_RIGHT
Definition: SDL_keycode.h:151
SDLK_o
@ SDLK_o
Definition: SDL_keycode.h:114
SDL_GL_STENCIL_SIZE
@ SDL_GL_STENCIL_SIZE
Definition: SDL_video.h:206
SDL_GetGlobalMouseState
#define SDL_GetGlobalMouseState
Definition: SDL_dynapi_overrides.h:586
SDL_CaptureMouse
#define SDL_CaptureMouse
Definition: SDL_dynapi_overrides.h:584
SDL_LOG_CATEGORY_AUDIO
@ SDL_LOG_CATEGORY_AUDIO
Definition: SDL_log.h:70
SDLTest_PrintEvent
static void SDLTest_PrintEvent(SDL_Event *event)
Definition: SDL_test_common.c:1229
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_GL_BLUE_SIZE
@ SDL_GL_BLUE_SIZE
Definition: SDL_video.h:201
SDL_VideoQuit
#define SDL_VideoQuit
Definition: SDL_dynapi_overrides.h:499
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
SDL_WINDOWEVENT
@ SDL_WINDOWEVENT
Definition: SDL_events.h:92
AUDIO_S8
#define AUDIO_S8
Definition: SDL_audio.h:90
SDL_PIXELFORMAT_INDEX8
@ SDL_PIXELFORMAT_INDEX8
Definition: SDL_pixels.h:186
SDL_LogSetAllPriority
#define SDL_LogSetAllPriority
Definition: SDL_dynapi_overrides.h:235
SDL_MouseMotionEvent::yrel
Sint32 yrel
Definition: SDL_events.h:263
SDL_CreateRenderer
#define SDL_CreateRenderer
Definition: SDL_dynapi_overrides.h:301
SDL_RenderSetClipRect
#define SDL_RenderSetClipRect
Definition: SDL_dynapi_overrides.h:326
SDLK_b
@ SDLK_b
Definition: SDL_keycode.h:101
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
SDLK_UP
@ SDLK_UP
Definition: SDL_keycode.h:154
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1483
VERBOSE_EVENT
#define VERBOSE_EVENT
Definition: SDL_test_common.h:48
SDL_DestroyRenderer
#define SDL_DestroyRenderer
Definition: SDL_dynapi_overrides.h:348
SDLK_EQUALS
@ SDLK_EQUALS
Definition: SDL_keycode.h:87
SDL_GetNumDisplayModes
#define SDL_GetNumDisplayModes
Definition: SDL_dynapi_overrides.h:505
SDL_SetWindowPosition
#define SDL_SetWindowPosition
Definition: SDL_dynapi_overrides.h:524
SDLK_2
@ SDLK_2
Definition: SDL_keycode.h:76
FullscreenTo
static void FullscreenTo(int index, int windowId)
Definition: SDL_test_common.c:1557
state
struct xkb_state * state
Definition: SDL_waylandsym.h:114
AUDIO_U16MSB
#define AUDIO_U16MSB
Definition: SDL_audio.h:93
audio_usage
static const char * audio_usage[]
Definition: SDL_test_common.c:41
SDLK_v
@ SDLK_v
Definition: SDL_keycode.h:121
SDL_LOG_CATEGORY_RENDER
@ SDL_LOG_CATEGORY_RENDER
Definition: SDL_log.h:72
AUDIO_U16
#define AUDIO_U16
Definition: SDL_audio.h:95
SDL_BUTTON_MMASK
#define SDL_BUTTON_MMASK
Definition: SDL_mouse.h:288
SDL_DROPFILE
@ 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
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
SDL_WINDOWPOS_ISUNDEFINED
#define SDL_WINDOWPOS_ISUNDEFINED(X)
Definition: SDL_video.h:130
SDLK_DOWN
@ SDLK_DOWN
Definition: SDL_keycode.h:153
SDL_GetNumAudioDrivers
#define SDL_GetNumAudioDrivers
Definition: SDL_dynapi_overrides.h:73
SDL_GL_MULTISAMPLESAMPLES
@ SDL_GL_MULTISAMPLESAMPLES
Definition: SDL_video.h:213
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:161
SDL_WINDOW_BORDERLESS
@ SDL_WINDOW_BORDERLESS
Definition: SDL_video.h:103
SDL_LOG_CATEGORY_VIDEO
@ SDL_LOG_CATEGORY_VIDEO
Definition: SDL_log.h:71
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:734
SDL_GetRendererInfo
#define SDL_GetRendererInfo
Definition: SDL_dynapi_overrides.h:304
SDL_WINDOW_VULKAN
@ SDL_WINDOW_VULKAN
Definition: SDL_video.h:121
SDL_INIT_AUDIO
#define SDL_INIT_AUDIO
Definition: SDL.h:79
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179