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	CASE(X)   case SDL_ORIENTATION_##X: return #X
#define	AXIS_CASE(ax)   case SDL_CONTROLLER_AXIS_##ax: return #ax
#define	BUTTON_CASE(btn)   case SDL_CONTROLLER_BUTTON_##btn: return #btn

Functions
static void	SDL_snprintfcat (SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
SDLTest_CommonState *	SDLTest_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...
static const char *	BuildCommonUsageString (char **pstr, const char **strlist, const int numitems, const char **strlist2, const int numitems2)
const char *	SDLTest_CommonUsage (SDLTest_CommonState *state)
	Returns common usage information. 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...
static void	SDLTest_PrintRendererFlag (char *text, size_t maxlen, Uint32 flag)
static void	SDLTest_PrintPixelFormat (char *text, size_t maxlen, Uint32 format)
static void	SDLTest_PrintRenderer (SDL_RendererInfo *info)
static SDL_Surface *	SDLTest_LoadIcon (const char *file)
static SDL_HitTestResult	SDLTest_ExampleHitTestCallback (SDL_Window *win, const SDL_Point *area, void *data)
SDL_bool	SDLTest_CommonInit (SDLTest_CommonState *state)
	Open test window. More...
static const char *	DisplayOrientationName (int orientation)
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...

Variables
static const char *	video_usage []
static const char *	audio_usage []
static char *	common_usage_video = NULL
static char *	common_usage_audio = NULL
static char *	common_usage_videoaudio = NULL

Macro Definition Documentation

AXIS_CASE

#define AXIS_CASE

(

ax

)

case SDL_CONTROLLER_AXIS_##ax: return #ax

BUTTON_CASE

#define BUTTON_CASE

(

btn

)

case SDL_CONTROLLER_BUTTON_##btn: return #btn

CASE

#define CASE

(

X

)

case SDL_ORIENTATION_##X: return #X

Function Documentation

BuildCommonUsageString()

static const char* BuildCommonUsageString ( char **  pstr, const char **  strlist, const int  numitems, const char **  strlist2, const int  numitems2  )

static

Definition at line 525 of file SDL_test_common.c.

{
    char *str = *pstr;
    if (!str) {
        size_t len = SDL_strlen("[--trackmem]") + 2;
        int i;
        for (i = 0; i < numitems; i++) {
            len += SDL_strlen(strlist[i]) + 1;
        }
        if (strlist2) {
            for (i = 0; i < numitems2; i++) {
                len += SDL_strlen(strlist2[i]) + 1;
            }
        }
        str = (char *) SDL_calloc(1, len);
        if (!str) {
            return "";  /* oh well. */
        }
        SDL_strlcat(str, "[--trackmem] ", len);
        for (i = 0; i < numitems-1; i++) {
            SDL_strlcat(str, strlist[i], len);
            SDL_strlcat(str, " ", len);
        }
        SDL_strlcat(str, strlist[i], len);
        if (strlist2) {
            SDL_strlcat(str, " ", len);
            for (i = 0; i < numitems2-1; i++) {
                SDL_strlcat(str, strlist2[i], len);
                SDL_strlcat(str, " ", len);
            }
            SDL_strlcat(str, strlist2[i], len);
        }
        *pstr = str;
    }
    return str;
}

References i, SDL_calloc, SDL_strlcat, and SDL_strlen.

Referenced by SDLTest_CommonUsage().

ControllerAxisName()

static const char* ControllerAxisName ( const SDL_GameControllerAxis  axis )

static

Definition at line 1186 of file SDL_test_common.c.

{
    switch (axis)
    {
#define AXIS_CASE(ax) case SDL_CONTROLLER_AXIS_##ax: return #ax
        AXIS_CASE(INVALID);
        AXIS_CASE(LEFTX);
        AXIS_CASE(LEFTY);
        AXIS_CASE(RIGHTX);
        AXIS_CASE(RIGHTY);
        AXIS_CASE(TRIGGERLEFT);
        AXIS_CASE(TRIGGERRIGHT);
#undef AXIS_CASE
default: return "???";
    }
}

References axis, and AXIS_CASE.

Referenced by SDLTest_PrintEvent().

ControllerButtonName()

static const char* ControllerButtonName ( const SDL_GameControllerButton  button )

static

Definition at line 1204 of file SDL_test_common.c.

{
    switch (button)
    {
#define BUTTON_CASE(btn) case SDL_CONTROLLER_BUTTON_##btn: return #btn
        BUTTON_CASE(INVALID);
        BUTTON_CASE(A);
        BUTTON_CASE(B);
        BUTTON_CASE(X);
        BUTTON_CASE(Y);
        BUTTON_CASE(BACK);
        BUTTON_CASE(GUIDE);
        BUTTON_CASE(START);
        BUTTON_CASE(LEFTSTICK);
        BUTTON_CASE(RIGHTSTICK);
        BUTTON_CASE(LEFTSHOULDER);
        BUTTON_CASE(RIGHTSHOULDER);
        BUTTON_CASE(DPAD_UP);
        BUTTON_CASE(DPAD_DOWN);
        BUTTON_CASE(DPAD_LEFT);
        BUTTON_CASE(DPAD_RIGHT);
#undef BUTTON_CASE
default: return "???";
    }
}

References button, BUTTON_CASE, X, and Y.

Referenced by SDLTest_PrintEvent().

DisplayOrientationName()

static const char* DisplayOrientationName ( int  orientation )

static

Definition at line 1170 of file SDL_test_common.c.

{
    switch (orientation)
    {
#define CASE(X) case SDL_ORIENTATION_##X: return #X
        CASE(UNKNOWN);
        CASE(LANDSCAPE);
        CASE(LANDSCAPE_FLIPPED);
        CASE(PORTRAIT);
        CASE(PORTRAIT_FLIPPED);
#undef CASE
default: return "???";
    }
}

References CASE.

Referenced by SDLTest_PrintEvent().

FullscreenTo()

static void FullscreenTo ( int  index, int  windowId  )

static

Definition at line 1559 of file SDL_test_common.c.

{
    Uint32 flags;
    struct SDL_Rect rect = { 0, 0, 0, 0 };
    SDL_Window *window = SDL_GetWindowFromID(windowId);
    if (!window) {
        return;
    }
 
    SDL_GetDisplayBounds( index, &rect );
 
    flags = SDL_GetWindowFlags(window);
    if (flags & SDL_WINDOW_FULLSCREEN) {
        SDL_SetWindowFullscreen( window, SDL_FALSE );
        SDL_Delay( 15 );
    }
 
    SDL_SetWindowPosition( window, rect.x, rect.y );
    SDL_SetWindowFullscreen( window, SDL_TRUE );
}

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

Referenced by SDLTest_CommonEvent().

SDL_snprintfcat()

static void SDL_snprintfcat ( SDL_OUT_Z_CAP(maxlen) char *  text, size_t  maxlen, SDL_PRINTF_FORMAT_STRING const char *  fmt,   ...  )

static

Definition at line 46 of file SDL_test_common.c.

{
    size_t length = SDL_strlen(text);
    va_list ap;
 
    va_start(ap, fmt);
    text += length;
    maxlen -= length;
    SDL_vsnprintf(text, maxlen, fmt, ap);
    va_end(ap);
}

References SDL_strlen, SDL_vsnprintf, and text.

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

SDLTest_CommonArg()

int SDLTest_CommonArg	(	SDLTest_CommonState *	state,
		int	index
	)

Process one common argument.

Parameters

state	The common state describing the test window to create.
index	The 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.

{
    char **argv = state->argv;
 
    if (SDL_strcasecmp(argv[index], "--video") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->videodriver = argv[index];
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->renderdriver = argv[index];
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--gldebug") == 0) {
        state->gl_debug = 1;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--info") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        if (SDL_strcasecmp(argv[index], "all") == 0) {
            state->verbose |=
                (VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER |
                 VERBOSE_EVENT);
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "video") == 0) {
            state->verbose |= VERBOSE_VIDEO;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "modes") == 0) {
            state->verbose |= VERBOSE_MODES;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "render") == 0) {
            state->verbose |= VERBOSE_RENDER;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "event") == 0) {
            state->verbose |= VERBOSE_EVENT;
            return 2;
        }
        return -1;
    }
    if (SDL_strcasecmp(argv[index], "--log") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        if (SDL_strcasecmp(argv[index], "all") == 0) {
            SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE);
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "error") == 0) {
            SDL_LogSetPriority(SDL_LOG_CATEGORY_ERROR, SDL_LOG_PRIORITY_VERBOSE);
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "system") == 0) {
            SDL_LogSetPriority(SDL_LOG_CATEGORY_SYSTEM, SDL_LOG_PRIORITY_VERBOSE);
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "audio") == 0) {
            SDL_LogSetPriority(SDL_LOG_CATEGORY_AUDIO, SDL_LOG_PRIORITY_VERBOSE);
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "video") == 0) {
            SDL_LogSetPriority(SDL_LOG_CATEGORY_VIDEO, SDL_LOG_PRIORITY_VERBOSE);
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "render") == 0) {
            SDL_LogSetPriority(SDL_LOG_CATEGORY_RENDER, SDL_LOG_PRIORITY_VERBOSE);
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "input") == 0) {
            SDL_LogSetPriority(SDL_LOG_CATEGORY_INPUT, SDL_LOG_PRIORITY_VERBOSE);
            return 2;
        }
        return -1;
    }
    if (SDL_strcasecmp(argv[index], "--display") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->display = SDL_atoi(argv[index]);
        if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) {
            state->window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
            state->window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
        }
        if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) {
            state->window_x = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
            state->window_y = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
        }
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
        state->window_flags |= SDL_WINDOW_FULLSCREEN;
        state->num_windows = 1;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--fullscreen-desktop") == 0) {
        state->window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
        state->num_windows = 1;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--allow-highdpi") == 0) {
        state->window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--windows") == 0) {
        ++index;
        if (!argv[index] || !SDL_isdigit(*argv[index])) {
            return -1;
        }
        if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
            state->num_windows = SDL_atoi(argv[index]);
        }
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--title") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->window_title = argv[index];
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--icon") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->window_icon = argv[index];
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--center") == 0) {
        state->window_x = SDL_WINDOWPOS_CENTERED;
        state->window_y = SDL_WINDOWPOS_CENTERED;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--position") == 0) {
        char *x, *y;
        ++index;
        if (!argv[index]) {
            return -1;
        }
        x = argv[index];
        y = argv[index];
        while (*y && *y != ',') {
            ++y;
        }
        if (!*y) {
            return -1;
        }
        *y++ = '\0';
        state->window_x = SDL_atoi(x);
        state->window_y = SDL_atoi(y);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--usable-bounds") == 0) {
        /* !!! FIXME: this is a bit of a hack, but I don't want to add a
           !!! FIXME:  flag to the public structure in 2.0.x */
        state->window_x = -1;
        state->window_y = -1;
        state->window_w = -1;
        state->window_h = -1;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
        char *w, *h;
        ++index;
        if (!argv[index]) {
            return -1;
        }
        w = argv[index];
        h = argv[index];
        while (*h && *h != 'x') {
            ++h;
        }
        if (!*h) {
            return -1;
        }
        *h++ = '\0';
        state->window_w = SDL_atoi(w);
        state->window_h = SDL_atoi(h);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) {
        char *w, *h;
        ++index;
        if (!argv[index]) {
            return -1;
        }
        w = argv[index];
        h = argv[index];
        while (*h && *h != 'x') {
            ++h;
        }
        if (!*h) {
            return -1;
        }
        *h++ = '\0';
        state->window_minW = SDL_atoi(w);
        state->window_minH = SDL_atoi(h);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) {
        char *w, *h;
        ++index;
        if (!argv[index]) {
            return -1;
        }
        w = argv[index];
        h = argv[index];
        while (*h && *h != 'x') {
            ++h;
        }
        if (!*h) {
            return -1;
        }
        *h++ = '\0';
        state->window_maxW = SDL_atoi(w);
        state->window_maxH = SDL_atoi(h);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--logical") == 0) {
        char *w, *h;
        ++index;
        if (!argv[index]) {
            return -1;
        }
        w = argv[index];
        h = argv[index];
        while (*h && *h != 'x') {
            ++h;
        }
        if (!*h) {
            return -1;
        }
        *h++ = '\0';
        state->logical_w = SDL_atoi(w);
        state->logical_h = SDL_atoi(h);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--scale") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->scale = (float)SDL_atof(argv[index]);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--depth") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->depth = SDL_atoi(argv[index]);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->refresh_rate = SDL_atoi(argv[index]);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
        state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
        state->window_flags |= SDL_WINDOW_BORDERLESS;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--resize") == 0) {
        state->window_flags |= SDL_WINDOW_RESIZABLE;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
        state->window_flags |= SDL_WINDOW_MINIMIZED;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
        state->window_flags |= SDL_WINDOW_MAXIMIZED;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--grab") == 0) {
        state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
        return 1;
    }
    if (SDL_strcasecmp(argv[index], "--rate") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->audiospec.freq = SDL_atoi(argv[index]);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--format") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        if (SDL_strcasecmp(argv[index], "U8") == 0) {
            state->audiospec.format = AUDIO_U8;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "S8") == 0) {
            state->audiospec.format = AUDIO_S8;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "U16") == 0) {
            state->audiospec.format = AUDIO_U16;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
            state->audiospec.format = AUDIO_U16LSB;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
            state->audiospec.format = AUDIO_U16MSB;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "S16") == 0) {
            state->audiospec.format = AUDIO_S16;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
            state->audiospec.format = AUDIO_S16LSB;
            return 2;
        }
        if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
            state->audiospec.format = AUDIO_S16MSB;
            return 2;
        }
        return -1;
    }
    if (SDL_strcasecmp(argv[index], "--channels") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--samples") == 0) {
        ++index;
        if (!argv[index]) {
            return -1;
        }
        state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
        return 2;
    }
    if (SDL_strcasecmp(argv[index], "--trackmem") == 0) {
        /* Already handled in SDLTest_CommonCreateState() */
        return 1;
    }
    if ((SDL_strcasecmp(argv[index], "-h") == 0)
        || (SDL_strcasecmp(argv[index], "--help") == 0)) {
        /* Print the usage message */
        return -1;
    }
    if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) {
    /* Debug flag sent by Xcode */
        return 2;
    }
    return 0;
}

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

argv	Array of command line parameters
flags	Flags 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.

{
    int i;
    SDLTest_CommonState *state;
 
    /* Do this first so we catch all allocations */
    for (i = 1; argv[i]; ++i) {
        if (SDL_strcasecmp(argv[i], "--trackmem") == 0) {
            SDLTest_TrackAllocations();
            break;
        }
    }
 
    state = (SDLTest_CommonState *)SDL_calloc(1, sizeof(*state));
    if (!state) {
        SDL_OutOfMemory();
        return NULL;
    }
 
    /* Initialize some defaults */
    state->argv = argv;
    state->flags = flags;
    state->window_title = argv[0];
    state->window_flags = 0;
    state->window_x = SDL_WINDOWPOS_UNDEFINED;
    state->window_y = SDL_WINDOWPOS_UNDEFINED;
    state->window_w = DEFAULT_WINDOW_WIDTH;
    state->window_h = DEFAULT_WINDOW_HEIGHT;
    state->num_windows = 1;
    state->audiospec.freq = 22050;
    state->audiospec.format = AUDIO_S16;
    state->audiospec.channels = 2;
    state->audiospec.samples = 2048;
 
    /* Set some very sane GL defaults */
    state->gl_red_size = 3;
    state->gl_green_size = 3;
    state->gl_blue_size = 2;
    state->gl_alpha_size = 0;
    state->gl_buffer_size = 0;
    state->gl_depth_size = 16;
    state->gl_stencil_size = 0;
    state->gl_double_buffer = 1;
    state->gl_accum_red_size = 0;
    state->gl_accum_green_size = 0;
    state->gl_accum_blue_size = 0;
    state->gl_accum_alpha_size = 0;
    state->gl_stereo = 0;
    state->gl_multisamplebuffers = 0;
    state->gl_multisamplesamples = 0;
    state->gl_retained_backing = 1;
    state->gl_accelerated = -1;
    state->gl_debug = 0;
 
    return state;
}

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

state	The common state describing the test window to create.
argc	argc, as supplied to SDL_main
argv	argv, as supplied to SDL_main

Returns

False if app should quit, true otherwise.

Definition at line 584 of file SDL_test_common.c.

{
    int i = 1;
    while (i < argc) {
        const int consumed = SDLTest_CommonArg(state, i);
        if (consumed == 0) {
            SDLTest_CommonLogUsage(state, argv[0], NULL);
            return SDL_FALSE;
        }
        i += consumed;
    }
    return SDL_TRUE;
}

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

state	The common state used to create test window.
event	The event to handle.
done	Flag indicating we are done.

Definition at line 1581 of file SDL_test_common.c.

{
    int i;
    static SDL_MouseMotionEvent lastEvent;
 
    if (state->verbose & VERBOSE_EVENT) {
        SDLTest_PrintEvent(event);
    }
 
    switch (event->type) {
    case SDL_WINDOWEVENT:
        switch (event->window.event) {
        case SDL_WINDOWEVENT_CLOSE:
            {
                SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
                if (window) {
                    for (i = 0; i < state->num_windows; ++i) {
                        if (window == state->windows[i]) {
                            if (state->targets[i]) {
                                SDL_DestroyTexture(state->targets[i]);
                                state->targets[i] = NULL;
                            }
                            if (state->renderers[i]) {
                                SDL_DestroyRenderer(state->renderers[i]);
                                state->renderers[i] = NULL;
                            }
                            SDL_DestroyWindow(state->windows[i]);
                            state->windows[i] = NULL;
                            break;
                        }
                    }
                }
            }
            break;
        }
        break;
    case SDL_KEYDOWN: {
        SDL_bool withControl = !!(event->key.keysym.mod & KMOD_CTRL);
        SDL_bool withShift = !!(event->key.keysym.mod & KMOD_SHIFT);
        SDL_bool withAlt = !!(event->key.keysym.mod & KMOD_ALT);
 
        switch (event->key.keysym.sym) {
            /* Add hotkeys here */
        case SDLK_PRINTSCREEN: {
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    for (i = 0; i < state->num_windows; ++i) {
                        if (window == state->windows[i]) {
                            SDLTest_ScreenShot(state->renderers[i]);
                        }
                    }
                }
            }
            break;
        case SDLK_EQUALS:
            if (withControl) {
                /* Ctrl-+ double the size of the window */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    int w, h;
                    SDL_GetWindowSize(window, &w, &h);
                    SDL_SetWindowSize(window, w*2, h*2);
                }
            }
            break;
        case SDLK_MINUS:
            if (withControl) {
                /* Ctrl-- half the size of the window */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    int w, h;
                    SDL_GetWindowSize(window, &w, &h);
                    SDL_SetWindowSize(window, w/2, h/2);
                }
            }
            break;
        case SDLK_UP:
        case SDLK_DOWN:
        case SDLK_LEFT:
        case SDLK_RIGHT:
            if (withAlt) {
                /* Alt-Up/Down/Left/Right switches between displays */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    int currentIndex = SDL_GetWindowDisplayIndex(window);
                    int numDisplays = SDL_GetNumVideoDisplays();
 
                    if (currentIndex >= 0 && numDisplays >= 1) {
                        int dest;
                        if (event->key.keysym.sym == SDLK_UP || event->key.keysym.sym == SDLK_LEFT) {
                            dest = (currentIndex + numDisplays - 1) % numDisplays;
                        } else {
                            dest = (currentIndex + numDisplays + 1) % numDisplays;
                        }
                        SDL_Log("Centering on display %d\n", dest);
                        SDL_SetWindowPosition(window,
                            SDL_WINDOWPOS_CENTERED_DISPLAY(dest),
                            SDL_WINDOWPOS_CENTERED_DISPLAY(dest));
                    }
                }
            }
            if (withShift) {
                /* Shift-Up/Down/Left/Right shift the window by 100px */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    const int delta = 100;
                    int x, y;
                    SDL_GetWindowPosition(window, &x, &y);
                    
                    if (event->key.keysym.sym == SDLK_UP)    y -= delta;
                    if (event->key.keysym.sym == SDLK_DOWN)  y += delta;
                    if (event->key.keysym.sym == SDLK_LEFT)  x -= delta;
                    if (event->key.keysym.sym == SDLK_RIGHT) x += delta;
 
                    SDL_Log("Setting position to (%d, %d)\n", x, y);
                    SDL_SetWindowPosition(window, x, y);
                }
            }
            break;
        case SDLK_o:
            if (withControl) {
                /* Ctrl-O (or Ctrl-Shift-O) changes window opacity. */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    float opacity;
                    if (SDL_GetWindowOpacity(window, &opacity) == 0) {
                        if (withShift) {
                            opacity += 0.20f;
                        } else {
                            opacity -= 0.20f;
                        }
                        SDL_SetWindowOpacity(window, opacity);
                    }
                }
            }
            break;
 
        case SDLK_c:
            if (withControl) {
                /* Ctrl-C copy awesome text! */
                SDL_SetClipboardText("SDL rocks!\nYou know it!");
                printf("Copied text to clipboard\n");
            }
            if (withAlt) {
                /* Alt-C toggle a render clip rectangle */
                for (i = 0; i < state->num_windows; ++i) {
                    int w, h;
                    if (state->renderers[i]) {
                        SDL_Rect clip;
                        SDL_GetWindowSize(state->windows[i], &w, &h);
                        SDL_RenderGetClipRect(state->renderers[i], &clip);
                        if (SDL_RectEmpty(&clip)) {
                            clip.x = w/4;
                            clip.y = h/4;
                            clip.w = w/2;
                            clip.h = h/2;
                            SDL_RenderSetClipRect(state->renderers[i], &clip);
                        } else {
                            SDL_RenderSetClipRect(state->renderers[i], NULL);
                        }
                    }
                }
            }
            if (withShift) {
                SDL_Window *current_win = SDL_GetKeyboardFocus();
                if (current_win) {
                    const SDL_bool shouldCapture = (SDL_GetWindowFlags(current_win) & SDL_WINDOW_MOUSE_CAPTURE) == 0;
                    const int rc = SDL_CaptureMouse(shouldCapture);
                    SDL_Log("%sapturing mouse %s!\n", shouldCapture ? "C" : "Unc", (rc == 0) ? "succeeded" : "failed");
                }
            }
            break;
        case SDLK_v:
            if (withControl) {
                /* Ctrl-V paste awesome text! */
                char *text = SDL_GetClipboardText();
                if (*text) {
                    printf("Clipboard: %s\n", text);
                } else {
                    printf("Clipboard is empty\n");
                }
                SDL_free(text);
            }
            break;
        case SDLK_g:
            if (withControl) {
                /* Ctrl-G toggle grab */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
                }
            }
            break;
        case SDLK_m:
            if (withControl) {
                /* Ctrl-M maximize */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    Uint32 flags = SDL_GetWindowFlags(window);
                    if (flags & SDL_WINDOW_MAXIMIZED) {
                        SDL_RestoreWindow(window);
                    } else {
                        SDL_MaximizeWindow(window);
                    }
                }
            }
            break;
        case SDLK_r:
            if (withControl) {
                /* Ctrl-R toggle mouse relative mode */
                SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode() ? SDL_TRUE : SDL_FALSE);
            }
            break;
        case SDLK_z:
            if (withControl) {
                /* Ctrl-Z minimize */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    SDL_MinimizeWindow(window);
                }
            }
            break;
        case SDLK_RETURN:
            if (withControl) {
                /* Ctrl-Enter toggle fullscreen */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    Uint32 flags = SDL_GetWindowFlags(window);
                    if (flags & SDL_WINDOW_FULLSCREEN) {
                        SDL_SetWindowFullscreen(window, SDL_FALSE);
                    } else {
                        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
                    }
                }
            } else if (withAlt) {
                /* Alt-Enter toggle fullscreen desktop */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    Uint32 flags = SDL_GetWindowFlags(window);
                    if (flags & SDL_WINDOW_FULLSCREEN) {
                        SDL_SetWindowFullscreen(window, SDL_FALSE);
                    } else {
                        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
                    }
                }
            } else if (withShift) {
                /* Shift-Enter toggle fullscreen desktop / fullscreen */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    Uint32 flags = SDL_GetWindowFlags(window);
                    if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {
                        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
                    } else {
                        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
                    }
                }
            }
 
            break;
        case SDLK_b:
            if (withControl) {
                /* Ctrl-B toggle window border */
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                if (window) {
                    const Uint32 flags = SDL_GetWindowFlags(window);
                    const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
                    SDL_SetWindowBordered(window, b);
                }
            }
            break;
        case SDLK_a:
            if (withControl) {
                /* Ctrl-A reports absolute mouse position. */
                int x, y;
                const Uint32 mask = SDL_GetGlobalMouseState(&x, &y);
                SDL_Log("ABSOLUTE MOUSE: (%d, %d)%s%s%s%s%s\n", x, y,
                        (mask & SDL_BUTTON_LMASK) ? " [LBUTTON]" : "",
                        (mask & SDL_BUTTON_MMASK) ? " [MBUTTON]" : "",
                        (mask & SDL_BUTTON_RMASK) ? " [RBUTTON]" : "",
                        (mask & SDL_BUTTON_X1MASK) ? " [X2BUTTON]" : "",
                        (mask & SDL_BUTTON_X2MASK) ? " [X2BUTTON]" : "");
            }
            break;
        case SDLK_0:
            if (withControl) {
                SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
                SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
            }
            break;
        case SDLK_1:
            if (withControl) {
                FullscreenTo(0, event->key.windowID);
            }
            break;
        case SDLK_2:
            if (withControl) {
                FullscreenTo(1, event->key.windowID);
            }
            break;
        case SDLK_ESCAPE:
            *done = 1;
            break;
        case SDLK_SPACE:
        {
            char message[256];
            SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
 
            SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
            SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
            break;
        }
        default:
            break;
        }
        break;
    }
    case SDL_QUIT:
        *done = 1;
        break;
    case SDL_MOUSEMOTION:
        lastEvent = event->motion;
        break;
 
    case SDL_DROPFILE:
    case SDL_DROPTEXT:
        SDL_free(event->drop.file);
        break;
    }
}

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

state

The common state describing the test window to create.

Returns

True if initialization succeeded, false otherwise

Definition at line 835 of file SDL_test_common.c.

{
    int i, j, m, n, w, h;
    SDL_DisplayMode fullscreen_mode;
    char text[1024];
 
    if (state->flags & SDL_INIT_VIDEO) {
        if (state->verbose & VERBOSE_VIDEO) {
            n = SDL_GetNumVideoDrivers();
            if (n == 0) {
                SDL_Log("No built-in video drivers\n");
            } else {
                SDL_snprintf(text, sizeof(text), "Built-in video drivers:");
                for (i = 0; i < n; ++i) {
                    if (i > 0) {
                        SDL_snprintfcat(text, sizeof(text), ",");
                    }
                    SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetVideoDriver(i));
                }
                SDL_Log("%s\n", text);
            }
        }
        if (SDL_VideoInit(state->videodriver) < 0) {
            SDL_Log("Couldn't initialize video driver: %s\n",
                    SDL_GetError());
            return SDL_FALSE;
        }
        if (state->verbose & VERBOSE_VIDEO) {
            SDL_Log("Video driver: %s\n",
                    SDL_GetCurrentVideoDriver());
        }
 
        /* Upload GL settings */
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, state->gl_red_size);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, state->gl_green_size);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, state->gl_blue_size);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, state->gl_alpha_size);
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer);
        SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, state->gl_depth_size);
        SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size);
        SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size);
        SDL_GL_SetAttribute(SDL_GL_STEREO, state->gl_stereo);
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers);
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples);
        if (state->gl_accelerated >= 0) {
            SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL,
                                state->gl_accelerated);
        }
        SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing);
        if (state->gl_major_version) {
            SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, state->gl_major_version);
            SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, state->gl_minor_version);
        }
        if (state->gl_debug) {
            SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
        }
        if (state->gl_profile_mask) {
            SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, state->gl_profile_mask);
        }
 
        if (state->verbose & VERBOSE_MODES) {
            SDL_Rect bounds, usablebounds;
            float hdpi = 0;
            float vdpi = 0;
            SDL_DisplayMode mode;
            int bpp;
            Uint32 Rmask, Gmask, Bmask, Amask;
#if SDL_VIDEO_DRIVER_WINDOWS
            int adapterIndex = 0;
            int outputIndex = 0;
#endif
            n = SDL_GetNumVideoDisplays();
            SDL_Log("Number of displays: %d\n", n);
            for (i = 0; i < n; ++i) {
                SDL_Log("Display %d: %s\n", i, SDL_GetDisplayName(i));
 
                SDL_zero(bounds);
                SDL_GetDisplayBounds(i, &bounds);
 
                SDL_zero(usablebounds);
                SDL_GetDisplayUsableBounds(i, &usablebounds);
 
                SDL_GetDisplayDPI(i, NULL, &hdpi, &vdpi);
 
                SDL_Log("Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
                SDL_Log("Usable bounds: %dx%d at %d,%d\n", usablebounds.w, usablebounds.h, usablebounds.x, usablebounds.y);
                SDL_Log("DPI: %fx%f\n", hdpi, vdpi);
 
                SDL_GetDesktopDisplayMode(i, &mode);
                SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
                                           &Bmask, &Amask);
                SDL_Log("  Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
                        mode.w, mode.h, mode.refresh_rate, bpp,
                        SDL_GetPixelFormatName(mode.format));
                if (Rmask || Gmask || Bmask) {
                    SDL_Log("      Red Mask   = 0x%.8x\n", Rmask);
                    SDL_Log("      Green Mask = 0x%.8x\n", Gmask);
                    SDL_Log("      Blue Mask  = 0x%.8x\n", Bmask);
                    if (Amask)
                        SDL_Log("      Alpha Mask = 0x%.8x\n", Amask);
                }
 
                /* Print available fullscreen video modes */
                m = SDL_GetNumDisplayModes(i);
                if (m == 0) {
                    SDL_Log("No available fullscreen video modes\n");
                } else {
                    SDL_Log("  Fullscreen video modes:\n");
                    for (j = 0; j < m; ++j) {
                        SDL_GetDisplayMode(i, j, &mode);
                        SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
                                                   &Gmask, &Bmask, &Amask);
                        SDL_Log("    Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
                                j, mode.w, mode.h, mode.refresh_rate, bpp,
                                SDL_GetPixelFormatName(mode.format));
                        if (Rmask || Gmask || Bmask) {
                            SDL_Log("        Red Mask   = 0x%.8x\n",
                                    Rmask);
                            SDL_Log("        Green Mask = 0x%.8x\n",
                                    Gmask);
                            SDL_Log("        Blue Mask  = 0x%.8x\n",
                                    Bmask);
                            if (Amask)
                                SDL_Log("        Alpha Mask = 0x%.8x\n",
                                        Amask);
                        }
                    }
                }
 
#if SDL_VIDEO_DRIVER_WINDOWS
                /* Print the D3D9 adapter index */
                adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
                SDL_Log("D3D9 Adapter Index: %d", adapterIndex);
 
                /* Print the DXGI adapter and output indices */
                SDL_DXGIGetOutputInfo(i, &adapterIndex, &outputIndex);
                SDL_Log("DXGI Adapter Index: %d  Output Index: %d", adapterIndex, outputIndex);
#endif
            }
        }
 
        if (state->verbose & VERBOSE_RENDER) {
            SDL_RendererInfo info;
 
            n = SDL_GetNumRenderDrivers();
            if (n == 0) {
                SDL_Log("No built-in render drivers\n");
            } else {
                SDL_Log("Built-in render drivers:\n");
                for (i = 0; i < n; ++i) {
                    SDL_GetRenderDriverInfo(i, &info);
                    SDLTest_PrintRenderer(&info);
                }
            }
        }
 
        SDL_zero(fullscreen_mode);
        switch (state->depth) {
        case 8:
            fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
            break;
        case 15:
            fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
            break;
        case 16:
            fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
            break;
        case 24:
            fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
            break;
        default:
            fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
            break;
        }
        fullscreen_mode.refresh_rate = state->refresh_rate;
 
        state->windows =
            (SDL_Window **) SDL_calloc(state->num_windows,
                                        sizeof(*state->windows));
        state->renderers =
            (SDL_Renderer **) SDL_calloc(state->num_windows,
                                        sizeof(*state->renderers));
        state->targets =
            (SDL_Texture **) SDL_calloc(state->num_windows,
                                        sizeof(*state->targets));
        if (!state->windows || !state->renderers) {
            SDL_Log("Out of memory!\n");
            return SDL_FALSE;
        }
        for (i = 0; i < state->num_windows; ++i) {
            char title[1024];
            SDL_Rect r;
 
            r.x = state->window_x;
            r.y = state->window_y;
            r.w = state->window_w;
            r.h = state->window_h;
 
            /* !!! FIXME: hack to make --usable-bounds work for now. */
            if ((r.x == -1) && (r.y == -1) && (r.w == -1) && (r.h == -1)) {
                SDL_GetDisplayUsableBounds(state->display, &r);
            }
 
            if (state->num_windows > 1) {
                SDL_snprintf(title, SDL_arraysize(title), "%s %d",
                             state->window_title, i + 1);
            } else {
                SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
            }
            state->windows[i] =
                SDL_CreateWindow(title, r.x, r.y, r.w, r.h, state->window_flags);
            if (!state->windows[i]) {
                SDL_Log("Couldn't create window: %s\n",
                        SDL_GetError());
                return SDL_FALSE;
            }
            if (state->window_minW || state->window_minH) {
                SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
            }
            if (state->window_maxW || state->window_maxH) {
                SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
            }
            SDL_GetWindowSize(state->windows[i], &w, &h);
            if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
                (w != state->window_w || h != state->window_h)) {
                printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
                state->window_w = w;
                state->window_h = h;
            }
            if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
                SDL_Log("Can't set up fullscreen display mode: %s\n",
                        SDL_GetError());
                return SDL_FALSE;
            }
 
            /* Add resize/drag areas for windows that are borderless and resizable */
            if ((state->window_flags & (SDL_WINDOW_RESIZABLE|SDL_WINDOW_BORDERLESS)) ==
                (SDL_WINDOW_RESIZABLE|SDL_WINDOW_BORDERLESS)) {
                SDL_SetWindowHitTest(state->windows[i], SDLTest_ExampleHitTestCallback, NULL);
            }
 
            if (state->window_icon) {
                SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
                if (icon) {
                    SDL_SetWindowIcon(state->windows[i], icon);
                    SDL_FreeSurface(icon);
                }
            }
 
            SDL_ShowWindow(state->windows[i]);
 
            if (!state->skip_renderer
                && (state->renderdriver
                    || !(state->window_flags & (SDL_WINDOW_OPENGL | SDL_WINDOW_VULKAN)))) {
                m = -1;
                if (state->renderdriver) {
                    SDL_RendererInfo info;
                    n = SDL_GetNumRenderDrivers();
                    for (j = 0; j < n; ++j) {
                        SDL_GetRenderDriverInfo(j, &info);
                        if (SDL_strcasecmp(info.name, state->renderdriver) ==
                            0) {
                            m = j;
                            break;
                        }
                    }
                    if (m == -1) {
                        SDL_Log("Couldn't find render driver named %s",
                                state->renderdriver);
                        return SDL_FALSE;
                    }
                }
                state->renderers[i] = SDL_CreateRenderer(state->windows[i],
                                            m, state->render_flags);
                if (!state->renderers[i]) {
                    SDL_Log("Couldn't create renderer: %s\n",
                            SDL_GetError());
                    return SDL_FALSE;
                }
                if (state->logical_w && state->logical_h) {
                    SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
                } else if (state->scale != 0.) {
                    SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
                }
                if (state->verbose & VERBOSE_RENDER) {
                    SDL_RendererInfo info;
 
                    SDL_Log("Current renderer:\n");
                    SDL_GetRendererInfo(state->renderers[i], &info);
                    SDLTest_PrintRenderer(&info);
                }
            }
        }
    }
 
    if (state->flags & SDL_INIT_AUDIO) {
        if (state->verbose & VERBOSE_AUDIO) {
            n = SDL_GetNumAudioDrivers();
            if (n == 0) {
                SDL_Log("No built-in audio drivers\n");
            } else {
                SDL_snprintf(text, sizeof(text), "Built-in audio drivers:");
                for (i = 0; i < n; ++i) {
                    if (i > 0) {
                        SDL_snprintfcat(text, sizeof(text), ",");
                    }
                    SDL_snprintfcat(text, sizeof(text), " %s", SDL_GetAudioDriver(i));
                }
                SDL_Log("%s\n", text);
            }
        }
        if (SDL_AudioInit(state->audiodriver) < 0) {
            SDL_Log("Couldn't initialize audio driver: %s\n",
                    SDL_GetError());
            return SDL_FALSE;
        }
        if (state->verbose & VERBOSE_AUDIO) {
            SDL_Log("Audio driver: %s\n",
                    SDL_GetCurrentAudioDriver());
        }
 
        if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
            SDL_Log("Couldn't open audio: %s\n", SDL_GetError());
            return SDL_FALSE;
        }
    }
 
    return SDL_TRUE;
}

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

Referenced by main().

SDLTest_CommonLogUsage()

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

Logs command line usage info.

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

Parameters

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

Definition at line 498 of file SDL_test_common.c.

{
    int i;
 
    SDL_Log("USAGE: %s", argv0);
    SDL_Log("    %s", "[--trackmem]");
 
    if (state->flags & SDL_INIT_VIDEO) {
        for (i = 0; i < SDL_arraysize(video_usage); i++) {
            SDL_Log("    %s", video_usage[i]);
        }
    }
 
    if (state->flags & SDL_INIT_AUDIO) {
        for (i = 0; i < SDL_arraysize(audio_usage); i++) {
            SDL_Log("    %s", audio_usage[i]);
        }
    }
 
    if (options) {
        for (i = 0; options[i] != NULL; i++) {
            SDL_Log("    %s", options[i]);
        }
    }
}

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

state

The common state used to create test window.

Definition at line 1912 of file SDL_test_common.c.

{
    int i;
 
    SDL_free(common_usage_video);
    SDL_free(common_usage_audio);
    SDL_free(common_usage_videoaudio);
    common_usage_video = NULL;
    common_usage_audio = NULL;
    common_usage_videoaudio = NULL;
 
    SDL_free(state->windows);
    if (state->targets) {
        for (i = 0; i < state->num_windows; ++i) {
            if (state->targets[i]) {
                SDL_DestroyTexture(state->targets[i]);
            }
        }
        SDL_free(state->targets);
    }
    if (state->renderers) {
        for (i = 0; i < state->num_windows; ++i) {
            if (state->renderers[i]) {
                SDL_DestroyRenderer(state->renderers[i]);
            }
        }
        SDL_free(state->renderers);
    }
    if (state->flags & SDL_INIT_VIDEO) {
        SDL_VideoQuit();
    }
    if (state->flags & SDL_INIT_AUDIO) {
        SDL_AudioQuit();
    }
    SDL_free(state);
    SDL_Quit();
    SDLTest_LogAllocations();
}

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

Referenced by main(), and quit().

SDLTest_CommonUsage()

const char* SDLTest_CommonUsage

(

SDLTest_CommonState *

state

)

Returns common usage information.

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

Parameters

state

The common state describing the test window to create.

Returns

String with usage information

Definition at line 567 of file SDL_test_common.c.

{
 
    switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
        case SDL_INIT_VIDEO:
            return BuildCommonUsageString(&common_usage_video, video_usage, SDL_arraysize(video_usage), NULL, 0);
        case SDL_INIT_AUDIO:
            return BuildCommonUsageString(&common_usage_audio, audio_usage, SDL_arraysize(audio_usage), NULL, 0);
        case (SDL_INIT_VIDEO | SDL_INIT_AUDIO):
            return BuildCommonUsageString(&common_usage_videoaudio, video_usage, SDL_arraysize(video_usage), audio_usage, SDL_arraysize(audio_usage));
        default:
            return "[--trackmem]";
    }
}

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

SDLTest_ExampleHitTestCallback()

static SDL_HitTestResult SDLTest_ExampleHitTestCallback ( SDL_Window *  win, const SDL_Point *  area, void *  data  )

static

Definition at line 789 of file SDL_test_common.c.

{
    int w, h;
    const int RESIZE_BORDER = 8;
    const int DRAGGABLE_TITLE = 32;
 
    /*SDL_Log("Hit test point %d,%d\n", area->x, area->y);*/
 
    SDL_GetWindowSize(win, &w, &h);
 
    if (area->x < RESIZE_BORDER) {
        if (area->y < RESIZE_BORDER) {
            SDL_Log("SDL_HITTEST_RESIZE_TOPLEFT\n");
            return SDL_HITTEST_RESIZE_TOPLEFT;
        } else if (area->y >= (h-RESIZE_BORDER)) {
            SDL_Log("SDL_HITTEST_RESIZE_BOTTOMLEFT\n");
            return SDL_HITTEST_RESIZE_BOTTOMLEFT;
        } else {
            SDL_Log("SDL_HITTEST_RESIZE_LEFT\n");
            return SDL_HITTEST_RESIZE_LEFT;
        }
    } else if (area->x >= (w-RESIZE_BORDER)) {
        if (area->y < RESIZE_BORDER) {
            SDL_Log("SDL_HITTEST_RESIZE_TOPRIGHT\n");
            return SDL_HITTEST_RESIZE_TOPRIGHT;
        } else if (area->y >= (h-RESIZE_BORDER)) {
            SDL_Log("SDL_HITTEST_RESIZE_BOTTOMRIGHT\n");
            return SDL_HITTEST_RESIZE_BOTTOMRIGHT;
        } else {
            SDL_Log("SDL_HITTEST_RESIZE_RIGHT\n");
            return SDL_HITTEST_RESIZE_RIGHT;
        }
    } else if (area->y >= (h-RESIZE_BORDER)) {
        SDL_Log("SDL_HITTEST_RESIZE_BOTTOM\n");
        return SDL_HITTEST_RESIZE_BOTTOM;
    } else if (area->y < RESIZE_BORDER) {
        SDL_Log("SDL_HITTEST_RESIZE_TOP\n");
        return SDL_HITTEST_RESIZE_TOP;
    } else if (area->y < DRAGGABLE_TITLE) {
        SDL_Log("SDL_HITTEST_DRAGGABLE\n");
        return SDL_HITTEST_DRAGGABLE;
    }
    return SDL_HITTEST_NORMAL;
}

References RESIZE_BORDER, SDL_GetWindowSize, SDL_HITTEST_DRAGGABLE, SDL_HITTEST_NORMAL, SDL_HITTEST_RESIZE_BOTTOM, SDL_HITTEST_RESIZE_BOTTOMLEFT, SDL_HITTEST_RESIZE_BOTTOMRIGHT, SDL_HITTEST_RESIZE_LEFT, SDL_HITTEST_RESIZE_RIGHT, SDL_HITTEST_RESIZE_TOP, SDL_HITTEST_RESIZE_TOPLEFT, SDL_HITTEST_RESIZE_TOPRIGHT, SDL_Log, SDL_Point::x, and SDL_Point::y.

Referenced by SDLTest_CommonInit().

SDLTest_LoadIcon()

static SDL_Surface* SDLTest_LoadIcon ( const char *  file )

static

Definition at line 769 of file SDL_test_common.c.

{
    SDL_Surface *icon;
 
    /* Load the icon surface */
    icon = SDL_LoadBMP(file);
    if (icon == NULL) {
        SDL_Log("Couldn't load %s: %s\n", file, SDL_GetError());
        return (NULL);
    }
 
    if (icon->format->palette) {
        /* Set the colorkey */
        SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels));
    }
 
    return (icon);
}

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

Referenced by SDLTest_CommonInit().

SDLTest_PrintEvent()

static void SDLTest_PrintEvent ( SDL_Event *  event )

static

Definition at line 1231 of file SDL_test_common.c.

{
    if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) {
        /* Mouse and finger motion are really spammy */
        return;
    }
 
    switch (event->type) {
    case SDL_DISPLAYEVENT:
        switch (event->display.event) {
        case SDL_DISPLAYEVENT_ORIENTATION:
            SDL_Log("SDL EVENT: Display %d changed orientation to %s", event->display.display, DisplayOrientationName(event->display.data1));
            break;
        default:
            SDL_Log("SDL EVENT: Display %d got unknown event 0x%4.4x",
                    event->display.display, event->display.event);
            break;
        }
        break;
    case SDL_WINDOWEVENT:
        switch (event->window.event) {
        case SDL_WINDOWEVENT_SHOWN:
            SDL_Log("SDL EVENT: Window %d shown", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_HIDDEN:
            SDL_Log("SDL EVENT: Window %d hidden", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_EXPOSED:
            SDL_Log("SDL EVENT: Window %d exposed", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_MOVED:
            SDL_Log("SDL EVENT: Window %d moved to %d,%d",
                    event->window.windowID, event->window.data1,
                    event->window.data2);
            break;
        case SDL_WINDOWEVENT_RESIZED:
            SDL_Log("SDL EVENT: Window %d resized to %dx%d",
                    event->window.windowID, event->window.data1,
                    event->window.data2);
            break;
        case SDL_WINDOWEVENT_SIZE_CHANGED:
            SDL_Log("SDL EVENT: Window %d changed size to %dx%d",
                    event->window.windowID, event->window.data1,
                    event->window.data2);
            break;
        case SDL_WINDOWEVENT_MINIMIZED:
            SDL_Log("SDL EVENT: Window %d minimized", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_MAXIMIZED:
            SDL_Log("SDL EVENT: Window %d maximized", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_RESTORED:
            SDL_Log("SDL EVENT: Window %d restored", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_ENTER:
            SDL_Log("SDL EVENT: Mouse entered window %d",
                    event->window.windowID);
            break;
        case SDL_WINDOWEVENT_LEAVE:
            SDL_Log("SDL EVENT: Mouse left window %d", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_FOCUS_GAINED:
            SDL_Log("SDL EVENT: Window %d gained keyboard focus",
                    event->window.windowID);
            break;
        case SDL_WINDOWEVENT_FOCUS_LOST:
            SDL_Log("SDL EVENT: Window %d lost keyboard focus",
                    event->window.windowID);
            break;
        case SDL_WINDOWEVENT_CLOSE:
            SDL_Log("SDL EVENT: Window %d closed", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_TAKE_FOCUS:
            SDL_Log("SDL EVENT: Window %d take focus", event->window.windowID);
            break;
        case SDL_WINDOWEVENT_HIT_TEST:
            SDL_Log("SDL EVENT: Window %d hit test", event->window.windowID);
            break;
        default:
            SDL_Log("SDL EVENT: Window %d got unknown event 0x%4.4x",
                    event->window.windowID, event->window.event);
            break;
        }
        break;
    case SDL_KEYDOWN:
        SDL_Log("SDL EVENT: Keyboard: key pressed  in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
                event->key.windowID,
                event->key.keysym.scancode,
                SDL_GetScancodeName(event->key.keysym.scancode),
                event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
        break;
    case SDL_KEYUP:
        SDL_Log("SDL EVENT: Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
                event->key.windowID,
                event->key.keysym.scancode,
                SDL_GetScancodeName(event->key.keysym.scancode),
                event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
        break;
    case SDL_TEXTEDITING:
        SDL_Log("SDL EVENT: Keyboard: text editing \"%s\" in window %d",
                event->edit.text, event->edit.windowID);
        break;
    case SDL_TEXTINPUT:
        SDL_Log("SDL EVENT: Keyboard: text input \"%s\" in window %d",
                event->text.text, event->text.windowID);
        break;
    case SDL_KEYMAPCHANGED:
        SDL_Log("SDL EVENT: Keymap changed");
        break;
    case SDL_MOUSEMOTION:
        SDL_Log("SDL EVENT: Mouse: moved to %d,%d (%d,%d) in window %d",
                event->motion.x, event->motion.y,
                event->motion.xrel, event->motion.yrel,
                event->motion.windowID);
        break;
    case SDL_MOUSEBUTTONDOWN:
        SDL_Log("SDL EVENT: Mouse: button %d pressed at %d,%d with click count %d in window %d",
                event->button.button, event->button.x, event->button.y, event->button.clicks,
                event->button.windowID);
        break;
    case SDL_MOUSEBUTTONUP:
        SDL_Log("SDL EVENT: Mouse: button %d released at %d,%d with click count %d in window %d",
                event->button.button, event->button.x, event->button.y, event->button.clicks,
                event->button.windowID);
        break;
    case SDL_MOUSEWHEEL:
        SDL_Log("SDL EVENT: Mouse: wheel scrolled %d in x and %d in y (reversed: %d) in window %d",
                event->wheel.x, event->wheel.y, event->wheel.direction, event->wheel.windowID);
        break;
    case SDL_JOYDEVICEADDED:
        SDL_Log("SDL EVENT: Joystick index %d attached",
            event->jdevice.which);
        break;
    case SDL_JOYDEVICEREMOVED:
        SDL_Log("SDL EVENT: Joystick %d removed",
            event->jdevice.which);
        break;
    case SDL_JOYBALLMOTION:
        SDL_Log("SDL EVENT: Joystick %d: ball %d moved by %d,%d",
                event->jball.which, event->jball.ball, event->jball.xrel,
                event->jball.yrel);
        break;
    case SDL_JOYHATMOTION:
        {
            const char *position = "UNKNOWN";
            switch (event->jhat.value) {
            case SDL_HAT_CENTERED:
                position = "CENTER";
                break;
            case SDL_HAT_UP:
                position = "UP";
                break;
            case SDL_HAT_RIGHTUP:
                position = "RIGHTUP";
                break;
            case SDL_HAT_RIGHT:
                position = "RIGHT";
                break;
            case SDL_HAT_RIGHTDOWN:
                position = "RIGHTDOWN";
                break;
            case SDL_HAT_DOWN:
                position = "DOWN";
                break;
            case SDL_HAT_LEFTDOWN:
                position = "LEFTDOWN";
                break;
            case SDL_HAT_LEFT:
                position = "LEFT";
                break;
            case SDL_HAT_LEFTUP:
                position = "LEFTUP";
                break;
            }
            SDL_Log("SDL EVENT: Joystick %d: hat %d moved to %s", event->jhat.which,
                event->jhat.hat, position);
        }
        break;
    case SDL_JOYBUTTONDOWN:
        SDL_Log("SDL EVENT: Joystick %d: button %d pressed",
                event->jbutton.which, event->jbutton.button);
        break;
    case SDL_JOYBUTTONUP:
        SDL_Log("SDL EVENT: Joystick %d: button %d released",
                event->jbutton.which, event->jbutton.button);
        break;
    case SDL_CONTROLLERDEVICEADDED:
        SDL_Log("SDL EVENT: Controller index %d attached",
            event->cdevice.which);
        break;
    case SDL_CONTROLLERDEVICEREMOVED:
        SDL_Log("SDL EVENT: Controller %d removed",
            event->cdevice.which);
        break;
    case SDL_CONTROLLERAXISMOTION:
        SDL_Log("SDL EVENT: Controller %d axis %d ('%s') value: %d",
            event->caxis.which,
            event->caxis.axis,
            ControllerAxisName((SDL_GameControllerAxis)event->caxis.axis),
            event->caxis.value);
        break;
    case SDL_CONTROLLERBUTTONDOWN:
        SDL_Log("SDL EVENT: Controller %d button %d ('%s') down",
            event->cbutton.which, event->cbutton.button,
            ControllerButtonName((SDL_GameControllerButton)event->cbutton.button));
        break;
    case SDL_CONTROLLERBUTTONUP:
        SDL_Log("SDL EVENT: Controller %d button %d ('%s') up",
            event->cbutton.which, event->cbutton.button,
            ControllerButtonName((SDL_GameControllerButton)event->cbutton.button));
        break;
    case SDL_CLIPBOARDUPDATE:
        SDL_Log("SDL EVENT: Clipboard updated");
        break;
 
    case SDL_FINGERMOTION:
        SDL_Log("SDL EVENT: Finger: motion touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
                (long) event->tfinger.touchId,
                (long) event->tfinger.fingerId,
                event->tfinger.x, event->tfinger.y,
                event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
        break;
    case SDL_FINGERDOWN:
    case SDL_FINGERUP:
        SDL_Log("SDL EVENT: Finger: %s touch=%ld, finger=%ld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
                (event->type == SDL_FINGERDOWN) ? "down" : "up",
                (long) event->tfinger.touchId,
                (long) event->tfinger.fingerId,
                event->tfinger.x, event->tfinger.y,
                event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
        break;
    case SDL_DOLLARGESTURE:
        SDL_Log("SDL_EVENT: Dollar gesture detect: %ld", (long) event->dgesture.gestureId);
        break;
    case SDL_DOLLARRECORD:
        SDL_Log("SDL_EVENT: Dollar gesture record: %ld", (long) event->dgesture.gestureId);
        break;
    case SDL_MULTIGESTURE:
        SDL_Log("SDL_EVENT: Multi gesture fingers: %d", event->mgesture.numFingers);
        break;
 
    case SDL_RENDER_DEVICE_RESET:
        SDL_Log("SDL EVENT: render device reset");
        break;
    case SDL_RENDER_TARGETS_RESET:
        SDL_Log("SDL EVENT: render targets reset");
        break;
 
    case SDL_APP_TERMINATING:
        SDL_Log("SDL EVENT: App terminating");
        break;
    case SDL_APP_LOWMEMORY:
        SDL_Log("SDL EVENT: App running low on memory");
        break;
    case SDL_APP_WILLENTERBACKGROUND:
        SDL_Log("SDL EVENT: App will enter the background");
        break;
    case SDL_APP_DIDENTERBACKGROUND:
        SDL_Log("SDL EVENT: App entered the background");
        break;
    case SDL_APP_WILLENTERFOREGROUND:
        SDL_Log("SDL EVENT: App will enter the foreground");
        break;
    case SDL_APP_DIDENTERFOREGROUND:
        SDL_Log("SDL EVENT: App entered the foreground");
        break;
    case SDL_DROPBEGIN:
        SDL_Log("SDL EVENT: Drag and drop beginning");
        break;
    case SDL_DROPFILE:
        SDL_Log("SDL EVENT: Drag and drop file: '%s'", event->drop.file);
        break;
    case SDL_DROPTEXT:
        SDL_Log("SDL EVENT: Drag and drop text: '%s'", event->drop.file);
        break;
    case SDL_DROPCOMPLETE:
        SDL_Log("SDL EVENT: Drag and drop ending");
        break;
    case SDL_QUIT:
        SDL_Log("SDL EVENT: Quit requested");
        break;
    case SDL_USEREVENT:
        SDL_Log("SDL EVENT: User event %d", event->user.code);
        break;
    default:
        SDL_Log("Unknown event 0x%4.4x", event->type);
        break;
    }
}

References ControllerAxisName(), ControllerButtonName(), DisplayOrientationName(), SDL_APP_DIDENTERBACKGROUND, SDL_APP_DIDENTERFOREGROUND, SDL_APP_LOWMEMORY, SDL_APP_TERMINATING, SDL_APP_WILLENTERBACKGROUND, SDL_APP_WILLENTERFOREGROUND, SDL_CLIPBOARDUPDATE, SDL_CONTROLLERAXISMOTION, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, SDL_DISPLAYEVENT, SDL_DISPLAYEVENT_ORIENTATION, SDL_DOLLARGESTURE, SDL_DOLLARRECORD, SDL_DROPBEGIN, SDL_DROPCOMPLETE, SDL_DROPFILE, SDL_DROPTEXT, SDL_FINGERDOWN, SDL_FINGERMOTION, SDL_FINGERUP, SDL_GetKeyName, SDL_GetScancodeName, SDL_HAT_CENTERED, SDL_HAT_DOWN, SDL_HAT_LEFT, SDL_HAT_LEFTDOWN, SDL_HAT_LEFTUP, SDL_HAT_RIGHT, SDL_HAT_RIGHTDOWN, SDL_HAT_RIGHTUP, SDL_HAT_UP, SDL_JOYBALLMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED, SDL_JOYHATMOTION, SDL_KEYDOWN, SDL_KEYMAPCHANGED, SDL_KEYUP, SDL_Log, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEMOTION, SDL_MOUSEWHEEL, SDL_MULTIGESTURE, SDL_QUIT, SDL_RENDER_DEVICE_RESET, SDL_RENDER_TARGETS_RESET, SDL_TEXTEDITING, SDL_TEXTINPUT, SDL_USEREVENT, SDL_WINDOWEVENT, SDL_WINDOWEVENT_CLOSE, SDL_WINDOWEVENT_ENTER, SDL_WINDOWEVENT_EXPOSED, SDL_WINDOWEVENT_FOCUS_GAINED, SDL_WINDOWEVENT_FOCUS_LOST, SDL_WINDOWEVENT_HIDDEN, SDL_WINDOWEVENT_HIT_TEST, SDL_WINDOWEVENT_LEAVE, SDL_WINDOWEVENT_MAXIMIZED, SDL_WINDOWEVENT_MINIMIZED, SDL_WINDOWEVENT_MOVED, SDL_WINDOWEVENT_RESIZED, SDL_WINDOWEVENT_RESTORED, SDL_WINDOWEVENT_SHOWN, SDL_WINDOWEVENT_SIZE_CHANGED, and SDL_WINDOWEVENT_TAKE_FOCUS.

Referenced by SDLTest_CommonEvent().

SDLTest_PrintPixelFormat()

static void SDLTest_PrintPixelFormat ( char *  text, size_t  maxlen, Uint32  format  )

static

Definition at line 621 of file SDL_test_common.c.

{
    switch (format) {
    case SDL_PIXELFORMAT_UNKNOWN:
        SDL_snprintfcat(text, maxlen, "Unknown");
        break;
    case SDL_PIXELFORMAT_INDEX1LSB:
        SDL_snprintfcat(text, maxlen, "Index1LSB");
        break;
    case SDL_PIXELFORMAT_INDEX1MSB:
        SDL_snprintfcat(text, maxlen, "Index1MSB");
        break;
    case SDL_PIXELFORMAT_INDEX4LSB:
        SDL_snprintfcat(text, maxlen, "Index4LSB");
        break;
    case SDL_PIXELFORMAT_INDEX4MSB:
        SDL_snprintfcat(text, maxlen, "Index4MSB");
        break;
    case SDL_PIXELFORMAT_INDEX8:
        SDL_snprintfcat(text, maxlen, "Index8");
        break;
    case SDL_PIXELFORMAT_RGB332:
        SDL_snprintfcat(text, maxlen, "RGB332");
        break;
    case SDL_PIXELFORMAT_RGB444:
        SDL_snprintfcat(text, maxlen, "RGB444");
        break;
    case SDL_PIXELFORMAT_BGR444:
        SDL_snprintfcat(text, maxlen, "BGR444");
        break;
    case SDL_PIXELFORMAT_RGB555:
        SDL_snprintfcat(text, maxlen, "RGB555");
        break;
    case SDL_PIXELFORMAT_BGR555:
        SDL_snprintfcat(text, maxlen, "BGR555");
        break;
    case SDL_PIXELFORMAT_ARGB4444:
        SDL_snprintfcat(text, maxlen, "ARGB4444");
        break;
    case SDL_PIXELFORMAT_ABGR4444:
        SDL_snprintfcat(text, maxlen, "ABGR4444");
        break;
    case SDL_PIXELFORMAT_ARGB1555:
        SDL_snprintfcat(text, maxlen, "ARGB1555");
        break;
    case SDL_PIXELFORMAT_ABGR1555:
        SDL_snprintfcat(text, maxlen, "ABGR1555");
        break;
    case SDL_PIXELFORMAT_RGB565:
        SDL_snprintfcat(text, maxlen, "RGB565");
        break;
    case SDL_PIXELFORMAT_BGR565:
        SDL_snprintfcat(text, maxlen, "BGR565");
        break;
    case SDL_PIXELFORMAT_RGB24:
        SDL_snprintfcat(text, maxlen, "RGB24");
        break;
    case SDL_PIXELFORMAT_BGR24:
        SDL_snprintfcat(text, maxlen, "BGR24");
        break;
    case SDL_PIXELFORMAT_RGB888:
        SDL_snprintfcat(text, maxlen, "RGB888");
        break;
    case SDL_PIXELFORMAT_BGR888:
        SDL_snprintfcat(text, maxlen, "BGR888");
        break;
    case SDL_PIXELFORMAT_ARGB8888:
        SDL_snprintfcat(text, maxlen, "ARGB8888");
        break;
    case SDL_PIXELFORMAT_RGBA8888:
        SDL_snprintfcat(text, maxlen, "RGBA8888");
        break;
    case SDL_PIXELFORMAT_ABGR8888:
        SDL_snprintfcat(text, maxlen, "ABGR8888");
        break;
    case SDL_PIXELFORMAT_BGRA8888:
        SDL_snprintfcat(text, maxlen, "BGRA8888");
        break;
    case SDL_PIXELFORMAT_ARGB2101010:
        SDL_snprintfcat(text, maxlen, "ARGB2101010");
        break;
    case SDL_PIXELFORMAT_YV12:
        SDL_snprintfcat(text, maxlen, "YV12");
        break;
    case SDL_PIXELFORMAT_IYUV:
        SDL_snprintfcat(text, maxlen, "IYUV");
        break;
    case SDL_PIXELFORMAT_YUY2:
        SDL_snprintfcat(text, maxlen, "YUY2");
        break;
    case SDL_PIXELFORMAT_UYVY:
        SDL_snprintfcat(text, maxlen, "UYVY");
        break;
    case SDL_PIXELFORMAT_YVYU:
        SDL_snprintfcat(text, maxlen, "YVYU");
        break;
    case SDL_PIXELFORMAT_NV12:
        SDL_snprintfcat(text, maxlen, "NV12");
        break;
    case SDL_PIXELFORMAT_NV21:
        SDL_snprintfcat(text, maxlen, "NV21");
        break;
    default:
        SDL_snprintfcat(text, maxlen, "0x%8.8x", format);
        break;
    }
}

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_BGR444, SDL_PIXELFORMAT_BGR555, SDL_PIXELFORMAT_BGR565, SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_INDEX1LSB, SDL_PIXELFORMAT_INDEX1MSB, SDL_PIXELFORMAT_INDEX4LSB, SDL_PIXELFORMAT_INDEX4MSB, SDL_PIXELFORMAT_INDEX8, SDL_PIXELFORMAT_IYUV, SDL_PIXELFORMAT_NV12, SDL_PIXELFORMAT_NV21, SDL_PIXELFORMAT_RGB24, SDL_PIXELFORMAT_RGB332, SDL_PIXELFORMAT_RGB444, SDL_PIXELFORMAT_RGB555, SDL_PIXELFORMAT_RGB565, SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_UNKNOWN, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_YV12, SDL_PIXELFORMAT_YVYU, SDL_snprintfcat(), and text.

Referenced by SDLTest_PrintRenderer().

SDLTest_PrintRenderer()

static void SDLTest_PrintRenderer ( SDL_RendererInfo *  info )

static

Definition at line 730 of file SDL_test_common.c.

{
    int i, count;
    char text[1024];
 
    SDL_Log("  Renderer %s:\n", info->name);
 
    SDL_snprintf(text, sizeof(text), "    Flags: 0x%8.8X", info->flags);
    SDL_snprintfcat(text, sizeof(text), " (");
    count = 0;
    for (i = 0; i < sizeof(info->flags) * 8; ++i) {
        Uint32 flag = (1 << i);
        if (info->flags & flag) {
            if (count > 0) {
                SDL_snprintfcat(text, sizeof(text), " | ");
            }
            SDLTest_PrintRendererFlag(text, sizeof(text), flag);
            ++count;
        }
    }
    SDL_snprintfcat(text, sizeof(text), ")");
    SDL_Log("%s\n", text);
 
    SDL_snprintf(text, sizeof(text), "    Texture formats (%d): ", info->num_texture_formats);
    for (i = 0; i < (int) info->num_texture_formats; ++i) {
        if (i > 0) {
            SDL_snprintfcat(text, sizeof(text), ", ");
        }
        SDLTest_PrintPixelFormat(text, sizeof(text), info->texture_formats[i]);
    }
    SDL_Log("%s\n", text);
 
    if (info->max_texture_width || info->max_texture_height) {
        SDL_Log("    Max Texture Size: %dx%d\n",
                info->max_texture_width, info->max_texture_height);
    }
}

References SDL_RendererInfo::flags, i, int(), SDL_RendererInfo::max_texture_height, SDL_RendererInfo::max_texture_width, SDL_RendererInfo::name, SDL_RendererInfo::num_texture_formats, SDL_Log, SDL_snprintf, SDL_snprintfcat(), SDLTest_PrintPixelFormat(), SDLTest_PrintRendererFlag(), text, and SDL_RendererInfo::texture_formats.

Referenced by SDLTest_CommonInit().

SDLTest_PrintRendererFlag()

static void SDLTest_PrintRendererFlag ( char *  text, size_t  maxlen, Uint32  flag  )

static

Definition at line 599 of file SDL_test_common.c.

{
    switch (flag) {
    case SDL_RENDERER_SOFTWARE:
        SDL_snprintfcat(text, maxlen, "Software");
        break;
    case SDL_RENDERER_ACCELERATED:
        SDL_snprintfcat(text, maxlen, "Accelerated");
        break;
    case SDL_RENDERER_PRESENTVSYNC:
        SDL_snprintfcat(text, maxlen, "PresentVSync");
        break;
    case SDL_RENDERER_TARGETTEXTURE:
        SDL_snprintfcat(text, maxlen, "TargetTexturesSupported");
        break;
    default:
        SDL_snprintfcat(text, maxlen, "0x%8.8x", flag);
        break;
    }
}

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

Referenced by SDLTest_PrintRenderer().

SDLTest_ScreenShot()

static void SDLTest_ScreenShot ( SDL_Renderer *  renderer )

static

Definition at line 1522 of file SDL_test_common.c.

{
    SDL_Rect viewport;
    SDL_Surface *surface;
 
    if (!renderer) {
        return;
    }
 
    SDL_RenderGetViewport(renderer, &viewport);
    surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
                    0x00FF0000, 0x0000FF00, 0x000000FF,
#else
                    0x000000FF, 0x0000FF00, 0x00FF0000,
#endif
                    0x00000000);
    if (!surface) {
        SDL_Log("Couldn't create surface: %s\n", SDL_GetError());
        return;
    }
 
    if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
                             surface->pixels, surface->pitch) < 0) {
        SDL_Log("Couldn't read screen: %s\n", SDL_GetError());
        SDL_free(surface);
        return;
    }
 
    if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
        SDL_Log("Couldn't save screenshot.bmp: %s\n", SDL_GetError());
        SDL_free(surface);
        return;
    }
}

References endif, SDL_Rect::h, NULL, renderer, SDL_BYTEORDER, SDL_CreateRGBSurface, SDL_free, SDL_GetError, SDL_LIL_ENDIAN, SDL_Log, SDL_RenderGetViewport, SDL_RenderReadPixels, SDL_SaveBMP, viewport, and SDL_Rect::w.

Referenced by SDLTest_CommonEvent().

Variable Documentation

audio_usage

const char* audio_usage[]

static

Initial value:

= {
    "[--rate N]", "[--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE]",
    "[--channels N]", "[--samples N]"
}

Definition at line 41 of file SDL_test_common.c.

Referenced by SDLTest_CommonLogUsage(), and SDLTest_CommonUsage().

common_usage_audio

char* common_usage_audio = NULL

static

Definition at line 563 of file SDL_test_common.c.

Referenced by SDLTest_CommonQuit(), and SDLTest_CommonUsage().

common_usage_video

char* common_usage_video = NULL

static

Definition at line 562 of file SDL_test_common.c.

Referenced by SDLTest_CommonQuit(), and SDLTest_CommonUsage().

common_usage_videoaudio

char* common_usage_videoaudio = NULL

static

Definition at line 564 of file SDL_test_common.c.

Referenced by SDLTest_CommonQuit(), and SDLTest_CommonUsage().

video_usage

const char* video_usage[]

static

Initial value:

= {
    "[--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]", "[--usable-bounds]"
}

Definition at line 29 of file SDL_test_common.c.

Referenced by SDLTest_CommonLogUsage(), and SDLTest_CommonUsage().