SDL 2.0
SDL_test_common.h File Reference
#include "SDL.h"
#include "begin_code.h"
#include "close_code.h"
+ Include dependency graph for SDL_test_common.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  SDLTest_CommonState
 

Macros

#define DEFAULT_WINDOW_WIDTH   640
 
#define DEFAULT_WINDOW_HEIGHT   480
 
#define VERBOSE_VIDEO   0x00000001
 
#define VERBOSE_MODES   0x00000002
 
#define VERBOSE_RENDER   0x00000004
 
#define VERBOSE_EVENT   0x00000008
 
#define VERBOSE_AUDIO   0x00000010
 

Functions

SDLTest_CommonStateSDLTest_CommonCreateState (char **argv, Uint32 flags)
 Parse command line parameters and create common state. More...
 
int SDLTest_CommonArg (SDLTest_CommonState *state, int index)
 Process one common argument. More...
 
void SDLTest_CommonLogUsage (SDLTest_CommonState *state, const char *argv0, const char **options)
 Logs command line usage info. More...
 
SDL_bool SDLTest_CommonInit (SDLTest_CommonState *state)
 Open test window. More...
 
SDL_bool SDLTest_CommonDefaultArgs (SDLTest_CommonState *state, const int argc, char **argv)
 Easy argument handling when test app doesn't need any custom args. More...
 
void SDLTest_CommonEvent (SDLTest_CommonState *state, SDL_Event *event, int *done)
 Common event handler for test windows. More...
 
void SDLTest_CommonQuit (SDLTest_CommonState *state)
 Close test window. More...
 

Detailed Description

Include file for SDL test framework.

This code is a part of the SDL2_test library, not the main SDL library.

Definition in file SDL_test_common.h.

Macro Definition Documentation

◆ DEFAULT_WINDOW_HEIGHT

#define DEFAULT_WINDOW_HEIGHT   480

Definition at line 42 of file SDL_test_common.h.

◆ DEFAULT_WINDOW_WIDTH

#define DEFAULT_WINDOW_WIDTH   640

Definition at line 41 of file SDL_test_common.h.

◆ VERBOSE_AUDIO

#define VERBOSE_AUDIO   0x00000010

Definition at line 49 of file SDL_test_common.h.

◆ VERBOSE_EVENT

#define VERBOSE_EVENT   0x00000008

Definition at line 48 of file SDL_test_common.h.

◆ VERBOSE_MODES

#define VERBOSE_MODES   0x00000002

Definition at line 46 of file SDL_test_common.h.

◆ VERBOSE_RENDER

#define VERBOSE_RENDER   0x00000004

Definition at line 47 of file SDL_test_common.h.

◆ VERBOSE_VIDEO

#define VERBOSE_VIDEO   0x00000001

Definition at line 45 of file SDL_test_common.h.

Function Documentation

◆ SDLTest_CommonArg()

int SDLTest_CommonArg ( SDLTest_CommonState state,
int  index 
)

Process one common argument.

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

Definition at line 117 of file SDL_test_common.c.

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

References AUDIO_S16, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S8, AUDIO_U16, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, SDL_atof, SDL_atoi, SDL_isdigit, SDL_LOG_CATEGORY_AUDIO, SDL_LOG_CATEGORY_ERROR, SDL_LOG_CATEGORY_INPUT, SDL_LOG_CATEGORY_RENDER, SDL_LOG_CATEGORY_SYSTEM, SDL_LOG_CATEGORY_VIDEO, SDL_LOG_PRIORITY_VERBOSE, SDL_LogSetAllPriority, SDL_LogSetPriority, SDL_RENDERER_PRESENTVSYNC, SDL_strcasecmp, SDL_strcmp, SDL_WINDOW_ALLOW_HIGHDPI, SDL_WINDOW_BORDERLESS, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSCREEN_DESKTOP, SDL_WINDOW_INPUT_GRABBED, SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MINIMIZED, SDL_WINDOW_RESIZABLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED_DISPLAY, SDL_WINDOWPOS_ISCENTERED, SDL_WINDOWPOS_ISUNDEFINED, SDL_WINDOWPOS_UNDEFINED_DISPLAY, state, VERBOSE_EVENT, VERBOSE_MODES, VERBOSE_RENDER, and VERBOSE_VIDEO.

Referenced by main(), and SDLTest_CommonDefaultArgs().

◆ SDLTest_CommonCreateState()

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

Parse command line parameters and create common state.

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

Definition at line 59 of file SDL_test_common.c.

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

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

Referenced by main().

◆ SDLTest_CommonDefaultArgs()

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

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

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

Definition at line 516 of file SDL_test_common.c.

517{
518 int i = 1;
519 while (i < argc) {
520 const int consumed = SDLTest_CommonArg(state, i);
521 if (consumed == 0) {
523 return SDL_FALSE;
524 }
525 i += consumed;
526 }
527 return SDL_TRUE;
528}
@ SDL_TRUE
Definition: SDL_stdinc.h:164
@ SDL_FALSE
Definition: SDL_stdinc.h:163
int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
Process one common argument.
void SDLTest_CommonLogUsage(SDLTest_CommonState *state, const char *argv0, const char **options)
Logs command line usage info.

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

Referenced by main().

◆ SDLTest_CommonEvent()

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

Common event handler for test windows.

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

Definition at line 1501 of file SDL_test_common.c.

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

References done, FullscreenTo(), SDL_Rect::h, i, KMOD_ALT, KMOD_CTRL, KMOD_SHIFT, NULL, SDL_BUTTON_LMASK, SDL_BUTTON_MMASK, SDL_BUTTON_RMASK, SDL_BUTTON_X1MASK, SDL_BUTTON_X2MASK, SDL_CaptureMouse, SDL_DestroyRenderer, SDL_DestroyTexture, SDL_DestroyWindow, SDL_DROPFILE, SDL_DROPTEXT, SDL_FALSE, SDL_free, SDL_GetClipboardText, SDL_GetGlobalMouseState, SDL_GetKeyboardFocus, SDL_GetNumVideoDisplays, SDL_GetRelativeMouseMode, SDL_GetWindowDisplayIndex, SDL_GetWindowFlags, SDL_GetWindowFromID, SDL_GetWindowGrab, SDL_GetWindowOpacity, SDL_GetWindowPosition, SDL_GetWindowSize, SDL_KEYDOWN, SDL_Log, SDL_MaximizeWindow, SDL_MESSAGEBOX_INFORMATION, SDL_MinimizeWindow, SDL_MOUSEMOTION, SDL_QUIT, SDL_RectEmpty(), SDL_RenderGetClipRect, SDL_RenderSetClipRect, SDL_RestoreWindow, SDL_SetClipboardText, SDL_SetRelativeMouseMode, SDL_SetWindowBordered, SDL_SetWindowFullscreen, SDL_SetWindowGrab, SDL_SetWindowOpacity, SDL_SetWindowPosition, SDL_SetWindowSize, SDL_ShowSimpleMessageBox, SDL_snprintf, SDL_TRUE, SDL_WINDOW_BORDERLESS, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSCREEN_DESKTOP, SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MOUSE_CAPTURE, SDL_WINDOWEVENT, SDL_WINDOWEVENT_CLOSE, SDL_WINDOWPOS_CENTERED_DISPLAY, SDLK_0, SDLK_1, SDLK_2, SDLK_a, SDLK_b, SDLK_c, SDLK_DOWN, SDLK_EQUALS, SDLK_ESCAPE, SDLK_g, SDLK_LEFT, SDLK_m, SDLK_MINUS, SDLK_o, SDLK_PRINTSCREEN, SDLK_r, SDLK_RETURN, SDLK_RIGHT, SDLK_SPACE, SDLK_UP, SDLK_v, SDLK_z, SDLTest_PrintEvent(), SDLTest_ScreenShot(), state, text, VERBOSE_EVENT, SDL_Rect::w, SDL_MouseMotionEvent::x, SDL_Rect::x, SDL_MouseMotionEvent::xrel, SDL_MouseMotionEvent::y, SDL_Rect::y, and SDL_MouseMotionEvent::yrel.

Referenced by loop(), and main().

◆ SDLTest_CommonInit()

SDL_bool SDLTest_CommonInit ( SDLTest_CommonState state)

Open test window.

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

Definition at line 764 of file SDL_test_common.c.

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

References SDL_DisplayMode::format, SDL_Rect::h, i, j, SDL_RendererInfo::name, NULL, SDL_DisplayMode::refresh_rate, SDL_arraysize, SDL_AudioInit, SDL_calloc, SDL_CreateRenderer, SDL_CreateWindow, SDL_Direct3D9GetAdapterIndex(), SDL_DXGIGetOutputInfo(), SDL_FALSE, SDL_FreeSurface, SDL_GetAudioDriver, SDL_GetCurrentAudioDriver, SDL_GetCurrentVideoDriver, SDL_GetDesktopDisplayMode, SDL_GetDisplayBounds, SDL_GetDisplayDPI, SDL_GetDisplayMode, SDL_GetDisplayName, SDL_GetDisplayUsableBounds, SDL_GetError, SDL_GetNumAudioDrivers, SDL_GetNumDisplayModes, SDL_GetNumRenderDrivers, SDL_GetNumVideoDisplays, SDL_GetNumVideoDrivers, SDL_GetPixelFormatName, SDL_GetRenderDriverInfo, SDL_GetRendererInfo, SDL_GetVideoDriver, SDL_GetWindowSize, SDL_GL_ACCELERATED_VISUAL, SDL_GL_ACCUM_ALPHA_SIZE, SDL_GL_ACCUM_BLUE_SIZE, SDL_GL_ACCUM_GREEN_SIZE, SDL_GL_ACCUM_RED_SIZE, SDL_GL_ALPHA_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_BUFFER_SIZE, SDL_GL_CONTEXT_DEBUG_FLAG, SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_MAJOR_VERSION, SDL_GL_CONTEXT_MINOR_VERSION, SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_DEPTH_SIZE, SDL_GL_DOUBLEBUFFER, SDL_GL_GREEN_SIZE, SDL_GL_MULTISAMPLEBUFFERS, SDL_GL_MULTISAMPLESAMPLES, SDL_GL_RED_SIZE, SDL_GL_RETAINED_BACKING, SDL_GL_SetAttribute, SDL_GL_STENCIL_SIZE, SDL_GL_STEREO, SDL_INIT_AUDIO, SDL_INIT_VIDEO, SDL_Log, SDL_OpenAudio, SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_RGB24, SDL_PIXELFORMAT_RGB555, SDL_PIXELFORMAT_RGB565, SDL_PIXELFORMAT_RGB888, SDL_PixelFormatEnumToMasks, SDL_RenderSetLogicalSize, SDL_RenderSetScale, SDL_SetWindowDisplayMode, SDL_SetWindowHitTest, SDL_SetWindowIcon, SDL_SetWindowMaximumSize, SDL_SetWindowMinimumSize, SDL_ShowWindow, SDL_snprintf, SDL_snprintfcat(), SDL_strcasecmp, SDL_strlcpy, SDL_TRUE, SDL_VideoInit, SDL_WINDOW_BORDERLESS, SDL_WINDOW_OPENGL, SDL_WINDOW_RESIZABLE, SDL_WINDOW_VULKAN, SDL_zero, SDLTest_ExampleHitTestCallback(), SDLTest_LoadIcon(), SDLTest_PrintRenderer(), state, text, VERBOSE_AUDIO, VERBOSE_MODES, VERBOSE_RENDER, VERBOSE_VIDEO, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by main().

◆ SDLTest_CommonLogUsage()

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

Logs command line usage info.

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

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

Definition at line 489 of file SDL_test_common.c.

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

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

Referenced by main(), and SDLTest_CommonDefaultArgs().

◆ SDLTest_CommonQuit()

void SDLTest_CommonQuit ( SDLTest_CommonState state)

Close test window.

Parameters
stateThe common state used to create test window.

Definition at line 1832 of file SDL_test_common.c.

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

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

Referenced by main(), and quit().