SDL  2.0
SDL_test_common.c File Reference
#include "SDL_config.h"
#include "SDL_test.h"
#include <stdio.h>
+ Include dependency graph for SDL_test_common.c:

Go to the source code of this file.

Macros

#define VIDEO_USAGE   "[--video driver] [--renderer driver] [--gldebug] [--info all|video|modes|render|event] [--log all|error|system|audio|video|render|input] [--display N] [--fullscreen | --fullscreen-desktop | --windows N] [--title title] [--icon icon.bmp] [--center | --position X,Y] [--geometry WxH] [--min-geometry WxH] [--max-geometry WxH] [--logical WxH] [--scale N] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab] [--allow-highdpi]"
 
#define AUDIO_USAGE   "[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"
 
#define AXIS_CASE(ax)   case SDL_CONTROLLER_AXIS_##ax: return #ax
 
#define BUTTON_CASE(btn)   case SDL_CONTROLLER_BUTTON_##btn: return #btn
 

Functions

SDLTest_CommonStateSDLTest_CommonCreateState (char **argv, Uint32 flags)
 Parse command line parameters and create common state. More...
 
int SDLTest_CommonArg (SDLTest_CommonState *state, int index)
 Process one common argument. More...
 
const char * SDLTest_CommonUsage (SDLTest_CommonState *state)
 Returns common usage information. More...
 
static void SDLTest_PrintRendererFlag (Uint32 flag)
 
static void SDLTest_PrintPixelFormat (Uint32 format)
 
static void SDLTest_PrintRenderer (SDL_RendererInfo *info)
 
static SDL_SurfaceSDLTest_LoadIcon (const char *file)
 
SDL_bool SDLTest_CommonInit (SDLTest_CommonState *state)
 Open test window. More...
 
static const char * ControllerAxisName (const SDL_GameControllerAxis axis)
 
static const char * ControllerButtonName (const SDL_GameControllerButton button)
 
static void SDLTest_PrintEvent (SDL_Event *event)
 
static void SDLTest_ScreenShot (SDL_Renderer *renderer)
 
static void FullscreenTo (int index, int windowId)
 
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...
 

Macro Definition Documentation

◆ AUDIO_USAGE

#define AUDIO_USAGE   "[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"

Definition at line 32 of file SDL_test_common.c.

Referenced by SDLTest_CommonUsage().

◆ AXIS_CASE

#define AXIS_CASE (   ax)    case SDL_CONTROLLER_AXIS_##ax: return #ax

Referenced by ControllerAxisName().

◆ BUTTON_CASE

#define BUTTON_CASE (   btn)    case SDL_CONTROLLER_BUTTON_##btn: return #btn

Referenced by ControllerButtonName().

◆ VIDEO_USAGE

#define VIDEO_USAGE   "[--video driver] [--renderer driver] [--gldebug] [--info all|video|modes|render|event] [--log all|error|system|audio|video|render|input] [--display N] [--fullscreen | --fullscreen-desktop | --windows N] [--title title] [--icon icon.bmp] [--center | --position X,Y] [--geometry WxH] [--min-geometry WxH] [--max-geometry WxH] [--logical WxH] [--scale N] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab] [--allow-highdpi]"

Definition at line 29 of file SDL_test_common.c.

Referenced by SDLTest_CommonUsage().

Function Documentation

◆ ControllerAxisName()

static const char* ControllerAxisName ( const SDL_GameControllerAxis  axis)
static

Definition at line 961 of file SDL_test_common.c.

References AXIS_CASE.

Referenced by SDLTest_PrintEvent().

962 {
963  switch (axis)
964  {
965 #define AXIS_CASE(ax) case SDL_CONTROLLER_AXIS_##ax: return #ax
966  AXIS_CASE(INVALID);
967  AXIS_CASE(LEFTX);
968  AXIS_CASE(LEFTY);
969  AXIS_CASE(RIGHTX);
970  AXIS_CASE(RIGHTY);
971  AXIS_CASE(TRIGGERLEFT);
972  AXIS_CASE(TRIGGERRIGHT);
973 #undef AXIS_CASE
974 default: return "???";
975  }
976 }
#define AXIS_CASE(ax)
SDL_Texture * axis

◆ ControllerButtonName()

static const char* ControllerButtonName ( const SDL_GameControllerButton  button)
static

Definition at line 979 of file SDL_test_common.c.

References BUTTON_CASE.

Referenced by SDLTest_PrintEvent().

980 {
981  switch (button)
982  {
983 #define BUTTON_CASE(btn) case SDL_CONTROLLER_BUTTON_##btn: return #btn
984  BUTTON_CASE(INVALID);
985  BUTTON_CASE(A);
986  BUTTON_CASE(B);
987  BUTTON_CASE(X);
988  BUTTON_CASE(Y);
989  BUTTON_CASE(BACK);
990  BUTTON_CASE(GUIDE);
991  BUTTON_CASE(START);
992  BUTTON_CASE(LEFTSTICK);
993  BUTTON_CASE(RIGHTSTICK);
994  BUTTON_CASE(LEFTSHOULDER);
995  BUTTON_CASE(RIGHTSHOULDER);
996  BUTTON_CASE(DPAD_UP);
997  BUTTON_CASE(DPAD_DOWN);
998  BUTTON_CASE(DPAD_LEFT);
999  BUTTON_CASE(DPAD_RIGHT);
1000 #undef BUTTON_CASE
1001 default: return "???";
1002  }
1003 }
SDL_Texture * button
#define BUTTON_CASE(btn)

◆ FullscreenTo()

static void FullscreenTo ( int  index,
int  windowId 
)
static

Definition at line 1279 of file SDL_test_common.c.

References SDL_Delay, SDL_FALSE, SDL_GetDisplayBounds, SDL_GetWindowFlags, SDL_GetWindowFromID, SDL_SetWindowFullscreen, SDL_SetWindowPosition, SDL_TRUE, SDL_WINDOW_FULLSCREEN, window, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDLTest_CommonEvent().

1280 {
1281  Uint32 flags;
1282  struct SDL_Rect rect = { 0, 0, 0, 0 };
1283  SDL_Window *window = SDL_GetWindowFromID(windowId);
1284  if (!window) {
1285  return;
1286  }
1287 
1288  SDL_GetDisplayBounds( index, &rect );
1289 
1290  flags = SDL_GetWindowFlags(window);
1291  if (flags & SDL_WINDOW_FULLSCREEN) {
1293  SDL_Delay( 15 );
1294  }
1295 
1296  SDL_SetWindowPosition( window, rect.x, rect.y );
1297  SDL_SetWindowFullscreen( window, SDL_TRUE );
1298 }
#define SDL_SetWindowFullscreen
SDL_Rect rect
Definition: testrelative.c:27
static SDL_Window * window
#define SDL_GetWindowFlags
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:161
#define SDL_GetDisplayBounds
int x
Definition: SDL_rect.h:66
#define SDL_GetWindowFromID
GLuint index
#define SDL_Delay
The type used to identify a window.
Definition: SDL_sysvideo.h:71
GLbitfield flags
int y
Definition: SDL_rect.h:66
#define SDL_SetWindowPosition
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64

◆ SDLTest_CommonArg()

int SDLTest_CommonArg ( SDLTest_CommonState state,
int  index 
)

Process one common argument.

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

Definition at line 83 of file SDL_test_common.c.

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

Referenced by main().

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

◆ SDLTest_CommonCreateState()

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

Parse command line parameters and create common state.

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

Definition at line 36 of file SDL_test_common.c.

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

Referenced by main().

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

◆ SDLTest_CommonEvent()

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

Common event handler for test windows.

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

Definition at line 1301 of file SDL_test_common.c.

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

Referenced by loop(), and main().

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

◆ SDLTest_CommonInit()

SDL_bool SDLTest_CommonInit ( SDLTest_CommonState state)

Open test window.

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

Definition at line 645 of file SDL_test_common.c.

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

Referenced by main().

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

◆ SDLTest_CommonQuit()

void SDLTest_CommonQuit ( SDLTest_CommonState state)

Close test window.

Parameters
stateThe common state used to create test window.

Definition at line 1584 of file SDL_test_common.c.

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

Referenced by main(), and quit().

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

◆ SDLTest_CommonUsage()

const char* SDLTest_CommonUsage ( SDLTest_CommonState state)

Returns common usage information.

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

Definition at line 451 of file SDL_test_common.c.

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

Referenced by main().

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

◆ SDLTest_LoadIcon()

static SDL_Surface* SDLTest_LoadIcon ( const char *  file)
static

Definition at line 625 of file SDL_test_common.c.

References SDL_Surface::format, NULL, SDL_PixelFormat::palette, SDL_Surface::pixels, SDL_GetError, SDL_LoadBMP, and SDL_SetColorKey.

Referenced by SDLTest_CommonInit().

626 {
627  SDL_Surface *icon;
628 
629  /* Load the icon surface */
630  icon = SDL_LoadBMP(file);
631  if (icon == NULL) {
632  fprintf(stderr, "Couldn't load %s: %s\n", file, SDL_GetError());
633  return (NULL);
634  }
635 
636  if (icon->format->palette) {
637  /* Set the colorkey */
638  SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels));
639  }
640 
641  return (icon);
642 }
#define SDL_GetError
#define SDL_LoadBMP(file)
Definition: SDL_surface.h:186
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
void * pixels
Definition: SDL_surface.h:75
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:143
#define SDL_SetColorKey
#define NULL
Definition: begin_code.h:143
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_Palette * palette
Definition: SDL_pixels.h:316

◆ SDLTest_PrintEvent()

static void SDLTest_PrintEvent ( SDL_Event event)
static

Definition at line 1006 of file SDL_test_common.c.

References SDL_ControllerAxisEvent::axis, SDL_JoyBallEvent::ball, SDL_MouseButtonEvent::button, SDL_JoyButtonEvent::button, SDL_ControllerButtonEvent::button, SDL_Event::button, SDL_Event::caxis, SDL_Event::cbutton, SDL_Event::cdevice, SDL_MouseButtonEvent::clicks, SDL_UserEvent::code, ControllerAxisName(), ControllerButtonName(), SDL_WindowEvent::data1, SDL_WindowEvent::data2, SDL_Event::dgesture, SDL_MouseWheelEvent::direction, SDL_TouchFingerEvent::dx, SDL_TouchFingerEvent::dy, SDL_WindowEvent::event, SDL_TouchFingerEvent::fingerId, SDL_DollarGestureEvent::gestureId, SDL_JoyHatEvent::hat, SDL_Event::jball, SDL_Event::jbutton, SDL_Event::jdevice, SDL_Event::jhat, SDL_Event::key, SDL_KeyboardEvent::keysym, SDL_Event::mgesture, SDL_Event::motion, SDL_MultiGestureEvent::numFingers, SDL_TouchFingerEvent::pressure, SDL_Keysym::scancode, SDL_CLIPBOARDUPDATE, SDL_CONTROLLERAXISMOTION, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, SDL_DOLLARGESTURE, SDL_DOLLARRECORD, SDL_FINGERDOWN, SDL_FINGERMOTION, SDL_FINGERUP, SDL_GetKeyName, SDL_GetScancodeName, SDL_HAT_CENTERED, SDL_HAT_DOWN, SDL_HAT_LEFT, SDL_HAT_LEFTDOWN, SDL_HAT_LEFTUP, SDL_HAT_RIGHT, SDL_HAT_RIGHTDOWN, SDL_HAT_RIGHTUP, SDL_HAT_UP, SDL_JOYBALLMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED, SDL_JOYHATMOTION, SDL_KEYDOWN, SDL_KEYUP, SDL_Log, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEMOTION, SDL_MOUSEWHEEL, SDL_MULTIGESTURE, SDL_PRIs64, SDL_QUIT, SDL_RENDER_DEVICE_RESET, SDL_RENDER_TARGETS_RESET, SDL_TEXTINPUT, SDL_USEREVENT, SDL_WINDOWEVENT, SDL_WINDOWEVENT_CLOSE, SDL_WINDOWEVENT_ENTER, SDL_WINDOWEVENT_EXPOSED, SDL_WINDOWEVENT_FOCUS_GAINED, SDL_WINDOWEVENT_FOCUS_LOST, SDL_WINDOWEVENT_HIDDEN, SDL_WINDOWEVENT_HIT_TEST, SDL_WINDOWEVENT_LEAVE, SDL_WINDOWEVENT_MAXIMIZED, SDL_WINDOWEVENT_MINIMIZED, SDL_WINDOWEVENT_MOVED, SDL_WINDOWEVENT_RESIZED, SDL_WINDOWEVENT_RESTORED, SDL_WINDOWEVENT_SHOWN, SDL_WINDOWEVENT_SIZE_CHANGED, SDL_WINDOWEVENT_TAKE_FOCUS, SDL_Keysym::sym, SDL_TextInputEvent::text, SDL_Event::text, SDL_Event::tfinger, SDL_TouchFingerEvent::touchId, SDL_Event::type, SDL_Event::user, SDL_JoyHatEvent::value, SDL_ControllerAxisEvent::value, SDL_Event::wheel, SDL_JoyBallEvent::which, SDL_JoyHatEvent::which, SDL_JoyButtonEvent::which, SDL_JoyDeviceEvent::which, SDL_ControllerAxisEvent::which, SDL_ControllerButtonEvent::which, SDL_ControllerDeviceEvent::which, SDL_Event::window, SDL_WindowEvent::windowID, SDL_KeyboardEvent::windowID, SDL_TextInputEvent::windowID, SDL_MouseMotionEvent::windowID, SDL_MouseButtonEvent::windowID, SDL_MouseWheelEvent::windowID, SDL_MouseMotionEvent::x, SDL_MouseButtonEvent::x, SDL_MouseWheelEvent::x, SDL_TouchFingerEvent::x, SDL_MouseMotionEvent::xrel, SDL_JoyBallEvent::xrel, SDL_MouseMotionEvent::y, SDL_MouseButtonEvent::y, SDL_MouseWheelEvent::y, SDL_TouchFingerEvent::y, SDL_MouseMotionEvent::yrel, and SDL_JoyBallEvent::yrel.

Referenced by SDLTest_CommonEvent().

1007 {
1008  if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) {
1009  /* Mouse and finger motion are really spammy */
1010  return;
1011  }
1012 
1013  switch (event->type) {
1014  case SDL_WINDOWEVENT:
1015  switch (event->window.event) {
1016  case SDL_WINDOWEVENT_SHOWN:
1017  SDL_Log("SDL EVENT: Window %d shown", event->window.windowID);
1018  break;
1020  SDL_Log("SDL EVENT: Window %d hidden", event->window.windowID);
1021  break;
1023  SDL_Log("SDL EVENT: Window %d exposed", event->window.windowID);
1024  break;
1025  case SDL_WINDOWEVENT_MOVED:
1026  SDL_Log("SDL EVENT: Window %d moved to %d,%d",
1027  event->window.windowID, event->window.data1,
1028  event->window.data2);
1029  break;
1031  SDL_Log("SDL EVENT: Window %d resized to %dx%d",
1032  event->window.windowID, event->window.data1,
1033  event->window.data2);
1034  break;
1036  SDL_Log("SDL EVENT: Window %d changed size to %dx%d",
1037  event->window.windowID, event->window.data1,
1038  event->window.data2);
1039  break;
1041  SDL_Log("SDL EVENT: Window %d minimized", event->window.windowID);
1042  break;
1044  SDL_Log("SDL EVENT: Window %d maximized", event->window.windowID);
1045  break;
1047  SDL_Log("SDL EVENT: Window %d restored", event->window.windowID);
1048  break;
1049  case SDL_WINDOWEVENT_ENTER:
1050  SDL_Log("SDL EVENT: Mouse entered window %d",
1051  event->window.windowID);
1052  break;
1053  case SDL_WINDOWEVENT_LEAVE:
1054  SDL_Log("SDL EVENT: Mouse left window %d", event->window.windowID);
1055  break;
1057  SDL_Log("SDL EVENT: Window %d gained keyboard focus",
1058  event->window.windowID);
1059  break;
1061  SDL_Log("SDL EVENT: Window %d lost keyboard focus",
1062  event->window.windowID);
1063  break;
1064  case SDL_WINDOWEVENT_CLOSE:
1065  SDL_Log("SDL EVENT: Window %d closed", event->window.windowID);
1066  break;
1068  SDL_Log("SDL EVENT: Window %d take focus", event->window.windowID);
1069  break;
1071  SDL_Log("SDL EVENT: Window %d hit test", event->window.windowID);
1072  break;
1073  default:
1074  SDL_Log("SDL EVENT: Window %d got unknown event %d",
1075  event->window.windowID, event->window.event);
1076  break;
1077  }
1078  break;
1079  case SDL_KEYDOWN:
1080  SDL_Log("SDL EVENT: Keyboard: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1081  event->key.windowID,
1082  event->key.keysym.scancode,
1084  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1085  break;
1086  case SDL_KEYUP:
1087  SDL_Log("SDL EVENT: Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1088  event->key.windowID,
1089  event->key.keysym.scancode,
1091  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1092  break;
1093  case SDL_TEXTINPUT:
1094  SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %d",
1095  event->text.text, event->text.windowID);
1096  break;
1097  case SDL_MOUSEMOTION:
1098  SDL_Log("SDL EVENT: Mouse: moved to %d,%d (%d,%d) in window %d",
1099  event->motion.x, event->motion.y,
1100  event->motion.xrel, event->motion.yrel,
1101  event->motion.windowID);
1102  break;
1103  case SDL_MOUSEBUTTONDOWN:
1104  SDL_Log("SDL EVENT: Mouse: button %d pressed at %d,%d with click count %d in window %d",
1105  event->button.button, event->button.x, event->button.y, event->button.clicks,
1106  event->button.windowID);
1107  break;
1108  case SDL_MOUSEBUTTONUP:
1109  SDL_Log("SDL EVENT: Mouse: button %d released at %d,%d with click count %d in window %d",
1110  event->button.button, event->button.x, event->button.y, event->button.clicks,
1111  event->button.windowID);
1112  break;
1113  case SDL_MOUSEWHEEL:
1114  SDL_Log("SDL EVENT: Mouse: wheel scrolled %d in x and %d in y (reversed: %d) in window %d",
1115  event->wheel.x, event->wheel.y, event->wheel.direction, event->wheel.windowID);
1116  break;
1117  case SDL_JOYDEVICEADDED:
1118  SDL_Log("SDL EVENT: Joystick index %d attached",
1119  event->jdevice.which);
1120  break;
1121  case SDL_JOYDEVICEREMOVED:
1122  SDL_Log("SDL EVENT: Joystick %d removed",
1123  event->jdevice.which);
1124  break;
1125  case SDL_JOYBALLMOTION:
1126  SDL_Log("SDL EVENT: Joystick %d: ball %d moved by %d,%d",
1127  event->jball.which, event->jball.ball, event->jball.xrel,
1128  event->jball.yrel);
1129  break;
1130  case SDL_JOYHATMOTION:
1131  {
1132  const char *position = "UNKNOWN";
1133  switch (event->jhat.value) {
1134  case SDL_HAT_CENTERED:
1135  position = "CENTER";
1136  break;
1137  case SDL_HAT_UP:
1138  position = "UP";
1139  break;
1140  case SDL_HAT_RIGHTUP:
1141  position = "RIGHTUP";
1142  break;
1143  case SDL_HAT_RIGHT:
1144  position = "RIGHT";
1145  break;
1146  case SDL_HAT_RIGHTDOWN:
1147  position = "RIGHTDOWN";
1148  break;
1149  case SDL_HAT_DOWN:
1150  position = "DOWN";
1151  break;
1152  case SDL_HAT_LEFTDOWN:
1153  position = "LEFTDOWN";
1154  break;
1155  case SDL_HAT_LEFT:
1156  position = "LEFT";
1157  break;
1158  case SDL_HAT_LEFTUP:
1159  position = "LEFTUP";
1160  break;
1161  }
1162  SDL_Log("SDL EVENT: Joystick %d: hat %d moved to %s", event->jhat.which,
1163  event->jhat.hat, position);
1164  }
1165  break;
1166  case SDL_JOYBUTTONDOWN:
1167  SDL_Log("SDL EVENT: Joystick %d: button %d pressed",
1168  event->jbutton.which, event->jbutton.button);
1169  break;
1170  case SDL_JOYBUTTONUP:
1171  SDL_Log("SDL EVENT: Joystick %d: button %d released",
1172  event->jbutton.which, event->jbutton.button);
1173  break;
1175  SDL_Log("SDL EVENT: Controller index %d attached",
1176  event->cdevice.which);
1177  break;
1179  SDL_Log("SDL EVENT: Controller %d removed",
1180  event->cdevice.which);
1181  break;
1183  SDL_Log("SDL EVENT: Controller %d axis %d ('%s') value: %d",
1184  event->caxis.which,
1185  event->caxis.axis,
1187  event->caxis.value);
1188  break;
1190  SDL_Log("SDL EVENT: Controller %d button %d ('%s') down",
1191  event->cbutton.which, event->cbutton.button,
1193  break;
1195  SDL_Log("SDL EVENT: Controller %d button %d ('%s') up",
1196  event->cbutton.which, event->cbutton.button,
1198  break;
1199  case SDL_CLIPBOARDUPDATE:
1200  SDL_Log("SDL EVENT: Clipboard updated");
1201  break;
1202 
1203  case SDL_FINGERDOWN:
1204  case SDL_FINGERUP:
1205  SDL_Log("SDL EVENT: Finger: %s touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
1206  (event->type == SDL_FINGERDOWN) ? "down" : "up",
1207  (long) event->tfinger.touchId,
1208  (long) event->tfinger.fingerId,
1209  event->tfinger.x, event->tfinger.y,
1210  event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
1211  break;
1212  case SDL_DOLLARGESTURE:
1213  SDL_Log("SDL_EVENT: Dollar gesture detect: %"SDL_PRIs64, (Sint64) event->dgesture.gestureId);
1214  break;
1215  case SDL_DOLLARRECORD:
1216  SDL_Log("SDL_EVENT: Dollar gesture record: %"SDL_PRIs64, (Sint64) event->dgesture.gestureId);
1217  break;
1218  case SDL_MULTIGESTURE:
1219  SDL_Log("SDL_EVENT: Multi gesture fingers: %d", event->mgesture.numFingers);
1220  break;
1221 
1223  SDL_Log("SDL EVENT: render device reset");
1224  break;
1226  SDL_Log("SDL EVENT: render targets reset");
1227  break;
1228 
1229  case SDL_QUIT:
1230  SDL_Log("SDL EVENT: Quit requested");
1231  break;
1232  case SDL_USEREVENT:
1233  SDL_Log("SDL EVENT: User event %d", event->user.code);
1234  break;
1235  default:
1236  SDL_Log("Unknown event %04x", event->type);
1237  break;
1238  }
1239 }
#define SDL_HAT_LEFTDOWN
Definition: SDL_joystick.h:215
SDL_JoystickID which
Definition: SDL_events.h:360
SDL_MouseMotionEvent motion
Definition: SDL_events.h:533
SDL_JoystickID which
Definition: SDL_events.h:335
SDL_ControllerAxisEvent caxis
Definition: SDL_events.h:541
SDL_JoyDeviceEvent jdevice
Definition: SDL_events.h:540
SDL_DollarGestureEvent dgesture
Definition: SDL_events.h:550
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:543
SDL_JoyButtonEvent jbutton
Definition: SDL_events.h:539
#define SDL_HAT_RIGHTUP
Definition: SDL_joystick.h:212
SDL_JoyBallEvent jball
Definition: SDL_events.h:537
SDL_TouchID touchId
Definition: SDL_events.h:417
SDL_Scancode scancode
Definition: SDL_keyboard.h:49
SDL_GameControllerButton
SDL_GestureID gestureId
Definition: SDL_events.h:452
SDL_JoystickID which
Definition: SDL_events.h:377
SDL_MouseWheelEvent wheel
Definition: SDL_events.h:535
SDL_WindowEvent window
Definition: SDL_events.h:529
#define SDL_HAT_RIGHT
Definition: SDL_joystick.h:209
SDL_JoystickID which
Definition: SDL_events.h:299
#define SDL_Log
SDL_TextInputEvent text
Definition: SDL_events.h:532
#define SDL_PRIs64
Definition: SDL_stdinc.h:181
char text[SDL_TEXTINPUTEVENT_TEXT_SIZE]
Definition: SDL_events.h:226
#define SDL_HAT_RIGHTDOWN
Definition: SDL_joystick.h:213
static const char * ControllerButtonName(const SDL_GameControllerButton button)
#define SDL_HAT_LEFT
Definition: SDL_joystick.h:211
SDL_MultiGestureEvent mgesture
Definition: SDL_events.h:549
SDL_Keysym keysym
Definition: SDL_events.h:199
#define SDL_GetScancodeName
SDL_KeyboardEvent key
Definition: SDL_events.h:530
SDL_ControllerButtonEvent cbutton
Definition: SDL_events.h:542
#define SDL_HAT_LEFTUP
Definition: SDL_joystick.h:214
#define SDL_GetKeyName
SDL_FingerID fingerId
Definition: SDL_events.h:418
SDL_Keycode sym
Definition: SDL_keyboard.h:50
static const char * ControllerAxisName(const SDL_GameControllerAxis axis)
SDL_MouseButtonEvent button
Definition: SDL_events.h:534
SDL_UserEvent user
Definition: SDL_events.h:546
int64_t Sint64
A signed 64-bit integer type.
Definition: SDL_stdinc.h:166
SDL_JoyHatEvent jhat
Definition: SDL_events.h:538
#define SDL_HAT_CENTERED
Definition: SDL_joystick.h:207
#define SDL_HAT_UP
Definition: SDL_joystick.h:208
#define SDL_HAT_DOWN
Definition: SDL_joystick.h:210
SDL_JoystickID which
Definition: SDL_events.h:315
SDL_GameControllerAxis
Uint32 type
Definition: SDL_events.h:527
SDL_TouchFingerEvent tfinger
Definition: SDL_events.h:548

◆ SDLTest_PrintPixelFormat()

static void SDLTest_PrintPixelFormat ( Uint32  format)
static

Definition at line 482 of file SDL_test_common.c.

References SDL_PIXELFORMAT_ABGR1555, SDL_PIXELFORMAT_ABGR4444, SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB1555, SDL_PIXELFORMAT_ARGB2101010, SDL_PIXELFORMAT_ARGB4444, SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR24, SDL_PIXELFORMAT_BGR555, SDL_PIXELFORMAT_BGR565, SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_INDEX1LSB, SDL_PIXELFORMAT_INDEX1MSB, SDL_PIXELFORMAT_INDEX4LSB, SDL_PIXELFORMAT_INDEX4MSB, SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_IYUV, SDL_PIXELFORMAT_NV12, SDL_PIXELFORMAT_NV21, SDL_PIXELFORMAT_RGB24, SDL_PIXELFORMAT_RGB332, SDL_PIXELFORMAT_RGB444, SDL_PIXELFORMAT_RGB555, SDL_PIXELFORMAT_RGB565, SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_UNKNOWN, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_YV12, and SDL_PIXELFORMAT_YVYU.

Referenced by SDLTest_PrintRenderer().

483 {
484  switch (format) {
486  fprintf(stderr, "Unknwon");
487  break;
489  fprintf(stderr, "Index1LSB");
490  break;
492  fprintf(stderr, "Index1MSB");
493  break;
495  fprintf(stderr, "Index4LSB");
496  break;
498  fprintf(stderr, "Index4MSB");
499  break;
501  fprintf(stderr, "Index8");
502  break;
504  fprintf(stderr, "RGB332");
505  break;
507  fprintf(stderr, "RGB444");
508  break;
510  fprintf(stderr, "RGB555");
511  break;
513  fprintf(stderr, "BGR555");
514  break;
516  fprintf(stderr, "ARGB4444");
517  break;
519  fprintf(stderr, "ABGR4444");
520  break;
522  fprintf(stderr, "ARGB1555");
523  break;
525  fprintf(stderr, "ABGR1555");
526  break;
528  fprintf(stderr, "RGB565");
529  break;
531  fprintf(stderr, "BGR565");
532  break;
534  fprintf(stderr, "RGB24");
535  break;
537  fprintf(stderr, "BGR24");
538  break;
540  fprintf(stderr, "RGB888");
541  break;
543  fprintf(stderr, "BGR888");
544  break;
546  fprintf(stderr, "ARGB8888");
547  break;
549  fprintf(stderr, "RGBA8888");
550  break;
552  fprintf(stderr, "ABGR8888");
553  break;
555  fprintf(stderr, "BGRA8888");
556  break;
558  fprintf(stderr, "ARGB2101010");
559  break;
561  fprintf(stderr, "YV12");
562  break;
564  fprintf(stderr, "IYUV");
565  break;
567  fprintf(stderr, "YUY2");
568  break;
570  fprintf(stderr, "UYVY");
571  break;
573  fprintf(stderr, "YVYU");
574  break;
576  fprintf(stderr, "NV12");
577  break;
579  fprintf(stderr, "NV21");
580  break;
581  default:
582  fprintf(stderr, "0x%8.8x", format);
583  break;
584  }
585 }
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1565

◆ SDLTest_PrintRenderer()

static void SDLTest_PrintRenderer ( SDL_RendererInfo info)
static

Definition at line 588 of file SDL_test_common.c.

References SDL_RendererInfo::flags, i, SDL_RendererInfo::max_texture_height, SDL_RendererInfo::max_texture_width, SDL_RendererInfo::name, SDL_RendererInfo::num_texture_formats, SDLTest_PrintPixelFormat(), SDLTest_PrintRendererFlag(), and SDL_RendererInfo::texture_formats.

Referenced by SDLTest_CommonInit().

589 {
590  int i, count;
591 
592  fprintf(stderr, " Renderer %s:\n", info->name);
593 
594  fprintf(stderr, " Flags: 0x%8.8X", info->flags);
595  fprintf(stderr, " (");
596  count = 0;
597  for (i = 0; i < sizeof(info->flags) * 8; ++i) {
598  Uint32 flag = (1 << i);
599  if (info->flags & flag) {
600  if (count > 0) {
601  fprintf(stderr, " | ");
602  }
604  ++count;
605  }
606  }
607  fprintf(stderr, ")\n");
608 
609  fprintf(stderr, " Texture formats (%d): ", info->num_texture_formats);
610  for (i = 0; i < (int) info->num_texture_formats; ++i) {
611  if (i > 0) {
612  fprintf(stderr, ", ");
613  }
615  }
616  fprintf(stderr, "\n");
617 
618  if (info->max_texture_width || info->max_texture_height) {
619  fprintf(stderr, " Max Texture Size: %dx%d\n",
621  }
622 }
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1564
Uint32 texture_formats[16]
Definition: SDL_render.h:83
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:161
const char * name
Definition: SDL_render.h:80
int max_texture_height
Definition: SDL_render.h:85
static void SDLTest_PrintPixelFormat(Uint32 format)
static void SDLTest_PrintRendererFlag(Uint32 flag)
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
Uint32 num_texture_formats
Definition: SDL_render.h:82

◆ SDLTest_PrintRendererFlag()

static void SDLTest_PrintRendererFlag ( Uint32  flag)
static

Definition at line 466 of file SDL_test_common.c.

References SDL_RENDERER_ACCELERATED, and SDL_RENDERER_PRESENTVSYNC.

Referenced by SDLTest_PrintRenderer().

467 {
468  switch (flag) {
470  fprintf(stderr, "PresentVSync");
471  break;
473  fprintf(stderr, "Accelerated");
474  break;
475  default:
476  fprintf(stderr, "0x%8.8x", flag);
477  break;
478  }
479 }

◆ SDLTest_ScreenShot()

static void SDLTest_ScreenShot ( SDL_Renderer renderer)
static

Definition at line 1242 of file SDL_test_common.c.

References SDL_Surface::format, SDL_PixelFormat::format, SDL_Rect::h, NULL, SDL_Surface::pitch, SDL_Surface::pixels, SDL_BYTEORDER, SDL_CreateRGBSurface, SDL_free(), SDL_GetError, SDL_LIL_ENDIAN, SDL_RenderGetViewport, SDL_RenderReadPixels, SDL_SaveBMP, viewport, and SDL_Rect::w.

Referenced by SDLTest_CommonEvent().

1243 {
1245  SDL_Surface *surface;
1246 
1247  if (!renderer) {
1248  return;
1249  }
1250 
1251  SDL_RenderGetViewport(renderer, &viewport);
1252  surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
1254  0x00FF0000, 0x0000FF00, 0x000000FF,
1255 #else
1256  0x000000FF, 0x0000FF00, 0x00FF0000,
1257 #endif
1258  0x00000000);
1259  if (!surface) {
1260  fprintf(stderr, "Couldn't create surface: %s\n", SDL_GetError());
1261  return;
1262  }
1263 
1264  if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
1265  surface->pixels, surface->pitch) < 0) {
1266  fprintf(stderr, "Couldn't read screen: %s\n", SDL_GetError());
1267  SDL_free(surface);
1268  return;
1269  }
1270 
1271  if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
1272  fprintf(stderr, "Couldn't save screenshot.bmp: %s\n", SDL_GetError());
1273  SDL_free(surface);
1274  return;
1275  }
1276 }
#define SDL_RenderReadPixels
#define SDL_GetError
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_SaveBMP(surface, file)
Definition: SDL_surface.h:209
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
void * pixels
Definition: SDL_surface.h:75
void SDL_free(void *mem)
#define SDL_RenderGetViewport
int w
Definition: SDL_rect.h:67
#define NULL
Definition: begin_code.h:143
SDL_PixelFormat * format
Definition: SDL_surface.h:72
#define SDL_CreateRGBSurface
int h
Definition: SDL_rect.h:67
SDL_Rect viewport
Definition: testviewport.c:28
#define SDL_BYTEORDER
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64