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

#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 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
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)
static void FullscreenTo ( int  index,
int  windowId 
)
static

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

1274 {
1275  Uint32 flags;
1276  struct SDL_Rect rect = { 0, 0, 0, 0 };
1277  SDL_Window *window = SDL_GetWindowFromID(windowId);
1278  if (!window) {
1279  return;
1280  }
1281 
1282  SDL_GetDisplayBounds( index, &rect );
1283 
1284  flags = SDL_GetWindowFlags(window);
1285  if (flags & SDL_WINDOW_FULLSCREEN) {
1287  SDL_Delay( 15 );
1288  }
1289 
1290  SDL_SetWindowPosition( window, rect.x, rect.y );
1291  SDL_SetWindowFullscreen( window, SDL_TRUE );
1292 }
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
#define SDL_SetWindowFullscreen
SDL_Rect rect
Definition: testrelative.c:27
SDL_Window * window
#define SDL_GetWindowFlags
#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
int SDLTest_CommonArg ( SDLTest_CommonState state,
int  index 
)

Process one common argument.

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

Definition at line 83 of file SDL_test_common.c.

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

Referenced by main().

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

Parse command line parameters and create common state.

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

Definition at line 36 of file SDL_test_common.c.

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

Referenced by main().

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

Common event handler for test windows.

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

Definition at line 1295 of file SDL_test_common.c.

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

Referenced by loop(), and main().

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

Open test window.

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

Definition at line 645 of file SDL_test_common.c.

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

Referenced by main().

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

Close test window.

Parameters
stateThe common state used to create test window.

Definition at line 1560 of file SDL_test_common.c.

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

Referenced by main(), and quit().

1561 {
1562  int i;
1563 
1564  SDL_free(state->windows);
1565  if (state->targets) {
1566  for (i = 0; i < state->num_windows; ++i) {
1567  if (state->targets[i]) {
1568  SDL_DestroyTexture(state->targets[i]);
1569  }
1570  }
1571  SDL_free(state->targets);
1572  }
1573  if (state->renderers) {
1574  for (i = 0; i < state->num_windows; ++i) {
1575  if (state->renderers[i]) {
1576  SDL_DestroyRenderer(state->renderers[i]);
1577  }
1578  }
1579  SDL_free(state->renderers);
1580  }
1581  if (state->flags & SDL_INIT_VIDEO) {
1582  SDL_VideoQuit();
1583  }
1584  if (state->flags & SDL_INIT_AUDIO) {
1585  SDL_AudioQuit();
1586  }
1587  SDL_free(state);
1588  SDL_Quit();
1589 }
SDL_Texture ** targets
#define SDL_AudioQuit
SDL_Window ** windows
void SDL_free(void *mem)
#define SDL_Quit
SDL_Renderer ** renderers
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:42
#define SDL_INIT_AUDIO
Definition: SDL.h:76
#define SDL_DestroyTexture
#define SDL_VideoQuit
#define SDL_DestroyRenderer
#define SDL_INIT_VIDEO
Definition: SDL.h:77
const char* SDLTest_CommonUsage ( SDLTest_CommonState state)

Returns common usage information.

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

Definition at line 451 of file SDL_test_common.c.

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

Referenced by main().

452 {
453  switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
454  case SDL_INIT_VIDEO:
455  return VIDEO_USAGE;
456  case SDL_INIT_AUDIO:
457  return AUDIO_USAGE;
459  return VIDEO_USAGE " " AUDIO_USAGE;
460  default:
461  return "";
462  }
463 }
#define AUDIO_USAGE
#define VIDEO_USAGE
#define SDL_INIT_AUDIO
Definition: SDL.h:76
#define SDL_INIT_VIDEO
Definition: SDL.h:77
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:182
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:139
#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:302
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_LEAVE, SDL_WINDOWEVENT_MAXIMIZED, SDL_WINDOWEVENT_MINIMIZED, SDL_WINDOWEVENT_MOVED, SDL_WINDOWEVENT_RESIZED, SDL_WINDOWEVENT_RESTORED, SDL_WINDOWEVENT_SHOWN, SDL_WINDOWEVENT_SIZE_CHANGED, 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;
1067  default:
1068  SDL_Log("SDL EVENT: Window %d got unknown event %d",
1069  event->window.windowID, event->window.event);
1070  break;
1071  }
1072  break;
1073  case SDL_KEYDOWN:
1074  SDL_Log("SDL EVENT: Keyboard: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1075  event->key.windowID,
1076  event->key.keysym.scancode,
1078  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1079  break;
1080  case SDL_KEYUP:
1081  SDL_Log("SDL EVENT: Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
1082  event->key.windowID,
1083  event->key.keysym.scancode,
1085  event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
1086  break;
1087  case SDL_TEXTINPUT:
1088  SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %d",
1089  event->text.text, event->text.windowID);
1090  break;
1091  case SDL_MOUSEMOTION:
1092  SDL_Log("SDL EVENT: Mouse: moved to %d,%d (%d,%d) in window %d",
1093  event->motion.x, event->motion.y,
1094  event->motion.xrel, event->motion.yrel,
1095  event->motion.windowID);
1096  break;
1097  case SDL_MOUSEBUTTONDOWN:
1098  SDL_Log("SDL EVENT: Mouse: button %d pressed at %d,%d with click count %d in window %d",
1099  event->button.button, event->button.x, event->button.y, event->button.clicks,
1100  event->button.windowID);
1101  break;
1102  case SDL_MOUSEBUTTONUP:
1103  SDL_Log("SDL EVENT: Mouse: button %d released at %d,%d with click count %d in window %d",
1104  event->button.button, event->button.x, event->button.y, event->button.clicks,
1105  event->button.windowID);
1106  break;
1107  case SDL_MOUSEWHEEL:
1108  SDL_Log("SDL EVENT: Mouse: wheel scrolled %d in x and %d in y (reversed: %d) in window %d",
1109  event->wheel.x, event->wheel.y, event->wheel.direction, event->wheel.windowID);
1110  break;
1111  case SDL_JOYDEVICEADDED:
1112  SDL_Log("SDL EVENT: Joystick index %d attached",
1113  event->jdevice.which);
1114  break;
1115  case SDL_JOYDEVICEREMOVED:
1116  SDL_Log("SDL EVENT: Joystick %d removed",
1117  event->jdevice.which);
1118  break;
1119  case SDL_JOYBALLMOTION:
1120  SDL_Log("SDL EVENT: Joystick %d: ball %d moved by %d,%d",
1121  event->jball.which, event->jball.ball, event->jball.xrel,
1122  event->jball.yrel);
1123  break;
1124  case SDL_JOYHATMOTION:
1125  {
1126  const char *position = "UNKNOWN";
1127  switch (event->jhat.value) {
1128  case SDL_HAT_CENTERED:
1129  position = "CENTER";
1130  break;
1131  case SDL_HAT_UP:
1132  position = "UP";
1133  break;
1134  case SDL_HAT_RIGHTUP:
1135  position = "RIGHTUP";
1136  break;
1137  case SDL_HAT_RIGHT:
1138  position = "RIGHT";
1139  break;
1140  case SDL_HAT_RIGHTDOWN:
1141  position = "RIGHTDOWN";
1142  break;
1143  case SDL_HAT_DOWN:
1144  position = "DOWN";
1145  break;
1146  case SDL_HAT_LEFTDOWN:
1147  position = "LEFTDOWN";
1148  break;
1149  case SDL_HAT_LEFT:
1150  position = "LEFT";
1151  break;
1152  case SDL_HAT_LEFTUP:
1153  position = "LEFTUP";
1154  break;
1155  }
1156  SDL_Log("SDL EVENT: Joystick %d: hat %d moved to %s", event->jhat.which,
1157  event->jhat.hat, position);
1158  }
1159  break;
1160  case SDL_JOYBUTTONDOWN:
1161  SDL_Log("SDL EVENT: Joystick %d: button %d pressed",
1162  event->jbutton.which, event->jbutton.button);
1163  break;
1164  case SDL_JOYBUTTONUP:
1165  SDL_Log("SDL EVENT: Joystick %d: button %d released",
1166  event->jbutton.which, event->jbutton.button);
1167  break;
1169  SDL_Log("SDL EVENT: Controller index %d attached",
1170  event->cdevice.which);
1171  break;
1173  SDL_Log("SDL EVENT: Controller %d removed",
1174  event->cdevice.which);
1175  break;
1177  SDL_Log("SDL EVENT: Controller %d axis %d ('%s') value: %d",
1178  event->caxis.which,
1179  event->caxis.axis,
1181  event->caxis.value);
1182  break;
1184  SDL_Log("SDL EVENT: Controller %d button %d ('%s') down",
1185  event->cbutton.which, event->cbutton.button,
1187  break;
1189  SDL_Log("SDL EVENT: Controller %d button %d ('%s') up",
1190  event->cbutton.which, event->cbutton.button,
1192  break;
1193  case SDL_CLIPBOARDUPDATE:
1194  SDL_Log("SDL EVENT: Clipboard updated");
1195  break;
1196 
1197  case SDL_FINGERDOWN:
1198  case SDL_FINGERUP:
1199  SDL_Log("SDL EVENT: Finger: %s touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
1200  (event->type == SDL_FINGERDOWN) ? "down" : "up",
1201  (long) event->tfinger.touchId,
1202  (long) event->tfinger.fingerId,
1203  event->tfinger.x, event->tfinger.y,
1204  event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
1205  break;
1206  case SDL_DOLLARGESTURE:
1207  SDL_Log("SDL_EVENT: Dollar gesture detect: %"SDL_PRIs64, (Sint64) event->dgesture.gestureId);
1208  break;
1209  case SDL_DOLLARRECORD:
1210  SDL_Log("SDL_EVENT: Dollar gesture record: %"SDL_PRIs64, (Sint64) event->dgesture.gestureId);
1211  break;
1212  case SDL_MULTIGESTURE:
1213  SDL_Log("SDL_EVENT: Multi gesture fingers: %d", event->mgesture.numFingers);
1214  break;
1215 
1217  SDL_Log("SDL EVENT: render device reset");
1218  break;
1220  SDL_Log("SDL EVENT: render targets reset");
1221  break;
1222 
1223  case SDL_QUIT:
1224  SDL_Log("SDL EVENT: Quit requested");
1225  break;
1226  case SDL_USEREVENT:
1227  SDL_Log("SDL EVENT: User event %d", event->user.code);
1228  break;
1229  default:
1230  SDL_Log("Unknown event %04x", event->type);
1231  break;
1232  }
1233 }
#define SDL_HAT_LEFTDOWN
Definition: SDL_joystick.h:215
SDL_JoystickID which
Definition: SDL_events.h:357
SDL_MouseMotionEvent motion
Definition: SDL_events.h:529
SDL_JoystickID which
Definition: SDL_events.h:332
SDL_ControllerAxisEvent caxis
Definition: SDL_events.h:537
SDL_JoyDeviceEvent jdevice
Definition: SDL_events.h:536
SDL_DollarGestureEvent dgesture
Definition: SDL_events.h:546
SDL_ControllerDeviceEvent cdevice
Definition: SDL_events.h:539
SDL_JoyButtonEvent jbutton
Definition: SDL_events.h:535
#define SDL_HAT_RIGHTUP
Definition: SDL_joystick.h:212
SDL_JoyBallEvent jball
Definition: SDL_events.h:533
SDL_TouchID touchId
Definition: SDL_events.h:414
SDL_Scancode scancode
Definition: SDL_keyboard.h:49
SDL_GameControllerButton
SDL_GestureID gestureId
Definition: SDL_events.h:449
SDL_JoystickID which
Definition: SDL_events.h:374
SDL_MouseWheelEvent wheel
Definition: SDL_events.h:531
SDL_WindowEvent window
Definition: SDL_events.h:525
#define SDL_HAT_RIGHT
Definition: SDL_joystick.h:209
SDL_JoystickID which
Definition: SDL_events.h:296
#define SDL_Log
SDL_TextInputEvent text
Definition: SDL_events.h:528
#define SDL_PRIs64
Definition: SDL_stdinc.h:175
char text[SDL_TEXTINPUTEVENT_TEXT_SIZE]
Definition: SDL_events.h:223
#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:545
SDL_Keysym keysym
Definition: SDL_events.h:196
#define SDL_GetScancodeName
SDL_KeyboardEvent key
Definition: SDL_events.h:526
SDL_ControllerButtonEvent cbutton
Definition: SDL_events.h:538
#define SDL_HAT_LEFTUP
Definition: SDL_joystick.h:214
#define SDL_GetKeyName
SDL_FingerID fingerId
Definition: SDL_events.h:415
SDL_Keycode sym
Definition: SDL_keyboard.h:50
static const char * ControllerAxisName(const SDL_GameControllerAxis axis)
SDL_MouseButtonEvent button
Definition: SDL_events.h:530
SDL_UserEvent user
Definition: SDL_events.h:542
int64_t Sint64
A signed 64-bit integer type.
Definition: SDL_stdinc.h:160
SDL_JoyHatEvent jhat
Definition: SDL_events.h:534
#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:312
SDL_GameControllerAxis
Uint32 type
Definition: SDL_events.h:523
SDL_TouchFingerEvent tfinger
Definition: SDL_events.h:544
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
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 }
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:155
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1564
Uint32 texture_formats[16]
Definition: SDL_render.h:83
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:42
Uint32 num_texture_formats
Definition: SDL_render.h:82
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 }
static void SDLTest_ScreenShot ( SDL_Renderer renderer)
static

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

1237 {
1239  SDL_Surface *surface;
1240 
1241  if (!renderer) {
1242  return;
1243  }
1244 
1245  SDL_RenderGetViewport(renderer, &viewport);
1246  surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
1248  0x00FF0000, 0x0000FF00, 0x000000FF,
1249 #else
1250  0x000000FF, 0x0000FF00, 0x00FF0000,
1251 #endif
1252  0x00000000);
1253  if (!surface) {
1254  fprintf(stderr, "Couldn't create surface: %s\n", SDL_GetError());
1255  return;
1256  }
1257 
1258  if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
1259  surface->pixels, surface->pitch) < 0) {
1260  fprintf(stderr, "Couldn't read screen: %s\n", SDL_GetError());
1261  SDL_free(surface);
1262  return;
1263  }
1264 
1265  if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
1266  fprintf(stderr, "Couldn't save screenshot.bmp: %s\n", SDL_GetError());
1267  SDL_free(surface);
1268  return;
1269  }
1270 }
#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:199
#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