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

static void SDL_snprintfcat (SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
 
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 (char *text, size_t maxlen, Uint32 flag)
 
static void SDLTest_PrintPixelFormat (char *text, size_t maxlen, 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

#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().

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

Referenced by ControllerAxisName().

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

Referenced by ControllerButtonName().

#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

static const char* ControllerAxisName ( const SDL_GameControllerAxis  axis)
static

Definition at line 985 of file SDL_test_common.c.

References AXIS_CASE.

Referenced by SDLTest_PrintEvent().

986 {
987  switch (axis)
988  {
989 #define AXIS_CASE(ax) case SDL_CONTROLLER_AXIS_##ax: return #ax
990  AXIS_CASE(INVALID);
991  AXIS_CASE(LEFTX);
992  AXIS_CASE(LEFTY);
993  AXIS_CASE(RIGHTX);
994  AXIS_CASE(RIGHTY);
995  AXIS_CASE(TRIGGERLEFT);
996  AXIS_CASE(TRIGGERRIGHT);
997 #undef AXIS_CASE
998 default: return "???";
999  }
1000 }
#define AXIS_CASE(ax)
SDL_Texture * axis
static const char* ControllerButtonName ( const SDL_GameControllerButton  button)
static

Definition at line 1003 of file SDL_test_common.c.

References BUTTON_CASE.

Referenced by SDLTest_PrintEvent().

1004 {
1005  switch (button)
1006  {
1007 #define BUTTON_CASE(btn) case SDL_CONTROLLER_BUTTON_##btn: return #btn
1008  BUTTON_CASE(INVALID);
1009  BUTTON_CASE(A);
1010  BUTTON_CASE(B);
1011  BUTTON_CASE(X);
1012  BUTTON_CASE(Y);
1013  BUTTON_CASE(BACK);
1014  BUTTON_CASE(GUIDE);
1015  BUTTON_CASE(START);
1016  BUTTON_CASE(LEFTSTICK);
1017  BUTTON_CASE(RIGHTSTICK);
1018  BUTTON_CASE(LEFTSHOULDER);
1019  BUTTON_CASE(RIGHTSHOULDER);
1020  BUTTON_CASE(DPAD_UP);
1021  BUTTON_CASE(DPAD_DOWN);
1022  BUTTON_CASE(DPAD_LEFT);
1023  BUTTON_CASE(DPAD_RIGHT);
1024 #undef BUTTON_CASE
1025 default: return "???";
1026  }
1027 }
SDL_Texture * button
#define BUTTON_CASE(btn)
static void FullscreenTo ( int  index,
int  windowId 
)
static

Definition at line 1336 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, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDLTest_CommonEvent().

1337 {
1338  Uint32 flags;
1339  struct SDL_Rect rect = { 0, 0, 0, 0 };
1340  SDL_Window *window = SDL_GetWindowFromID(windowId);
1341  if (!window) {
1342  return;
1343  }
1344 
1345  SDL_GetDisplayBounds( index, &rect );
1346 
1347  flags = SDL_GetWindowFlags(window);
1348  if (flags & SDL_WINDOW_FULLSCREEN) {
1350  SDL_Delay( 15 );
1351  }
1352 
1353  SDL_SetWindowPosition( window, rect.x, rect.y );
1354  SDL_SetWindowFullscreen( window, SDL_TRUE );
1355 }
#define SDL_SetWindowFullscreen
SDL_Rect rect
Definition: testrelative.c:27
#define SDL_GetWindowFlags
uint32_t Uint32
Definition: SDL_stdinc.h:181
#define SDL_GetDisplayBounds
int x
Definition: SDL_rect.h:66
#define SDL_GetWindowFromID
GLuint index
#define SDL_Delay
GLbitfield flags
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
The type used to identify a window.
Definition: SDL_sysvideo.h:73
int y
Definition: SDL_rect.h:66
#define SDL_SetWindowPosition
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
static void SDL_snprintfcat ( SDL_OUT_Z_CAP(maxlen) char *  text,
size_t  maxlen,
SDL_PRINTF_FORMAT_STRING const char *  fmt,
  ... 
)
static

Definition at line 35 of file SDL_test_common.c.

References SDL_strlen, and SDL_vsnprintf.

Referenced by SDLTest_CommonInit(), SDLTest_PrintPixelFormat(), SDLTest_PrintRenderer(), and SDLTest_PrintRendererFlag().

36 {
37  size_t length = SDL_strlen(text);
38  va_list ap;
39 
40  va_start(ap, fmt);
41  text += length;
42  maxlen -= length;
43  SDL_vsnprintf(text, maxlen, fmt, ap);
44  va_end(ap);
45 }
#define SDL_vsnprintf
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
#define SDL_strlen
GLuint GLsizei GLsizei * length
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 95 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().

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

Parse command line parameters and create common state.

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

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

49 {
51  if (!state) {
53  return NULL;
54  }
55 
56  /* Initialize some defaults */
57  state->argv = argv;
58  state->flags = flags;
59  state->window_title = argv[0];
60  state->window_flags = 0;
65  state->num_windows = 1;
66  state->audiospec.freq = 22050;
67  state->audiospec.format = AUDIO_S16;
68  state->audiospec.channels = 2;
69  state->audiospec.samples = 2048;
70 
71  /* Set some very sane GL defaults */
72  state->gl_red_size = 3;
73  state->gl_green_size = 3;
74  state->gl_blue_size = 2;
75  state->gl_alpha_size = 0;
76  state->gl_buffer_size = 0;
77  state->gl_depth_size = 16;
78  state->gl_stencil_size = 0;
79  state->gl_double_buffer = 1;
80  state->gl_accum_red_size = 0;
81  state->gl_accum_green_size = 0;
82  state->gl_accum_blue_size = 0;
83  state->gl_accum_alpha_size = 0;
84  state->gl_stereo = 0;
85  state->gl_multisamplebuffers = 0;
86  state->gl_multisamplesamples = 0;
87  state->gl_retained_backing = 1;
88  state->gl_accelerated = -1;
89  state->gl_debug = 0;
90 
91  return state;
92 }
struct xkb_state * state
Uint16 samples
Definition: SDL_audio.h:174
#define SDL_WINDOWPOS_UNDEFINED
Definition: SDL_video.h:128
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:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
GLbitfield flags
SDL_AudioFormat format
Definition: SDL_audio.h:171
#define AUDIO_S16
Definition: SDL_audio.h:96
#define DEFAULT_WINDOW_WIDTH
const char * window_title
void SDLTest_CommonEvent ( SDLTest_CommonState state,
SDL_Event event,
int *  done 
)

Common event handler for test windows.

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

Definition at line 1358 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_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(), SDL_Keysym::sym, SDLTest_CommonState::targets, text, SDL_Event::type, SDLTest_CommonState::verbose, VERBOSE_EVENT, SDL_Rect::w, 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().

1359 {
1360  int i;
1361  static SDL_MouseMotionEvent lastEvent;
1362 
1363  if (state->verbose & VERBOSE_EVENT) {
1364  SDLTest_PrintEvent(event);
1365  }
1366 
1367  switch (event->type) {
1368  case SDL_WINDOWEVENT:
1369  switch (event->window.event) {
1370  case SDL_WINDOWEVENT_CLOSE:
1371  {
1373  if (window) {
1374  for (i = 0; i < state->num_windows; ++i) {
1375  if (window == state->windows[i]) {
1376  if (state->targets[i]) {
1377  SDL_DestroyTexture(state->targets[i]);
1378  state->targets[i] = NULL;
1379  }
1380  if (state->renderers[i]) {
1381  SDL_DestroyRenderer(state->renderers[i]);
1382  state->renderers[i] = NULL;
1383  }
1384  SDL_DestroyWindow(state->windows[i]);
1385  state->windows[i] = NULL;
1386  break;
1387  }
1388  }
1389  }
1390  }
1391  break;
1392  }
1393  break;
1394  case SDL_KEYDOWN: {
1395  SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
1396  SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
1397  SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
1398 
1399  switch (event->key.keysym.sym) {
1400  /* Add hotkeys here */
1401  case SDLK_PRINTSCREEN: {
1402  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1403  if (window) {
1404  for (i = 0; i < state->num_windows; ++i) {
1405  if (window == state->windows[i]) {
1406  SDLTest_ScreenShot(state->renderers[i]);
1407  }
1408  }
1409  }
1410  }
1411  break;
1412  case SDLK_EQUALS:
1413  if (withControl) {
1414  /* Ctrl-+ double the size of the window */
1415  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1416  if (window) {
1417  int w, h;
1418  SDL_GetWindowSize(window, &w, &h);
1419  SDL_SetWindowSize(window, w*2, h*2);
1420  }
1421  }
1422  break;
1423  case SDLK_MINUS:
1424  if (withControl) {
1425  /* Ctrl-- half the size of the window */
1426  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1427  if (window) {
1428  int w, h;
1429  SDL_GetWindowSize(window, &w, &h);
1430  SDL_SetWindowSize(window, w/2, h/2);
1431  }
1432  }
1433  break;
1434  case SDLK_UP:
1435  case SDLK_DOWN:
1436  case SDLK_LEFT:
1437  case SDLK_RIGHT:
1438  if (withAlt) {
1439  /* Alt-Up/Down/Left/Right switches between displays */
1440  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1441  if (window) {
1442  int currentIndex = SDL_GetWindowDisplayIndex(window);
1443  int numDisplays = SDL_GetNumVideoDisplays();
1444 
1445  if (currentIndex >= 0 && numDisplays >= 1) {
1446  int dest;
1447  if (event->key.keysym.sym == SDLK_UP || event->key.keysym.sym == SDLK_LEFT) {
1448  dest = (currentIndex + numDisplays - 1) % numDisplays;
1449  } else {
1450  dest = (currentIndex + numDisplays + 1) % numDisplays;
1451  }
1452  SDL_Log("Centering on display %d\n", dest);
1453  SDL_SetWindowPosition(window,
1456  }
1457  }
1458  }
1459  if (withShift) {
1460  /* Shift-Up/Down/Left/Right shift the window by 100px */
1461  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1462  if (window) {
1463  const int delta = 100;
1464  int x, y;
1465  SDL_GetWindowPosition(window, &x, &y);
1466 
1467  if (event->key.keysym.sym == SDLK_UP) y -= delta;
1468  if (event->key.keysym.sym == SDLK_DOWN) y += delta;
1469  if (event->key.keysym.sym == SDLK_LEFT) x -= delta;
1470  if (event->key.keysym.sym == SDLK_RIGHT) x += delta;
1471 
1472  SDL_Log("Setting position to (%d, %d)\n", x, y);
1473  SDL_SetWindowPosition(window, x, y);
1474  }
1475  }
1476  break;
1477  case SDLK_o:
1478  if (withControl) {
1479  /* Ctrl-O (or Ctrl-Shift-O) changes window opacity. */
1480  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1481  if (window) {
1482  float opacity;
1483  if (SDL_GetWindowOpacity(window, &opacity) == 0) {
1484  if (withShift) {
1485  opacity += 0.20f;
1486  } else {
1487  opacity -= 0.20f;
1488  }
1489  SDL_SetWindowOpacity(window, opacity);
1490  }
1491  }
1492  }
1493  break;
1494 
1495  case SDLK_c:
1496  if (withControl) {
1497  /* Ctrl-C copy awesome text! */
1498  SDL_SetClipboardText("SDL rocks!\nYou know it!");
1499  printf("Copied text to clipboard\n");
1500  }
1501  if (withAlt) {
1502  /* Alt-C toggle a render clip rectangle */
1503  for (i = 0; i < state->num_windows; ++i) {
1504  int w, h;
1505  if (state->renderers[i]) {
1506  SDL_Rect clip;
1507  SDL_GetWindowSize(state->windows[i], &w, &h);
1508  SDL_RenderGetClipRect(state->renderers[i], &clip);
1509  if (SDL_RectEmpty(&clip)) {
1510  clip.x = w/4;
1511  clip.y = h/4;
1512  clip.w = w/2;
1513  clip.h = h/2;
1514  SDL_RenderSetClipRect(state->renderers[i], &clip);
1515  } else {
1516  SDL_RenderSetClipRect(state->renderers[i], NULL);
1517  }
1518  }
1519  }
1520  }
1521  if (withShift) {
1522  SDL_Window *current_win = SDL_GetKeyboardFocus();
1523  if (current_win) {
1524  const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
1525  const int rc = SDL_CaptureMouse(shouldCapture);
1526  SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
1527  }
1528  }
1529  break;
1530  case SDLK_v:
1531  if (withControl) {
1532  /* Ctrl-V paste awesome text! */
1533  char *text = SDL_GetClipboardText();
1534  if (*text) {
1535  printf("Clipboard: %s\n", text);
1536  } else {
1537  printf("Clipboard is empty\n");
1538  }
1539  SDL_free(text);
1540  }
1541  break;
1542  case SDLK_g:
1543  if (withControl) {
1544  /* Ctrl-G toggle grab */
1545  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1546  if (window) {
1547  SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
1548  }
1549  }
1550  break;
1551  case SDLK_m:
1552  if (withControl) {
1553  /* Ctrl-M maximize */
1554  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1555  if (window) {
1556  Uint32 flags = SDL_GetWindowFlags(window);
1557  if (flags & SDL_WINDOW_MAXIMIZED) {
1558  SDL_RestoreWindow(window);
1559  } else {
1560  SDL_MaximizeWindow(window);
1561  }
1562  }
1563  }
1564  break;
1565  case SDLK_r:
1566  if (withControl) {
1567  /* Ctrl-R toggle mouse relative mode */
1569  }
1570  break;
1571  case SDLK_z:
1572  if (withControl) {
1573  /* Ctrl-Z minimize */
1574  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1575  if (window) {
1576  SDL_MinimizeWindow(window);
1577  }
1578  }
1579  break;
1580  case SDLK_RETURN:
1581  if (withControl) {
1582  /* Ctrl-Enter toggle fullscreen */
1583  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1584  if (window) {
1585  Uint32 flags = SDL_GetWindowFlags(window);
1586  if (flags & SDL_WINDOW_FULLSCREEN) {
1588  } else {
1589  SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
1590  }
1591  }
1592  } else if (withAlt) {
1593  /* Alt-Enter toggle fullscreen desktop */
1594  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1595  if (window) {
1596  Uint32 flags = SDL_GetWindowFlags(window);
1597  if (flags & SDL_WINDOW_FULLSCREEN) {
1599  } else {
1601  }
1602  }
1603  } else if (withShift) {
1604  /* Shift-Enter toggle fullscreen desktop / fullscreen */
1605  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1606  if (window) {
1607  Uint32 flags = SDL_GetWindowFlags(window);
1608  if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
1610  } else {
1611  SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
1612  }
1613  }
1614  }
1615 
1616  break;
1617  case SDLK_b:
1618  if (withControl) {
1619  /* Ctrl-B toggle window border */
1620  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1621  if (window) {
1622  const Uint32 flags = SDL_GetWindowFlags(window);
1623  const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
1624  SDL_SetWindowBordered(window, b);
1625  }
1626  }
1627  break;
1628  case SDLK_a:
1629  if (withControl) {
1630  /* Ctrl-A reports absolute mouse position. */
1631  int x, y;
1632  const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
1633  SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
1634  (mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
1635  (mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
1636  (mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
1637  (mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
1638  (mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
1639  }
1640  break;
1641  case SDLK_0:
1642  if (withControl) {
1643  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1644  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
1645  }
1646  break;
1647  case SDLK_1:
1648  if (withControl) {
1649  FullscreenTo(0, event->key.windowID);
1650  }
1651  break;
1652  case SDLK_2:
1653  if (withControl) {
1654  FullscreenTo(1, event->key.windowID);
1655  }
1656  break;
1657  case SDLK_ESCAPE:
1658  *done = 1;
1659  break;
1660  case SDLK_SPACE:
1661  {
1662  char message[256];
1663  SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
1664 
1665  SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
1666  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
1667  break;
1668  }
1669  default:
1670  break;
1671  }
1672  break;
1673  }
1674  case SDL_QUIT:
1675  *done = 1;
1676  break;
1677  case SDL_MOUSEMOTION:
1678  lastEvent = event->motion;
1679  break;
1680  }
1681 }
SDL_Texture ** targets
#define SDL_GetWindowDisplayIndex
#define SDL_RenderGetClipRect
#define SDL_SetWindowFullscreen
#define SDL_BUTTON_RMASK
Definition: SDL_mouse.h:289
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
GLuint GLsizei const GLchar * message
#define KMOD_CTRL
Definition: SDL_keycode.h:342
#define SDL_BUTTON_X2MASK
Definition: SDL_mouse.h:291
GLfloat GLfloat GLfloat GLfloat h
#define SDL_SetWindowSize
#define SDL_GetWindowFlags
#define KMOD_ALT
Definition: SDL_keycode.h:344
#define VERBOSE_EVENT
#define SDL_SetRelativeMouseMode
#define SDL_GetKeyboardFocus
uint32_t Uint32
Definition: SDL_stdinc.h:181
#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
#define SDL_GetNumVideoDisplays
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_WindowEvent window
Definition: SDL_events.h:529
#define SDL_GetWindowSize
#define SDL_Log
#define SDL_GetRelativeMouseMode
#define SDL_ShowSimpleMessageBox
#define SDL_GetClipboardText
#define SDL_SetWindowGrab
#define KMOD_SHIFT
Definition: SDL_keycode.h:343
void SDL_free(void *mem)
int done
Definition: checkkeys.c:28
GLenum GLint GLuint mask
#define SDL_SetWindowOpacity
#define SDL_BUTTON_X1MASK
Definition: SDL_mouse.h:290
GLubyte GLubyte GLubyte GLubyte w
#define SDL_BUTTON_LMASK
Definition: SDL_mouse.h:287
#define SDL_GetWindowPosition
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
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
#define SDL_RestoreWindow
SDL_Renderer ** renderers
static void SDLTest_PrintEvent(SDL_Event *event)
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X)
Definition: SDL_video.h:136
#define SDL_GetWindowOpacity
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:139
#define SDL_SetWindowBordered
GLbitfield flags
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
Mouse motion event structure (event.motion.*)
Definition: SDL_events.h:232
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
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:73
#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
#define SDL_RenderSetClipRect
#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
#define SDL_SetWindowPosition
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
#define SDL_SetClipboardText
Uint32 type
Definition: SDL_events.h:527
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 665 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_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_SetWindowIcon, SDL_SetWindowMaximumSize, SDL_SetWindowMinimumSize, SDL_ShowWindow, SDL_snprintf, SDL_snprintfcat(), SDL_strcasecmp, SDL_strlcpy, SDL_TRUE, SDL_VideoInit, SDL_WINDOW_OPENGL, SDL_WINDOW_RESIZABLE, SDL_WINDOW_VULKAN, SDL_zero, SDLTest_LoadIcon(), SDLTest_PrintRenderer(), SDLTest_CommonState::skip_renderer, SDLTest_CommonState::targets, text, 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().

666 {
667  int i, j, m, n, w, h;
668  SDL_DisplayMode fullscreen_mode;
669  char text[1024];
670 
671  if (state->flags & SDL_INIT_VIDEO) {
672  if (state->verbose & VERBOSE_VIDEO) {
674  if (n == 0) {
675  SDL_Log("No built-in video drivers\n");
676  } else {
677  SDL_snprintf(text, sizeof(text), "Built-in video drivers:");
678  for (i = 0; i < n; ++i) {
679  if (i > 0) {
680  SDL_snprintfcat(text, sizeof(text), ",");
681  }
682  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetVideoDriver(i));
683  }
684  SDL_Log("%s\n", text);
685  }
686  }
687  if (SDL_VideoInit(state->videodriver) < 0) {
688  SDL_Log("Couldn't initialize video driver: %s\n",
689  SDL_GetError());
690  return SDL_FALSE;
691  }
692  if (state->verbose & VERBOSE_VIDEO) {
693  SDL_Log("Video driver: %s\n",
695  }
696 
697  /* Upload GL settings */
713  if (state->gl_accelerated >= 0) {
715  state->gl_accelerated);
716  }
718  if (state->gl_major_version) {
721  }
722  if (state->gl_debug) {
724  }
725  if (state->gl_profile_mask) {
727  }
728 
729  if (state->verbose & VERBOSE_MODES) {
730  SDL_Rect bounds, usablebounds;
731  float hdpi = 0;
732  float vdpi = 0;
734  int bpp;
735  Uint32 Rmask, Gmask, Bmask, Amask;
736 #if SDL_VIDEO_DRIVER_WINDOWS
737  int adapterIndex = 0;
738  int outputIndex = 0;
739 #endif
741  SDL_Log("Number of displays: %d\n", n);
742  for (i = 0; i < n; ++i) {
743  SDL_Log("Display %d: %s\n", i, SDL_GetDisplayName(i));
744 
745  SDL_zero(bounds);
746  SDL_GetDisplayBounds(i, &bounds);
747 
748  SDL_zero(usablebounds);
749  SDL_GetDisplayUsableBounds(i, &usablebounds);
750 
751  SDL_GetDisplayDPI(i, NULL, &hdpi, &vdpi);
752 
753  SDL_Log("Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
754  SDL_Log("Usable bounds: %dx%d at %d,%d\n", usablebounds.w, usablebounds.h, usablebounds.x, usablebounds.y);
755  SDL_Log("DPI: %fx%f\n", hdpi, vdpi);
756 
757  SDL_GetDesktopDisplayMode(i, &mode);
758  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
759  &Bmask, &Amask);
760  SDL_Log(" Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
761  mode.w, mode.h, mode.refresh_rate, bpp,
763  if (Rmask || Gmask || Bmask) {
764  SDL_Log(" Red Mask = 0x%.8x\n", Rmask);
765  SDL_Log(" Green Mask = 0x%.8x\n", Gmask);
766  SDL_Log(" Blue Mask = 0x%.8x\n", Bmask);
767  if (Amask)
768  SDL_Log(" Alpha Mask = 0x%.8x\n", Amask);
769  }
770 
771  /* Print available fullscreen video modes */
772  m = SDL_GetNumDisplayModes(i);
773  if (m == 0) {
774  SDL_Log("No available fullscreen video modes\n");
775  } else {
776  SDL_Log(" Fullscreen video modes:\n");
777  for (j = 0; j < m; ++j) {
778  SDL_GetDisplayMode(i, j, &mode);
779  SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
780  &Gmask, &Bmask, &Amask);
781  SDL_Log(" Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
782  j, mode.w, mode.h, mode.refresh_rate, bpp,
784  if (Rmask || Gmask || Bmask) {
785  SDL_Log(" Red Mask = 0x%.8x\n",
786  Rmask);
787  SDL_Log(" Green Mask = 0x%.8x\n",
788  Gmask);
789  SDL_Log(" Blue Mask = 0x%.8x\n",
790  Bmask);
791  if (Amask)
792  SDL_Log(" Alpha Mask = 0x%.8x\n",
793  Amask);
794  }
795  }
796  }
797 
798 #if SDL_VIDEO_DRIVER_WINDOWS
799  /* Print the D3D9 adapter index */
800  adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
801  SDL_Log("D3D9 Adapter Index: %d", adapterIndex);
802 
803  /* Print the DXGI adapter and output indices */
804  SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
805  SDL_Log("DXGI Adapter Index: %d Output Index: %d", adapterIndex, outputIndex);
806 #endif
807  }
808  }
809 
810  if (state->verbose & VERBOSE_RENDER) {
811  SDL_RendererInfo info;
812 
814  if (n == 0) {
815  SDL_Log("No built-in render drivers\n");
816  } else {
817  SDL_Log("Built-in render drivers:\n");
818  for (i = 0; i < n; ++i) {
819  SDL_GetRenderDriverInfo(i, &info);
820  SDLTest_PrintRenderer(&info);
821  }
822  }
823  }
824 
825  SDL_zero(fullscreen_mode);
826  switch (state->depth) {
827  case 8:
828  fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
829  break;
830  case 15:
831  fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
832  break;
833  case 16:
834  fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
835  break;
836  case 24:
837  fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
838  break;
839  default:
840  fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
841  break;
842  }
843  fullscreen_mode.refresh_rate = state->refresh_rate;
844 
845  state->windows =
846  (SDL_Window **) SDL_calloc(state->num_windows,
847  sizeof(*state->windows));
848  state->renderers =
849  (SDL_Renderer **) SDL_calloc(state->num_windows,
850  sizeof(*state->renderers));
851  state->targets =
852  (SDL_Texture **) SDL_calloc(state->num_windows,
853  sizeof(*state->targets));
854  if (!state->windows || !state->renderers) {
855  SDL_Log("Out of memory!\n");
856  return SDL_FALSE;
857  }
858  for (i = 0; i < state->num_windows; ++i) {
859  char title[1024];
860 
861  if (state->num_windows > 1) {
862  SDL_snprintf(title, SDL_arraysize(title), "%s %d",
863  state->window_title, i + 1);
864  } else {
865  SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
866  }
867  state->windows[i] =
868  SDL_CreateWindow(title, state->window_x, state->window_y,
869  state->window_w, state->window_h,
870  state->window_flags);
871  if (!state->windows[i]) {
872  SDL_Log("Couldn't create window: %s\n",
873  SDL_GetError());
874  return SDL_FALSE;
875  }
876  if (state->window_minW || state->window_minH) {
877  SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
878  }
879  if (state->window_maxW || state->window_maxH) {
880  SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
881  }
882  SDL_GetWindowSize(state->windows[i], &w, &h);
883  if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
884  (w != state->window_w || h != state->window_h)) {
885  printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
886  state->window_w = w;
887  state->window_h = h;
888  }
889  if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
890  SDL_Log("Can't set up fullscreen display mode: %s\n",
891  SDL_GetError());
892  return SDL_FALSE;
893  }
894 
895  if (state->window_icon) {
896  SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
897  if (icon) {
898  SDL_SetWindowIcon(state->windows[i], icon);
899  SDL_FreeSurface(icon);
900  }
901  }
902 
903  SDL_ShowWindow(state->windows[i]);
904 
905  if (!state->skip_renderer
906  && (state->renderdriver
907  || !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN)))) {
908  m = -1;
909  if (state->renderdriver) {
910  SDL_RendererInfo info;
912  for (j = 0; j < n; ++j) {
913  SDL_GetRenderDriverInfo(j, &info);
914  if (SDL_strcasecmp(info.name, state->renderdriver) ==
915  0) {
916  m = j;
917  break;
918  }
919  }
920  if (m == -1) {
921  SDL_Log("Couldn't find render driver named %s",
922  state->renderdriver);
923  return SDL_FALSE;
924  }
925  }
926  state->renderers[i] = SDL_CreateRenderer(state->windows[i],
927  m, state->render_flags);
928  if (!state->renderers[i]) {
929  SDL_Log("Couldn't create renderer: %s\n",
930  SDL_GetError());
931  return SDL_FALSE;
932  }
933  if (state->logical_w && state->logical_h) {
934  SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
935  } else if (state->scale) {
936  SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
937  }
938  if (state->verbose & VERBOSE_RENDER) {
939  SDL_RendererInfo info;
940 
941  SDL_Log("Current renderer:\n");
942  SDL_GetRendererInfo(state->renderers[i], &info);
943  SDLTest_PrintRenderer(&info);
944  }
945  }
946  }
947  }
948 
949  if (state->flags & SDL_INIT_AUDIO) {
950  if (state->verbose & VERBOSE_AUDIO) {
952  if (n == 0) {
953  SDL_Log("No built-in audio drivers\n");
954  } else {
955  SDL_snprintf(text, sizeof(text), "Built-in audio drivers:");
956  for (i = 0; i < n; ++i) {
957  if (i > 0) {
958  SDL_snprintfcat(text, sizeof(text), ",");
959  }
960  SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetAudioDriver(i));
961  }
962  SDL_Log("%s\n", text);
963  }
964  }
965  if (SDL_AudioInit(state->audiodriver) < 0) {
966  SDL_Log("Couldn't initialize audio driver: %s\n",
967  SDL_GetError());
968  return SDL_FALSE;
969  }
970  if (state->verbose & VERBOSE_VIDEO) {
971  SDL_Log("Audio driver: %s\n",
973  }
974 
975  if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
976  SDL_Log("Couldn't open audio: %s\n", SDL_GetError());
977  return SDL_FALSE;
978  }
979  }
980 
981  return SDL_TRUE;
982 }
#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)
#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
#define SDL_GetNumRenderDrivers
GLfloat GLfloat GLfloat GLfloat h
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
const GLfloat * m
#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
Definition: SDL_stdinc.h:181
#define SDL_strcasecmp
const char * name
Definition: SDL_render.h:80
#define SDL_GetRenderDriverInfo
SDL_AudioSpec audiospec
#define SDL_GetDisplayUsableBounds
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.
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 VERBOSE_AUDIO
#define SDL_GL_SetAttribute
#define SDL_GetWindowSize
#define SDL_Log
void * SDL_calloc(size_t nmemb, size_t size)
static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
#define SDL_VideoInit
static void SDLTest_PrintRenderer(SDL_RendererInfo *info)
#define SDL_FreeSurface
#define SDL_RenderSetLogicalSize
GLenum mode
GLubyte GLubyte GLubyte GLubyte w
#define SDL_GetDisplayBounds
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
#define SDL_zero(x)
Definition: SDL_stdinc.h:385
#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
#define SDL_GetCurrentAudioDriver
#define NULL
Definition: begin_code.h:164
#define SDL_GetCurrentVideoDriver
#define VERBOSE_MODES
Information on the capabilities of a render driver or context.
Definition: SDL_render.h:78
#define SDL_GetVideoDriver
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
#define VERBOSE_RENDER
const char * audiodriver
#define SDL_INIT_AUDIO
Definition: SDL.h:77
int h
Definition: SDL_rect.h:67
The type used to identify a window.
Definition: SDL_sysvideo.h:73
GLdouble n
#define SDL_GetDisplayDPI
#define SDL_snprintf
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
#define SDL_GetNumDisplayModes
Uint32 format
Definition: SDL_video.h:55
#define VERBOSE_VIDEO
int y
Definition: SDL_rect.h:66
const char * videodriver
#define SDL_INIT_VIDEO
Definition: SDL.h:78
#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
void SDLTest_CommonQuit ( SDLTest_CommonState state)

Close test window.

Parameters
stateThe common state used to create test window.

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

1685 {
1686  int i;
1687 
1688  SDL_free(state->windows);
1689  if (state->targets) {
1690  for (i = 0; i < state->num_windows; ++i) {
1691  if (state->targets[i]) {
1692  SDL_DestroyTexture(state->targets[i]);
1693  }
1694  }
1695  SDL_free(state->targets);
1696  }
1697  if (state->renderers) {
1698  for (i = 0; i < state->num_windows; ++i) {
1699  if (state->renderers[i]) {
1700  SDL_DestroyRenderer(state->renderers[i]);
1701  }
1702  }
1703  SDL_free(state->renderers);
1704  }
1705  if (state->flags & SDL_INIT_VIDEO) {
1706  SDL_VideoQuit();
1707  }
1708  if (state->flags & SDL_INIT_AUDIO) {
1709  SDL_AudioQuit();
1710  }
1711  SDL_free(state);
1712  SDL_Quit();
1713 }
SDL_Texture ** targets
#define SDL_AudioQuit
SDL_Window ** windows
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
void SDL_free(void *mem)
#define SDL_Quit
SDL_Renderer ** renderers
#define SDL_INIT_AUDIO
Definition: SDL.h:77
#define SDL_DestroyTexture
#define SDL_VideoQuit
#define SDL_DestroyRenderer
#define SDL_INIT_VIDEO
Definition: SDL.h:78
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 463 of file SDL_test_common.c.

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

Referenced by main().

464 {
465  switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
466  case SDL_INIT_VIDEO:
467  return VIDEO_USAGE;
468  case SDL_INIT_AUDIO:
469  return AUDIO_USAGE;
471  return VIDEO_USAGE " " AUDIO_USAGE;
472  default:
473  return "";
474  }
475 }
#define AUDIO_USAGE
#define VIDEO_USAGE
#define SDL_INIT_AUDIO
Definition: SDL.h:77
#define SDL_INIT_VIDEO
Definition: SDL.h:78
static SDL_Surface* SDLTest_LoadIcon ( const char *  file)
static

Definition at line 645 of file SDL_test_common.c.

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

Referenced by SDLTest_CommonInit().

646 {
647  SDL_Surface *icon;
648 
649  /* Load the icon surface */
650  icon = SDL_LoadBMP(file);
651  if (icon == NULL) {
652  SDL_Log("Couldn't load %s: %s\n", file, SDL_GetError());
653  return (NULL);
654  }
655 
656  if (icon->format->palette) {
657  /* Set the colorkey */
658  SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels));
659  }
660 
661  return (icon);
662 }
#define SDL_GetError
#define SDL_LoadBMP(file)
Definition: SDL_surface.h:189
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_Log
void * pixels
Definition: SDL_surface.h:75
uint8_t Uint8
Definition: SDL_stdinc.h:157
#define SDL_SetColorKey
#define NULL
Definition: begin_code.h:164
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_Palette * palette
Definition: SDL_pixels.h:316
static void SDLTest_PrintEvent ( SDL_Event event)
static

Definition at line 1030 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_Event::edit, 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_APP_DIDENTERBACKGROUND, SDL_APP_DIDENTERFOREGROUND, SDL_APP_LOWMEMORY, SDL_APP_TERMINATING, SDL_APP_WILLENTERBACKGROUND, SDL_APP_WILLENTERFOREGROUND, 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_KEYMAPCHANGED, SDL_KEYUP, SDL_Log, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEMOTION, SDL_MOUSEWHEEL, SDL_MULTIGESTURE, SDL_QUIT, SDL_RENDER_DEVICE_RESET, SDL_RENDER_TARGETS_RESET, SDL_TEXTEDITING, 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_TextEditingEvent::text, 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_TextEditingEvent::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().

1031 {
1032  if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) {
1033  /* Mouse and finger motion are really spammy */
1034  return;
1035  }
1036 
1037  switch (event->type) {
1038  case SDL_WINDOWEVENT:
1039  switch (event->window.event) {
1040  case SDL_WINDOWEVENT_SHOWN:
1041  SDL_Log("SDL EVENT: Window %d shown", event->window.windowID);
1042  break;
1044  SDL_Log("SDL EVENT: Window %d hidden", event->window.windowID);
1045  break;
1047  SDL_Log("SDL EVENT: Window %d exposed", event->window.windowID);
1048  break;
1049  case SDL_WINDOWEVENT_MOVED:
1050  SDL_Log("SDL EVENT: Window %d moved to %d,%d",
1051  event->window.windowID, event->window.data1,
1052  event->window.data2);
1053  break;
1055  SDL_Log("SDL EVENT: Window %d resized to %dx%d",
1056  event->window.windowID, event->window.data1,
1057  event->window.data2);
1058  break;
1060  SDL_Log("SDL EVENT: Window %d changed size to %dx%d",
1061  event->window.windowID, event->window.data1,
1062  event->window.data2);
1063  break;
1065  SDL_Log("SDL EVENT: Window %d minimized", event->window.windowID);
1066  break;
1068  SDL_Log("SDL EVENT: Window %d maximized", event->window.windowID);
1069  break;
1071  SDL_Log("SDL EVENT: Window %d restored", event->window.windowID);
1072  break;
1073  case SDL_WINDOWEVENT_ENTER:
1074  SDL_Log("SDL EVENT: Mouse entered window %d",
1075  event->window.windowID);
1076  break;
1077  case SDL_WINDOWEVENT_LEAVE:
1078  SDL_Log("SDL EVENT: Mouse left window %d", event->window.windowID);
1079  break;
1081  SDL_Log("SDL EVENT: Window %d gained keyboard focus",
1082  event->window.windowID);
1083  break;
1085  SDL_Log("SDL EVENT: Window %d lost keyboard focus",
1086  event->window.windowID);
1087  break;
1088  case SDL_WINDOWEVENT_CLOSE:
1089  SDL_Log("SDL EVENT: Window %d closed", event->window.windowID);
1090  break;
1092  SDL_Log("SDL EVENT: Window %d take focus", event->window.windowID);
1093  break;
1095  SDL_Log("SDL EVENT: Window %d hit test", event->window.windowID);
1096  break;
1097  default:
1098  SDL_Log("SDL EVENT: Window %d got unknown event 0x%4.4x",
1099  event->window.windowID, event->window.event);
1100  break;
1101  }
1102  break;
1103  case SDL_KEYDOWN:
1104  SDL_Log("SDL EVENT: Keyboard: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1105  event->key.windowID,
1106  event->key.keysym.scancode,
1108  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1109  break;
1110  case SDL_KEYUP:
1111  SDL_Log("SDL EVENT: Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1112  event->key.windowID,
1113  event->key.keysym.scancode,
1115  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1116  break;
1117  case SDL_TEXTEDITING:
1118  SDL_Log("SDL EVENT: Keyboard: text editing \"%s\" in window %d",
1119  event->edit.text, event->edit.windowID);
1120  break;
1121  case SDL_TEXTINPUT:
1122  SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %d",
1123  event->text.text, event->text.windowID);
1124  break;
1125  case SDL_KEYMAPCHANGED:
1126  SDL_Log("SDL EVENT: Keymap changed");
1127  break;
1128  case SDL_MOUSEMOTION:
1129  SDL_Log("SDL EVENT: Mouse: moved to %d,%d (%d,%d) in window %d",
1130  event->motion.x, event->motion.y,
1131  event->motion.xrel, event->motion.yrel,
1132  event->motion.windowID);
1133  break;
1134  case SDL_MOUSEBUTTONDOWN:
1135  SDL_Log("SDL EVENT: Mouse: button %d pressed at %d,%d with click count %d in window %d",
1136  event->button.button, event->button.x, event->button.y, event->button.clicks,
1137  event->button.windowID);
1138  break;
1139  case SDL_MOUSEBUTTONUP:
1140  SDL_Log("SDL EVENT: Mouse: button %d released at %d,%d with click count %d in window %d",
1141  event->button.button, event->button.x, event->button.y, event->button.clicks,
1142  event->button.windowID);
1143  break;
1144  case SDL_MOUSEWHEEL:
1145  SDL_Log("SDL EVENT: Mouse: wheel scrolled %d in x and %d in y (reversed: %d) in window %d",
1146  event->wheel.x, event->wheel.y, event->wheel.direction, event->wheel.windowID);
1147  break;
1148  case SDL_JOYDEVICEADDED:
1149  SDL_Log("SDL EVENT: Joystick index %d attached",
1150  event->jdevice.which);
1151  break;
1152  case SDL_JOYDEVICEREMOVED:
1153  SDL_Log("SDL EVENT: Joystick %d removed",
1154  event->jdevice.which);
1155  break;
1156  case SDL_JOYBALLMOTION:
1157  SDL_Log("SDL EVENT: Joystick %d: ball %d moved by %d,%d",
1158  event->jball.which, event->jball.ball, event->jball.xrel,
1159  event->jball.yrel);
1160  break;
1161  case SDL_JOYHATMOTION:
1162  {
1163  const char *position = "UNKNOWN";
1164  switch (event->jhat.value) {
1165  case SDL_HAT_CENTERED:
1166  position = "CENTER";
1167  break;
1168  case SDL_HAT_UP:
1169  position = "UP";
1170  break;
1171  case SDL_HAT_RIGHTUP:
1172  position = "RIGHTUP";
1173  break;
1174  case SDL_HAT_RIGHT:
1175  position = "RIGHT";
1176  break;
1177  case SDL_HAT_RIGHTDOWN:
1178  position = "RIGHTDOWN";
1179  break;
1180  case SDL_HAT_DOWN:
1181  position = "DOWN";
1182  break;
1183  case SDL_HAT_LEFTDOWN:
1184  position = "LEFTDOWN";
1185  break;
1186  case SDL_HAT_LEFT:
1187  position = "LEFT";
1188  break;
1189  case SDL_HAT_LEFTUP:
1190  position = "LEFTUP";
1191  break;
1192  }
1193  SDL_Log("SDL EVENT: Joystick %d: hat %d moved to %s", event->jhat.which,
1194  event->jhat.hat, position);
1195  }
1196  break;
1197  case SDL_JOYBUTTONDOWN:
1198  SDL_Log("SDL EVENT: Joystick %d: button %d pressed",
1199  event->jbutton.which, event->jbutton.button);
1200  break;
1201  case SDL_JOYBUTTONUP:
1202  SDL_Log("SDL EVENT: Joystick %d: button %d released",
1203  event->jbutton.which, event->jbutton.button);
1204  break;
1206  SDL_Log("SDL EVENT: Controller index %d attached",
1207  event->cdevice.which);
1208  break;
1210  SDL_Log("SDL EVENT: Controller %d removed",
1211  event->cdevice.which);
1212  break;
1214  SDL_Log("SDL EVENT: Controller %d axis %d ('%s') value: %d",
1215  event->caxis.which,
1216  event->caxis.axis,
1218  event->caxis.value);
1219  break;
1221  SDL_Log("SDL EVENT: Controller %d button %d ('%s') down",
1222  event->cbutton.which, event->cbutton.button,
1224  break;
1226  SDL_Log("SDL EVENT: Controller %d button %d ('%s') up",
1227  event->cbutton.which, event->cbutton.button,
1229  break;
1230  case SDL_CLIPBOARDUPDATE:
1231  SDL_Log("SDL EVENT: Clipboard updated");
1232  break;
1233 
1234  case SDL_FINGERMOTION:
1235  SDL_Log("SDL EVENT: Finger: motion touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
1236  (long) event->tfinger.touchId,
1237  (long) event->tfinger.fingerId,
1238  event->tfinger.x, event->tfinger.y,
1239  event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
1240  break;
1241  case SDL_FINGERDOWN:
1242  case SDL_FINGERUP:
1243  SDL_Log("SDL EVENT: Finger: %s touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
1244  (event->type == SDL_FINGERDOWN) ? "down" : "up",
1245  (long) event->tfinger.touchId,
1246  (long) event->tfinger.fingerId,
1247  event->tfinger.x, event->tfinger.y,
1248  event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
1249  break;
1250  case SDL_DOLLARGESTURE:
1251  SDL_Log("SDL_EVENT: Dollar gesture detect: %ld", (long) event->dgesture.gestureId);
1252  break;
1253  case SDL_DOLLARRECORD:
1254  SDL_Log("SDL_EVENT: Dollar gesture record: %ld", (long) event->dgesture.gestureId);
1255  break;
1256  case SDL_MULTIGESTURE:
1257  SDL_Log("SDL_EVENT: Multi gesture fingers: %d", event->mgesture.numFingers);
1258  break;
1259 
1261  SDL_Log("SDL EVENT: render device reset");
1262  break;
1264  SDL_Log("SDL EVENT: render targets reset");
1265  break;
1266 
1267  case SDL_APP_TERMINATING:
1268  SDL_Log("SDL EVENT: App terminating");
1269  break;
1270  case SDL_APP_LOWMEMORY:
1271  SDL_Log("SDL EVENT: App running low on memory");
1272  break;
1274  SDL_Log("SDL EVENT: App will enter the background");
1275  break;
1277  SDL_Log("SDL EVENT: App entered the background");
1278  break;
1280  SDL_Log("SDL EVENT: App will enter the foreground");
1281  break;
1283  SDL_Log("SDL EVENT: App entered the foreground");
1284  break;
1285 
1286  case SDL_QUIT:
1287  SDL_Log("SDL EVENT: Quit requested");
1288  break;
1289  case SDL_USEREVENT:
1290  SDL_Log("SDL EVENT: User event %d", event->user.code);
1291  break;
1292  default:
1293  SDL_Log("Unknown event 0x%4.4x", event->type);
1294  break;
1295  }
1296 }
#define SDL_HAT_LEFTDOWN
Definition: SDL_joystick.h:310
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:307
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:304
SDL_JoystickID which
Definition: SDL_events.h:299
#define SDL_Log
SDL_TextInputEvent text
Definition: SDL_events.h:532
char text[SDL_TEXTINPUTEVENT_TEXT_SIZE]
Definition: SDL_events.h:226
#define SDL_HAT_RIGHTDOWN
Definition: SDL_joystick.h:308
static const char * ControllerButtonName(const SDL_GameControllerButton button)
#define SDL_HAT_LEFT
Definition: SDL_joystick.h:306
SDL_MultiGestureEvent mgesture
Definition: SDL_events.h:549
char text[SDL_TEXTEDITINGEVENT_TEXT_SIZE]
Definition: SDL_events.h:211
SDL_Keysym keysym
Definition: SDL_events.h:199
SDL_TextEditingEvent edit
Definition: SDL_events.h:531
#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:309
#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
SDL_JoyHatEvent jhat
Definition: SDL_events.h:538
#define SDL_HAT_CENTERED
Definition: SDL_joystick.h:302
#define SDL_HAT_UP
Definition: SDL_joystick.h:303
#define SDL_HAT_DOWN
Definition: SDL_joystick.h:305
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
static void SDLTest_PrintPixelFormat ( char *  text,
size_t  maxlen,
Uint32  format 
)
static

Definition at line 500 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, SDL_PIXELFORMAT_YVYU, and SDL_snprintfcat().

Referenced by SDLTest_PrintRenderer().

501 {
502  switch (format) {
504  SDL_snprintfcat(text, maxlen, "Unknown");
505  break;
507  SDL_snprintfcat(text, maxlen, "Index1LSB");
508  break;
510  SDL_snprintfcat(text, maxlen, "Index1MSB");
511  break;
513  SDL_snprintfcat(text, maxlen, "Index4LSB");
514  break;
516  SDL_snprintfcat(text, maxlen, "Index4MSB");
517  break;
519  SDL_snprintfcat(text, maxlen, "Index8");
520  break;
522  SDL_snprintfcat(text, maxlen, "RGB332");
523  break;
525  SDL_snprintfcat(text, maxlen, "RGB444");
526  break;
528  SDL_snprintfcat(text, maxlen, "RGB555");
529  break;
531  SDL_snprintfcat(text, maxlen, "BGR555");
532  break;
534  SDL_snprintfcat(text, maxlen, "ARGB4444");
535  break;
537  SDL_snprintfcat(text, maxlen, "ABGR4444");
538  break;
540  SDL_snprintfcat(text, maxlen, "ARGB1555");
541  break;
543  SDL_snprintfcat(text, maxlen, "ABGR1555");
544  break;
546  SDL_snprintfcat(text, maxlen, "RGB565");
547  break;
549  SDL_snprintfcat(text, maxlen, "BGR565");
550  break;
552  SDL_snprintfcat(text, maxlen, "RGB24");
553  break;
555  SDL_snprintfcat(text, maxlen, "BGR24");
556  break;
558  SDL_snprintfcat(text, maxlen, "RGB888");
559  break;
561  SDL_snprintfcat(text, maxlen, "BGR888");
562  break;
564  SDL_snprintfcat(text, maxlen, "ARGB8888");
565  break;
567  SDL_snprintfcat(text, maxlen, "RGBA8888");
568  break;
570  SDL_snprintfcat(text, maxlen, "ABGR8888");
571  break;
573  SDL_snprintfcat(text, maxlen, "BGRA8888");
574  break;
576  SDL_snprintfcat(text, maxlen, "ARGB2101010");
577  break;
579  SDL_snprintfcat(text, maxlen, "YV12");
580  break;
582  SDL_snprintfcat(text, maxlen, "IYUV");
583  break;
585  SDL_snprintfcat(text, maxlen, "YUY2");
586  break;
588  SDL_snprintfcat(text, maxlen, "UYVY");
589  break;
591  SDL_snprintfcat(text, maxlen, "YVYU");
592  break;
594  SDL_snprintfcat(text, maxlen, "NV12");
595  break;
597  SDL_snprintfcat(text, maxlen, "NV21");
598  break;
599  default:
600  SDL_snprintfcat(text, maxlen, "0x%8.8x", format);
601  break;
602  }
603 }
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
static void SDLTest_PrintRenderer ( SDL_RendererInfo info)
static

Definition at line 606 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, SDL_Log, SDL_snprintf, SDL_snprintfcat(), SDLTest_PrintPixelFormat(), SDLTest_PrintRendererFlag(), text, and SDL_RendererInfo::texture_formats.

Referenced by SDLTest_CommonInit().

607 {
608  int i, count;
609  char text[1024];
610 
611  SDL_Log(" Renderer %s:\n", info->name);
612 
613  SDL_snprintf(text, sizeof(text), " Flags: 0x%8.8X", info->flags);
614  SDL_snprintfcat(text, sizeof(text), " (");
615  count = 0;
616  for (i = 0; i < sizeof(info->flags) * 8; ++i) {
617  Uint32 flag = (1 << i);
618  if (info->flags & flag) {
619  if (count > 0) {
620  SDL_snprintfcat(text, sizeof(text), " | ");
621  }
622  SDLTest_PrintRendererFlag(text, sizeof(text), flag);
623  ++count;
624  }
625  }
626  SDL_snprintfcat(text, sizeof(text), ")");
627  SDL_Log("%s\n", text);
628 
629  SDL_snprintf(text, sizeof(text), " Texture formats (%d): ", info->num_texture_formats);
630  for (i = 0; i < (int) info->num_texture_formats; ++i) {
631  if (i > 0) {
632  SDL_snprintfcat(text, sizeof(text), ", ");
633  }
634  SDLTest_PrintPixelFormat(text, sizeof(text), info->texture_formats[i]);
635  }
636  SDL_Log("%s\n", text);
637 
638  if (info->max_texture_width || info->max_texture_height) {
639  SDL_Log(" Max Texture Size: %dx%d\n",
641  }
642 }
static void SDLTest_PrintRendererFlag(char *text, size_t maxlen, Uint32 flag)
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
Uint32 texture_formats[16]
Definition: SDL_render.h:83
uint32_t Uint32
Definition: SDL_stdinc.h:181
const char * name
Definition: SDL_render.h:80
int max_texture_height
Definition: SDL_render.h:85
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_Log
static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
static void SDLTest_PrintPixelFormat(char *text, size_t maxlen, Uint32 format)
Uint32 num_texture_formats
Definition: SDL_render.h:82
#define SDL_snprintf
static void SDLTest_PrintRendererFlag ( char *  text,
size_t  maxlen,
Uint32  flag 
)
static

Definition at line 478 of file SDL_test_common.c.

References SDL_RENDERER_ACCELERATED, SDL_RENDERER_PRESENTVSYNC, SDL_RENDERER_SOFTWARE, SDL_RENDERER_TARGETTEXTURE, and SDL_snprintfcat().

Referenced by SDLTest_PrintRenderer().

479 {
480  switch (flag) {
482  SDL_snprintfcat(text, maxlen, "Software");
483  break;
485  SDL_snprintfcat(text, maxlen, "Accelerated");
486  break;
488  SDL_snprintfcat(text, maxlen, "PresentVSync");
489  break;
491  SDL_snprintfcat(text, maxlen, "TargetTexturesSupported");
492  break;
493  default:
494  SDL_snprintfcat(text, maxlen, "0x%8.8x", flag);
495  break;
496  }
497 }
static void SDL_snprintfcat(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
static char text[MAX_TEXT_LENGTH]
Definition: testime.c:47
static void SDLTest_ScreenShot ( SDL_Renderer renderer)
static

Definition at line 1299 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_Log, SDL_RenderGetViewport, SDL_RenderReadPixels, SDL_SaveBMP, viewport, and SDL_Rect::w.

Referenced by SDLTest_CommonEvent().

1300 {
1303 
1304  if (!renderer) {
1305  return;
1306  }
1307 
1308  SDL_RenderGetViewport(renderer, &viewport);
1309  surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
1311  0x00FF0000, 0x0000FF00, 0x000000FF,
1312 #else
1313  0x000000FF, 0x0000FF00, 0x00FF0000,
1314 #endif
1315  0x00000000);
1316  if (!surface) {
1317  SDL_Log("Couldn't create surface: %s\n", SDL_GetError());
1318  return;
1319  }
1320 
1321  if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
1322  surface->pixels, surface->pitch) < 0) {
1323  SDL_Log("Couldn't read screen: %s\n", SDL_GetError());
1324  SDL_free(surface);
1325  return;
1326  }
1327 
1328  if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
1329  SDL_Log("Couldn't save screenshot.bmp: %s\n", SDL_GetError());
1330  SDL_free(surface);
1331  return;
1332  }
1333 }
#define SDL_RenderReadPixels
#define SDL_GetError
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
#define SDL_SaveBMP(surface, file)
Definition: SDL_surface.h:212
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
#define SDL_Log
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:164
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