src/test/SDL_test_common.c
author Gabriel Jacobo <gabomdq@gmail.com>
Thu, 10 Oct 2013 00:49:57 -0300
changeset 7796 75c80f36038e
parent 7787 e6f3e8fc96ea
child 7828 1451063c8ecd
permissions -rw-r--r--
Adds gl_profile_mask to test framework, uses it in testgles
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 
    22 /* Ported from original test\common.c file. */
    23 
    24 #include "SDL_config.h"
    25 #include "SDL_test.h"
    26 
    27 #include <stdio.h>
    28 
    29 #define VIDEO_USAGE \
    30 "[--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-hidpi]"
    31 
    32 #define AUDIO_USAGE \
    33 "[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]"
    34 
    35 SDLTest_CommonState *
    36 SDLTest_CommonCreateState(char **argv, Uint32 flags)
    37 {
    38     SDLTest_CommonState *state = (SDLTest_CommonState *)SDL_calloc(1, sizeof(*state));
    39     if (!state) {
    40         SDL_OutOfMemory();
    41         return NULL;
    42     }
    43 
    44     /* Initialize some defaults */
    45     state->argv = argv;
    46     state->flags = flags;
    47     state->window_title = argv[0];
    48     state->window_flags = 0;
    49     state->window_x = SDL_WINDOWPOS_UNDEFINED;
    50     state->window_y = SDL_WINDOWPOS_UNDEFINED;
    51     state->window_w = DEFAULT_WINDOW_WIDTH;
    52     state->window_h = DEFAULT_WINDOW_HEIGHT;
    53     state->num_windows = 1;
    54     state->audiospec.freq = 22050;
    55     state->audiospec.format = AUDIO_S16;
    56     state->audiospec.channels = 2;
    57     state->audiospec.samples = 2048;
    58 
    59     /* Set some very sane GL defaults */
    60     state->gl_red_size = 3;
    61     state->gl_green_size = 3;
    62     state->gl_blue_size = 2;
    63     state->gl_alpha_size = 0;
    64     state->gl_buffer_size = 0;
    65     state->gl_depth_size = 16;
    66     state->gl_stencil_size = 0;
    67     state->gl_double_buffer = 1;
    68     state->gl_accum_red_size = 0;
    69     state->gl_accum_green_size = 0;
    70     state->gl_accum_blue_size = 0;
    71     state->gl_accum_alpha_size = 0;
    72     state->gl_stereo = 0;
    73     state->gl_multisamplebuffers = 0;
    74     state->gl_multisamplesamples = 0;
    75     state->gl_retained_backing = 1;
    76     state->gl_accelerated = -1;
    77     state->gl_debug = 0;
    78 
    79     return state;
    80 }
    81 
    82 int
    83 SDLTest_CommonArg(SDLTest_CommonState * state, int index)
    84 {
    85     char **argv = state->argv;
    86 
    87     if (SDL_strcasecmp(argv[index], "--video") == 0) {
    88         ++index;
    89         if (!argv[index]) {
    90             return -1;
    91         }
    92         state->videodriver = argv[index];
    93         return 2;
    94     }
    95     if (SDL_strcasecmp(argv[index], "--renderer") == 0) {
    96         ++index;
    97         if (!argv[index]) {
    98             return -1;
    99         }
   100         state->renderdriver = argv[index];
   101         return 2;
   102     }
   103     if (SDL_strcasecmp(argv[index], "--gldebug") == 0) {
   104         state->gl_debug = 1;
   105         return 1;
   106     }
   107     if (SDL_strcasecmp(argv[index], "--info") == 0) {
   108         ++index;
   109         if (!argv[index]) {
   110             return -1;
   111         }
   112         if (SDL_strcasecmp(argv[index], "all") == 0) {
   113             state->verbose |=
   114                 (VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER |
   115                  VERBOSE_EVENT);
   116             return 2;
   117         }
   118         if (SDL_strcasecmp(argv[index], "video") == 0) {
   119             state->verbose |= VERBOSE_VIDEO;
   120             return 2;
   121         }
   122         if (SDL_strcasecmp(argv[index], "modes") == 0) {
   123             state->verbose |= VERBOSE_MODES;
   124             return 2;
   125         }
   126         if (SDL_strcasecmp(argv[index], "render") == 0) {
   127             state->verbose |= VERBOSE_RENDER;
   128             return 2;
   129         }
   130         if (SDL_strcasecmp(argv[index], "event") == 0) {
   131             state->verbose |= VERBOSE_EVENT;
   132             return 2;
   133         }
   134         return -1;
   135     }
   136     if (SDL_strcasecmp(argv[index], "--log") == 0) {
   137         ++index;
   138         if (!argv[index]) {
   139             return -1;
   140         }
   141         if (SDL_strcasecmp(argv[index], "all") == 0) {
   142             SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE);
   143             return 2;
   144         }
   145         if (SDL_strcasecmp(argv[index], "error") == 0) {
   146             SDL_LogSetPriority(SDL_LOG_CATEGORY_ERROR, SDL_LOG_PRIORITY_VERBOSE);
   147             return 2;
   148         }
   149         if (SDL_strcasecmp(argv[index], "system") == 0) {
   150             SDL_LogSetPriority(SDL_LOG_CATEGORY_SYSTEM, SDL_LOG_PRIORITY_VERBOSE);
   151             return 2;
   152         }
   153         if (SDL_strcasecmp(argv[index], "audio") == 0) {
   154             SDL_LogSetPriority(SDL_LOG_CATEGORY_AUDIO, SDL_LOG_PRIORITY_VERBOSE);
   155             return 2;
   156         }
   157         if (SDL_strcasecmp(argv[index], "video") == 0) {
   158             SDL_LogSetPriority(SDL_LOG_CATEGORY_VIDEO, SDL_LOG_PRIORITY_VERBOSE);
   159             return 2;
   160         }
   161         if (SDL_strcasecmp(argv[index], "render") == 0) {
   162             SDL_LogSetPriority(SDL_LOG_CATEGORY_RENDER, SDL_LOG_PRIORITY_VERBOSE);
   163             return 2;
   164         }
   165         if (SDL_strcasecmp(argv[index], "input") == 0) {
   166             SDL_LogSetPriority(SDL_LOG_CATEGORY_INPUT, SDL_LOG_PRIORITY_VERBOSE);
   167             return 2;
   168         }
   169         return -1;
   170     }
   171     if (SDL_strcasecmp(argv[index], "--display") == 0) {
   172         ++index;
   173         if (!argv[index]) {
   174             return -1;
   175         }
   176         state->display = SDL_atoi(argv[index]);
   177         if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) {
   178             state->window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
   179             state->window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display);
   180         }
   181         if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) {
   182             state->window_x = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
   183             state->window_y = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display);
   184         }
   185         return 2;
   186     }
   187     if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) {
   188         state->window_flags |= SDL_WINDOW_FULLSCREEN;
   189         state->num_windows = 1;
   190         return 1;
   191     }
   192     if (SDL_strcasecmp(argv[index], "--fullscreen-desktop") == 0) {
   193         state->window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
   194         state->num_windows = 1;
   195         return 1;
   196     }
   197     if (SDL_strcasecmp(argv[index], "--allow-highdpi") == 0) {
   198         state->window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
   199         return 1;
   200     }
   201     if (SDL_strcasecmp(argv[index], "--windows") == 0) {
   202         ++index;
   203         if (!argv[index] || !SDL_isdigit(*argv[index])) {
   204             return -1;
   205         }
   206         if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) {
   207             state->num_windows = SDL_atoi(argv[index]);
   208         }
   209         return 2;
   210     }
   211     if (SDL_strcasecmp(argv[index], "--title") == 0) {
   212         ++index;
   213         if (!argv[index]) {
   214             return -1;
   215         }
   216         state->window_title = argv[index];
   217         return 2;
   218     }
   219     if (SDL_strcasecmp(argv[index], "--icon") == 0) {
   220         ++index;
   221         if (!argv[index]) {
   222             return -1;
   223         }
   224         state->window_icon = argv[index];
   225         return 2;
   226     }
   227     if (SDL_strcasecmp(argv[index], "--center") == 0) {
   228         state->window_x = SDL_WINDOWPOS_CENTERED;
   229         state->window_y = SDL_WINDOWPOS_CENTERED;
   230         return 1;
   231     }
   232     if (SDL_strcasecmp(argv[index], "--position") == 0) {
   233         char *x, *y;
   234         ++index;
   235         if (!argv[index]) {
   236             return -1;
   237         }
   238         x = argv[index];
   239         y = argv[index];
   240         while (*y && *y != ',') {
   241             ++y;
   242         }
   243         if (!*y) {
   244             return -1;
   245         }
   246         *y++ = '\0';
   247         state->window_x = SDL_atoi(x);
   248         state->window_y = SDL_atoi(y);
   249         return 2;
   250     }
   251     if (SDL_strcasecmp(argv[index], "--geometry") == 0) {
   252         char *w, *h;
   253         ++index;
   254         if (!argv[index]) {
   255             return -1;
   256         }
   257         w = argv[index];
   258         h = argv[index];
   259         while (*h && *h != 'x') {
   260             ++h;
   261         }
   262         if (!*h) {
   263             return -1;
   264         }
   265         *h++ = '\0';
   266         state->window_w = SDL_atoi(w);
   267         state->window_h = SDL_atoi(h);
   268         return 2;
   269     }
   270     if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) {
   271         char *w, *h;
   272         ++index;
   273         if (!argv[index]) {
   274             return -1;
   275         }
   276         w = argv[index];
   277         h = argv[index];
   278         while (*h && *h != 'x') {
   279             ++h;
   280         }
   281         if (!*h) {
   282             return -1;
   283         }
   284         *h++ = '\0';
   285         state->window_minW = SDL_atoi(w);
   286         state->window_minH = SDL_atoi(h);
   287         return 2;
   288     }
   289     if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) {
   290         char *w, *h;
   291         ++index;
   292         if (!argv[index]) {
   293             return -1;
   294         }
   295         w = argv[index];
   296         h = argv[index];
   297         while (*h && *h != 'x') {
   298             ++h;
   299         }
   300         if (!*h) {
   301             return -1;
   302         }
   303         *h++ = '\0';
   304         state->window_maxW = SDL_atoi(w);
   305         state->window_maxH = SDL_atoi(h);
   306         return 2;
   307     }
   308     if (SDL_strcasecmp(argv[index], "--logical") == 0) {
   309         char *w, *h;
   310         ++index;
   311         if (!argv[index]) {
   312             return -1;
   313         }
   314         w = argv[index];
   315         h = argv[index];
   316         while (*h && *h != 'x') {
   317             ++h;
   318         }
   319         if (!*h) {
   320             return -1;
   321         }
   322         *h++ = '\0';
   323         state->logical_w = SDL_atoi(w);
   324         state->logical_h = SDL_atoi(h);
   325         return 2;
   326     }
   327     if (SDL_strcasecmp(argv[index], "--scale") == 0) {
   328         ++index;
   329         if (!argv[index]) {
   330             return -1;
   331         }
   332         state->scale = (float)SDL_atof(argv[index]);
   333         return 2;
   334     }
   335     if (SDL_strcasecmp(argv[index], "--depth") == 0) {
   336         ++index;
   337         if (!argv[index]) {
   338             return -1;
   339         }
   340         state->depth = SDL_atoi(argv[index]);
   341         return 2;
   342     }
   343     if (SDL_strcasecmp(argv[index], "--refresh") == 0) {
   344         ++index;
   345         if (!argv[index]) {
   346             return -1;
   347         }
   348         state->refresh_rate = SDL_atoi(argv[index]);
   349         return 2;
   350     }
   351     if (SDL_strcasecmp(argv[index], "--vsync") == 0) {
   352         state->render_flags |= SDL_RENDERER_PRESENTVSYNC;
   353         return 1;
   354     }
   355     if (SDL_strcasecmp(argv[index], "--noframe") == 0) {
   356         state->window_flags |= SDL_WINDOW_BORDERLESS;
   357         return 1;
   358     }
   359     if (SDL_strcasecmp(argv[index], "--resize") == 0) {
   360         state->window_flags |= SDL_WINDOW_RESIZABLE;
   361         return 1;
   362     }
   363     if (SDL_strcasecmp(argv[index], "--minimize") == 0) {
   364         state->window_flags |= SDL_WINDOW_MINIMIZED;
   365         return 1;
   366     }
   367     if (SDL_strcasecmp(argv[index], "--maximize") == 0) {
   368         state->window_flags |= SDL_WINDOW_MAXIMIZED;
   369         return 1;
   370     }
   371     if (SDL_strcasecmp(argv[index], "--grab") == 0) {
   372         state->window_flags |= SDL_WINDOW_INPUT_GRABBED;
   373         return 1;
   374     }
   375     if (SDL_strcasecmp(argv[index], "--rate") == 0) {
   376         ++index;
   377         if (!argv[index]) {
   378             return -1;
   379         }
   380         state->audiospec.freq = SDL_atoi(argv[index]);
   381         return 2;
   382     }
   383     if (SDL_strcasecmp(argv[index], "--format") == 0) {
   384         ++index;
   385         if (!argv[index]) {
   386             return -1;
   387         }
   388         if (SDL_strcasecmp(argv[index], "U8") == 0) {
   389             state->audiospec.format = AUDIO_U8;
   390             return 2;
   391         }
   392         if (SDL_strcasecmp(argv[index], "S8") == 0) {
   393             state->audiospec.format = AUDIO_S8;
   394             return 2;
   395         }
   396         if (SDL_strcasecmp(argv[index], "U16") == 0) {
   397             state->audiospec.format = AUDIO_U16;
   398             return 2;
   399         }
   400         if (SDL_strcasecmp(argv[index], "U16LE") == 0) {
   401             state->audiospec.format = AUDIO_U16LSB;
   402             return 2;
   403         }
   404         if (SDL_strcasecmp(argv[index], "U16BE") == 0) {
   405             state->audiospec.format = AUDIO_U16MSB;
   406             return 2;
   407         }
   408         if (SDL_strcasecmp(argv[index], "S16") == 0) {
   409             state->audiospec.format = AUDIO_S16;
   410             return 2;
   411         }
   412         if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
   413             state->audiospec.format = AUDIO_S16LSB;
   414             return 2;
   415         }
   416         if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
   417             state->audiospec.format = AUDIO_S16MSB;
   418             return 2;
   419         }
   420         return -1;
   421     }
   422     if (SDL_strcasecmp(argv[index], "--channels") == 0) {
   423         ++index;
   424         if (!argv[index]) {
   425             return -1;
   426         }
   427         state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
   428         return 2;
   429     }
   430     if (SDL_strcasecmp(argv[index], "--samples") == 0) {
   431         ++index;
   432         if (!argv[index]) {
   433             return -1;
   434         }
   435         state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
   436         return 2;
   437     }
   438     if ((SDL_strcasecmp(argv[index], "-h") == 0)
   439         || (SDL_strcasecmp(argv[index], "--help") == 0)) {
   440         /* Print the usage message */
   441         return -1;
   442     }
   443     if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) {
   444     /* Debug flag sent by Xcode */
   445         return 2;
   446     }
   447     return 0;
   448 }
   449 
   450 const char *
   451 SDLTest_CommonUsage(SDLTest_CommonState * state)
   452 {
   453     switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
   454     case SDL_INIT_VIDEO:
   455         return VIDEO_USAGE;
   456     case SDL_INIT_AUDIO:
   457         return AUDIO_USAGE;
   458     case (SDL_INIT_VIDEO | SDL_INIT_AUDIO):
   459         return VIDEO_USAGE " " AUDIO_USAGE;
   460     default:
   461         return "";
   462     }
   463 }
   464 
   465 static void
   466 SDLTest_PrintRendererFlag(Uint32 flag)
   467 {
   468     switch (flag) {
   469     case SDL_RENDERER_PRESENTVSYNC:
   470         fprintf(stderr, "PresentVSync");
   471         break;
   472     case SDL_RENDERER_ACCELERATED:
   473         fprintf(stderr, "Accelerated");
   474         break;
   475     default:
   476         fprintf(stderr, "0x%8.8x", flag);
   477         break;
   478     }
   479 }
   480 
   481 static void
   482 SDLTest_PrintPixelFormat(Uint32 format)
   483 {
   484     switch (format) {
   485     case SDL_PIXELFORMAT_UNKNOWN:
   486         fprintf(stderr, "Unknwon");
   487         break;
   488     case SDL_PIXELFORMAT_INDEX1LSB:
   489         fprintf(stderr, "Index1LSB");
   490         break;
   491     case SDL_PIXELFORMAT_INDEX1MSB:
   492         fprintf(stderr, "Index1MSB");
   493         break;
   494     case SDL_PIXELFORMAT_INDEX4LSB:
   495         fprintf(stderr, "Index4LSB");
   496         break;
   497     case SDL_PIXELFORMAT_INDEX4MSB:
   498         fprintf(stderr, "Index4MSB");
   499         break;
   500     case SDL_PIXELFORMAT_INDEX8:
   501         fprintf(stderr, "Index8");
   502         break;
   503     case SDL_PIXELFORMAT_RGB332:
   504         fprintf(stderr, "RGB332");
   505         break;
   506     case SDL_PIXELFORMAT_RGB444:
   507         fprintf(stderr, "RGB444");
   508         break;
   509     case SDL_PIXELFORMAT_RGB555:
   510         fprintf(stderr, "RGB555");
   511         break;
   512     case SDL_PIXELFORMAT_BGR555:
   513         fprintf(stderr, "BGR555");
   514         break;
   515     case SDL_PIXELFORMAT_ARGB4444:
   516         fprintf(stderr, "ARGB4444");
   517         break;
   518     case SDL_PIXELFORMAT_ABGR4444:
   519         fprintf(stderr, "ABGR4444");
   520         break;
   521     case SDL_PIXELFORMAT_ARGB1555:
   522         fprintf(stderr, "ARGB1555");
   523         break;
   524     case SDL_PIXELFORMAT_ABGR1555:
   525         fprintf(stderr, "ABGR1555");
   526         break;
   527     case SDL_PIXELFORMAT_RGB565:
   528         fprintf(stderr, "RGB565");
   529         break;
   530     case SDL_PIXELFORMAT_BGR565:
   531         fprintf(stderr, "BGR565");
   532         break;
   533     case SDL_PIXELFORMAT_RGB24:
   534         fprintf(stderr, "RGB24");
   535         break;
   536     case SDL_PIXELFORMAT_BGR24:
   537         fprintf(stderr, "BGR24");
   538         break;
   539     case SDL_PIXELFORMAT_RGB888:
   540         fprintf(stderr, "RGB888");
   541         break;
   542     case SDL_PIXELFORMAT_BGR888:
   543         fprintf(stderr, "BGR888");
   544         break;
   545     case SDL_PIXELFORMAT_ARGB8888:
   546         fprintf(stderr, "ARGB8888");
   547         break;
   548     case SDL_PIXELFORMAT_RGBA8888:
   549         fprintf(stderr, "RGBA8888");
   550         break;
   551     case SDL_PIXELFORMAT_ABGR8888:
   552         fprintf(stderr, "ABGR8888");
   553         break;
   554     case SDL_PIXELFORMAT_BGRA8888:
   555         fprintf(stderr, "BGRA8888");
   556         break;
   557     case SDL_PIXELFORMAT_ARGB2101010:
   558         fprintf(stderr, "ARGB2101010");
   559         break;
   560     case SDL_PIXELFORMAT_YV12:
   561         fprintf(stderr, "YV12");
   562         break;
   563     case SDL_PIXELFORMAT_IYUV:
   564         fprintf(stderr, "IYUV");
   565         break;
   566     case SDL_PIXELFORMAT_YUY2:
   567         fprintf(stderr, "YUY2");
   568         break;
   569     case SDL_PIXELFORMAT_UYVY:
   570         fprintf(stderr, "UYVY");
   571         break;
   572     case SDL_PIXELFORMAT_YVYU:
   573         fprintf(stderr, "YVYU");
   574         break;
   575     default:
   576         fprintf(stderr, "0x%8.8x", format);
   577         break;
   578     }
   579 }
   580 
   581 static void
   582 SDLTest_PrintRenderer(SDL_RendererInfo * info)
   583 {
   584     int i, count;
   585 
   586     fprintf(stderr, "  Renderer %s:\n", info->name);
   587 
   588     fprintf(stderr, "    Flags: 0x%8.8X", info->flags);
   589     fprintf(stderr, " (");
   590     count = 0;
   591     for (i = 0; i < sizeof(info->flags) * 8; ++i) {
   592         Uint32 flag = (1 << i);
   593         if (info->flags & flag) {
   594             if (count > 0) {
   595                 fprintf(stderr, " | ");
   596             }
   597             SDLTest_PrintRendererFlag(flag);
   598             ++count;
   599         }
   600     }
   601     fprintf(stderr, ")\n");
   602 
   603     fprintf(stderr, "    Texture formats (%d): ", info->num_texture_formats);
   604     for (i = 0; i < (int) info->num_texture_formats; ++i) {
   605         if (i > 0) {
   606             fprintf(stderr, ", ");
   607         }
   608         SDLTest_PrintPixelFormat(info->texture_formats[i]);
   609     }
   610     fprintf(stderr, "\n");
   611 
   612     if (info->max_texture_width || info->max_texture_height) {
   613         fprintf(stderr, "    Max Texture Size: %dx%d\n",
   614                 info->max_texture_width, info->max_texture_height);
   615     }
   616 }
   617 
   618 static SDL_Surface *
   619 SDLTest_LoadIcon(const char *file)
   620 {
   621     SDL_Surface *icon;
   622 
   623     /* Load the icon surface */
   624     icon = SDL_LoadBMP(file);
   625     if (icon == NULL) {
   626         fprintf(stderr, "Couldn't load %s: %s\n", file, SDL_GetError());
   627         return (NULL);
   628     }
   629 
   630     if (icon->format->palette) {
   631         /* Set the colorkey */
   632         SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels));
   633     }
   634 
   635     return (icon);
   636 }
   637 
   638 SDL_bool
   639 SDLTest_CommonInit(SDLTest_CommonState * state)
   640 {
   641     int i, j, m, n, w, h;
   642     SDL_DisplayMode fullscreen_mode;
   643 
   644     if (state->flags & SDL_INIT_VIDEO) {
   645         if (state->verbose & VERBOSE_VIDEO) {
   646             n = SDL_GetNumVideoDrivers();
   647             if (n == 0) {
   648                 fprintf(stderr, "No built-in video drivers\n");
   649             } else {
   650                 fprintf(stderr, "Built-in video drivers:");
   651                 for (i = 0; i < n; ++i) {
   652                     if (i > 0) {
   653                         fprintf(stderr, ",");
   654                     }
   655                     fprintf(stderr, " %s", SDL_GetVideoDriver(i));
   656                 }
   657                 fprintf(stderr, "\n");
   658             }
   659         }
   660         if (SDL_VideoInit(state->videodriver) < 0) {
   661             fprintf(stderr, "Couldn't initialize video driver: %s\n",
   662                     SDL_GetError());
   663             return SDL_FALSE;
   664         }
   665         if (state->verbose & VERBOSE_VIDEO) {
   666             fprintf(stderr, "Video driver: %s\n",
   667                     SDL_GetCurrentVideoDriver());
   668         }
   669 
   670         /* Upload GL settings */
   671         SDL_GL_SetAttribute(SDL_GL_RED_SIZE, state->gl_red_size);
   672         SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, state->gl_green_size);
   673         SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, state->gl_blue_size);
   674         SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, state->gl_alpha_size);
   675         SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer);
   676         SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size);
   677         SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, state->gl_depth_size);
   678         SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size);
   679         SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size);
   680         SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size);
   681         SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size);
   682         SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size);
   683         SDL_GL_SetAttribute(SDL_GL_STEREO, state->gl_stereo);
   684         SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers);
   685         SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples);
   686         if (state->gl_accelerated >= 0) {
   687             SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL,
   688                                 state->gl_accelerated);
   689         }
   690         SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing);
   691         if (state->gl_major_version) {
   692             SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, state->gl_major_version);
   693             SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, state->gl_minor_version);
   694         }
   695         if (state->gl_debug) {
   696             SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
   697         }
   698         if (state->gl_profile_mask) {
   699             SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, state->gl_profile_mask);
   700         }
   701 
   702         if (state->verbose & VERBOSE_MODES) {
   703             SDL_Rect bounds;
   704             SDL_DisplayMode mode;
   705             int bpp;
   706             Uint32 Rmask, Gmask, Bmask, Amask;
   707 #if SDL_VIDEO_DRIVER_WINDOWS
   708 			int adapterIndex = 0;
   709 #endif
   710             n = SDL_GetNumVideoDisplays();
   711             fprintf(stderr, "Number of displays: %d\n", n);
   712             for (i = 0; i < n; ++i) {
   713                 fprintf(stderr, "Display %d: %s\n", i, SDL_GetDisplayName(i));
   714 
   715                 SDL_zero(bounds);
   716                 SDL_GetDisplayBounds(i, &bounds);
   717                 fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
   718 
   719                 SDL_GetDesktopDisplayMode(i, &mode);
   720                 SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
   721                                            &Bmask, &Amask);
   722                 fprintf(stderr,
   723                         "  Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
   724                         mode.w, mode.h, mode.refresh_rate, bpp,
   725                         SDL_GetPixelFormatName(mode.format));
   726                 if (Rmask || Gmask || Bmask) {
   727                     fprintf(stderr, "      Red Mask   = 0x%.8x\n", Rmask);
   728                     fprintf(stderr, "      Green Mask = 0x%.8x\n", Gmask);
   729                     fprintf(stderr, "      Blue Mask  = 0x%.8x\n", Bmask);
   730                     if (Amask)
   731                         fprintf(stderr, "      Alpha Mask = 0x%.8x\n", Amask);
   732                 }
   733 
   734                 /* Print available fullscreen video modes */
   735                 m = SDL_GetNumDisplayModes(i);
   736                 if (m == 0) {
   737                     fprintf(stderr, "No available fullscreen video modes\n");
   738                 } else {
   739                     fprintf(stderr, "  Fullscreen video modes:\n");
   740                     for (j = 0; j < m; ++j) {
   741                         SDL_GetDisplayMode(i, j, &mode);
   742                         SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
   743                                                    &Gmask, &Bmask, &Amask);
   744                         fprintf(stderr,
   745                                 "    Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n",
   746                                 j, mode.w, mode.h, mode.refresh_rate, bpp,
   747                                 SDL_GetPixelFormatName(mode.format));
   748                         if (Rmask || Gmask || Bmask) {
   749                             fprintf(stderr, "        Red Mask   = 0x%.8x\n",
   750                                     Rmask);
   751                             fprintf(stderr, "        Green Mask = 0x%.8x\n",
   752                                     Gmask);
   753                             fprintf(stderr, "        Blue Mask  = 0x%.8x\n",
   754                                     Bmask);
   755                             if (Amask)
   756                                 fprintf(stderr,
   757                                         "        Alpha Mask = 0x%.8x\n",
   758                                         Amask);
   759                         }
   760                     }
   761                 }
   762 
   763 #if SDL_VIDEO_DRIVER_WINDOWS
   764 				/* Print the adapter index */
   765 				adapterIndex = SDL_Direct3D9GetAdapterIndex( i );
   766 				fprintf( stderr, "Adapter Index: %d", adapterIndex );
   767 #endif
   768             }
   769         }
   770 
   771         if (state->verbose & VERBOSE_RENDER) {
   772             SDL_RendererInfo info;
   773 
   774             n = SDL_GetNumRenderDrivers();
   775             if (n == 0) {
   776                 fprintf(stderr, "No built-in render drivers\n");
   777             } else {
   778                 fprintf(stderr, "Built-in render drivers:\n");
   779                 for (i = 0; i < n; ++i) {
   780                     SDL_GetRenderDriverInfo(i, &info);
   781                     SDLTest_PrintRenderer(&info);
   782                 }
   783             }
   784         }
   785 
   786         SDL_zero(fullscreen_mode);
   787         switch (state->depth) {
   788         case 8:
   789             fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8;
   790             break;
   791         case 15:
   792             fullscreen_mode.format = SDL_PIXELFORMAT_RGB555;
   793             break;
   794         case 16:
   795             fullscreen_mode.format = SDL_PIXELFORMAT_RGB565;
   796             break;
   797         case 24:
   798             fullscreen_mode.format = SDL_PIXELFORMAT_RGB24;
   799             break;
   800         default:
   801             fullscreen_mode.format = SDL_PIXELFORMAT_RGB888;
   802             break;
   803         }
   804         fullscreen_mode.refresh_rate = state->refresh_rate;
   805 
   806         state->windows =
   807             (SDL_Window **) SDL_malloc(state->num_windows *
   808                                         sizeof(*state->windows));
   809         state->renderers =
   810             (SDL_Renderer **) SDL_malloc(state->num_windows *
   811                                         sizeof(*state->renderers));
   812         if (!state->windows || !state->renderers) {
   813             fprintf(stderr, "Out of memory!\n");
   814             return SDL_FALSE;
   815         }
   816         for (i = 0; i < state->num_windows; ++i) {
   817             char title[1024];
   818 
   819             if (state->num_windows > 1) {
   820                 SDL_snprintf(title, SDL_arraysize(title), "%s %d",
   821                              state->window_title, i + 1);
   822             } else {
   823                 SDL_strlcpy(title, state->window_title, SDL_arraysize(title));
   824             }
   825             state->windows[i] =
   826                 SDL_CreateWindow(title, state->window_x, state->window_y,
   827                                  state->window_w, state->window_h,
   828                                  state->window_flags);
   829             if (!state->windows[i]) {
   830                 fprintf(stderr, "Couldn't create window: %s\n",
   831                         SDL_GetError());
   832                 return SDL_FALSE;
   833             }
   834             if (state->window_minW || state->window_minH) {
   835                 SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH);
   836             }
   837             if (state->window_maxW || state->window_maxH) {
   838                 SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH);
   839             }
   840             SDL_GetWindowSize(state->windows[i], &w, &h);
   841             if (!(state->window_flags & SDL_WINDOW_RESIZABLE) &&
   842                 (w != state->window_w || h != state->window_h)) {
   843                 printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h);
   844                 state->window_w = w;
   845                 state->window_h = h;
   846             }
   847             if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) {
   848                 fprintf(stderr, "Can't set up fullscreen display mode: %s\n",
   849                         SDL_GetError());
   850                 return SDL_FALSE;
   851             }
   852 
   853             if (state->window_icon) {
   854                 SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon);
   855                 if (icon) {
   856                     SDL_SetWindowIcon(state->windows[i], icon);
   857                     SDL_FreeSurface(icon);
   858                 }
   859             }
   860 
   861             SDL_ShowWindow(state->windows[i]);
   862 
   863             state->renderers[i] = NULL;
   864 
   865             if (!state->skip_renderer
   866                 && (state->renderdriver
   867                     || !(state->window_flags & SDL_WINDOW_OPENGL))) {
   868                 m = -1;
   869                 if (state->renderdriver) {
   870                     SDL_RendererInfo info;
   871                     n = SDL_GetNumRenderDrivers();
   872                     for (j = 0; j < n; ++j) {
   873                         SDL_GetRenderDriverInfo(j, &info);
   874                         if (SDL_strcasecmp(info.name, state->renderdriver) ==
   875                             0) {
   876                             m = j;
   877                             break;
   878                         }
   879                     }
   880                     if (m == n) {
   881                         fprintf(stderr,
   882                                 "Couldn't find render driver named %s",
   883                                 state->renderdriver);
   884                         return SDL_FALSE;
   885                     }
   886                 }
   887                 state->renderers[i] = SDL_CreateRenderer(state->windows[i],
   888                                             m, state->render_flags);
   889                 if (!state->renderers[i]) {
   890                     fprintf(stderr, "Couldn't create renderer: %s\n",
   891                             SDL_GetError());
   892                     return SDL_FALSE;
   893                 }
   894                 if (state->logical_w && state->logical_h) {
   895                     SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h);
   896                 } else if (state->scale) {
   897                     SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
   898                 }
   899                 if (state->verbose & VERBOSE_RENDER) {
   900                     SDL_RendererInfo info;
   901 
   902                     fprintf(stderr, "Current renderer:\n");
   903                     SDL_GetRendererInfo(state->renderers[i], &info);
   904                     SDLTest_PrintRenderer(&info);
   905                 }
   906             }
   907         }
   908     }
   909 
   910     if (state->flags & SDL_INIT_AUDIO) {
   911         if (state->verbose & VERBOSE_AUDIO) {
   912             n = SDL_GetNumAudioDrivers();
   913             if (n == 0) {
   914                 fprintf(stderr, "No built-in audio drivers\n");
   915             } else {
   916                 fprintf(stderr, "Built-in audio drivers:");
   917                 for (i = 0; i < n; ++i) {
   918                     if (i > 0) {
   919                         fprintf(stderr, ",");
   920                     }
   921                     fprintf(stderr, " %s", SDL_GetAudioDriver(i));
   922                 }
   923                 fprintf(stderr, "\n");
   924             }
   925         }
   926         if (SDL_AudioInit(state->audiodriver) < 0) {
   927             fprintf(stderr, "Couldn't initialize audio driver: %s\n",
   928                     SDL_GetError());
   929             return SDL_FALSE;
   930         }
   931         if (state->verbose & VERBOSE_VIDEO) {
   932             fprintf(stderr, "Audio driver: %s\n",
   933                     SDL_GetCurrentAudioDriver());
   934         }
   935 
   936         if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
   937             fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
   938             return SDL_FALSE;
   939         }
   940     }
   941 
   942     return SDL_TRUE;
   943 }
   944 
   945 static void
   946 SDLTest_PrintEvent(SDL_Event * event)
   947 {
   948     if ((event->type == SDL_MOUSEMOTION) || (event->type == SDL_FINGERMOTION)) {
   949         /* Mouse and finger motion are really spammy */
   950         return;
   951     }
   952 
   953     fprintf(stderr, "SDL EVENT: ");
   954     switch (event->type) {
   955     case SDL_WINDOWEVENT:
   956         switch (event->window.event) {
   957         case SDL_WINDOWEVENT_SHOWN:
   958             fprintf(stderr, "Window %d shown", event->window.windowID);
   959             break;
   960         case SDL_WINDOWEVENT_HIDDEN:
   961             fprintf(stderr, "Window %d hidden", event->window.windowID);
   962             break;
   963         case SDL_WINDOWEVENT_EXPOSED:
   964             fprintf(stderr, "Window %d exposed", event->window.windowID);
   965             break;
   966         case SDL_WINDOWEVENT_MOVED:
   967             fprintf(stderr, "Window %d moved to %d,%d",
   968                     event->window.windowID, event->window.data1,
   969                     event->window.data2);
   970             break;
   971         case SDL_WINDOWEVENT_RESIZED:
   972             fprintf(stderr, "Window %d resized to %dx%d",
   973                     event->window.windowID, event->window.data1,
   974                     event->window.data2);
   975             break;
   976         case SDL_WINDOWEVENT_SIZE_CHANGED:
   977             fprintf(stderr, "Window %d changed size to %dx%d",
   978                     event->window.windowID, event->window.data1,
   979                     event->window.data2);
   980             break;
   981         case SDL_WINDOWEVENT_MINIMIZED:
   982             fprintf(stderr, "Window %d minimized", event->window.windowID);
   983             break;
   984         case SDL_WINDOWEVENT_MAXIMIZED:
   985             fprintf(stderr, "Window %d maximized", event->window.windowID);
   986             break;
   987         case SDL_WINDOWEVENT_RESTORED:
   988             fprintf(stderr, "Window %d restored", event->window.windowID);
   989             break;
   990         case SDL_WINDOWEVENT_ENTER:
   991             fprintf(stderr, "Mouse entered window %d",
   992                     event->window.windowID);
   993             break;
   994         case SDL_WINDOWEVENT_LEAVE:
   995             fprintf(stderr, "Mouse left window %d", event->window.windowID);
   996             break;
   997         case SDL_WINDOWEVENT_FOCUS_GAINED:
   998             fprintf(stderr, "Window %d gained keyboard focus",
   999                     event->window.windowID);
  1000             break;
  1001         case SDL_WINDOWEVENT_FOCUS_LOST:
  1002             fprintf(stderr, "Window %d lost keyboard focus",
  1003                     event->window.windowID);
  1004             break;
  1005         case SDL_WINDOWEVENT_CLOSE:
  1006             fprintf(stderr, "Window %d closed", event->window.windowID);
  1007             break;
  1008         default:
  1009             fprintf(stderr, "Window %d got unknown event %d",
  1010                     event->window.windowID, event->window.event);
  1011             break;
  1012         }
  1013         break;
  1014     case SDL_KEYDOWN:
  1015         fprintf(stderr,
  1016                 "Keyboard: key pressed  in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
  1017                 event->key.windowID,
  1018                 event->key.keysym.scancode,
  1019                 SDL_GetScancodeName(event->key.keysym.scancode),
  1020                 event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
  1021         break;
  1022     case SDL_KEYUP:
  1023         fprintf(stderr,
  1024                 "Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s",
  1025                 event->key.windowID,
  1026                 event->key.keysym.scancode,
  1027                 SDL_GetScancodeName(event->key.keysym.scancode),
  1028                 event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym));
  1029         break;
  1030     case SDL_TEXTINPUT:
  1031         fprintf(stderr, "Keyboard: text input \"%s\" in window %d",
  1032                 event->text.text, event->text.windowID);
  1033         break;
  1034     case SDL_MOUSEMOTION:
  1035         fprintf(stderr, "Mouse: moved to %d,%d (%d,%d) in window %d",
  1036                 event->motion.x, event->motion.y,
  1037                 event->motion.xrel, event->motion.yrel,
  1038                 event->motion.windowID);
  1039         break;
  1040     case SDL_MOUSEBUTTONDOWN:
  1041         fprintf(stderr, "Mouse: button %d pressed at %d,%d in window %d",
  1042                 event->button.button, event->button.x, event->button.y,
  1043                 event->button.windowID);
  1044         break;
  1045     case SDL_MOUSEBUTTONUP:
  1046         fprintf(stderr, "Mouse: button %d released at %d,%d in window %d",
  1047                 event->button.button, event->button.x, event->button.y,
  1048                 event->button.windowID);
  1049         break;
  1050     case SDL_MOUSEWHEEL:
  1051         fprintf(stderr,
  1052                 "Mouse: wheel scrolled %d in x and %d in y in window %d",
  1053                 event->wheel.x, event->wheel.y, event->wheel.windowID);
  1054         break;
  1055     case SDL_JOYBALLMOTION:
  1056         fprintf(stderr, "Joystick %d: ball %d moved by %d,%d",
  1057                 event->jball.which, event->jball.ball, event->jball.xrel,
  1058                 event->jball.yrel);
  1059         break;
  1060     case SDL_JOYHATMOTION:
  1061         fprintf(stderr, "Joystick %d: hat %d moved to ", event->jhat.which,
  1062                 event->jhat.hat);
  1063         switch (event->jhat.value) {
  1064         case SDL_HAT_CENTERED:
  1065             fprintf(stderr, "CENTER");
  1066             break;
  1067         case SDL_HAT_UP:
  1068             fprintf(stderr, "UP");
  1069             break;
  1070         case SDL_HAT_RIGHTUP:
  1071             fprintf(stderr, "RIGHTUP");
  1072             break;
  1073         case SDL_HAT_RIGHT:
  1074             fprintf(stderr, "RIGHT");
  1075             break;
  1076         case SDL_HAT_RIGHTDOWN:
  1077             fprintf(stderr, "RIGHTDOWN");
  1078             break;
  1079         case SDL_HAT_DOWN:
  1080             fprintf(stderr, "DOWN");
  1081             break;
  1082         case SDL_HAT_LEFTDOWN:
  1083             fprintf(stderr, "LEFTDOWN");
  1084             break;
  1085         case SDL_HAT_LEFT:
  1086             fprintf(stderr, "LEFT");
  1087             break;
  1088         case SDL_HAT_LEFTUP:
  1089             fprintf(stderr, "LEFTUP");
  1090             break;
  1091         default:
  1092             fprintf(stderr, "UNKNOWN");
  1093             break;
  1094         }
  1095         break;
  1096     case SDL_JOYBUTTONDOWN:
  1097         fprintf(stderr, "Joystick %d: button %d pressed",
  1098                 event->jbutton.which, event->jbutton.button);
  1099         break;
  1100     case SDL_JOYBUTTONUP:
  1101         fprintf(stderr, "Joystick %d: button %d released",
  1102                 event->jbutton.which, event->jbutton.button);
  1103         break;
  1104     case SDL_CLIPBOARDUPDATE:
  1105         fprintf(stderr, "Clipboard updated");
  1106         break;
  1107 
  1108     case SDL_FINGERDOWN:
  1109     case SDL_FINGERUP:
  1110         fprintf(stderr, "Finger: %s touch=%lld, finger=%lld, x=%f, y=%f, dx=%f, dy=%f, pressure=%f",
  1111                 (event->type == SDL_FINGERDOWN) ? "down" : "up",
  1112                 (long long) event->tfinger.touchId,
  1113                 (long long) event->tfinger.fingerId,
  1114                 event->tfinger.x, event->tfinger.y,
  1115                 event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure);
  1116         break;
  1117 
  1118     case SDL_QUIT:
  1119         fprintf(stderr, "Quit requested");
  1120         break;
  1121     case SDL_USEREVENT:
  1122         fprintf(stderr, "User event %d", event->user.code);
  1123         break;
  1124     default:
  1125         fprintf(stderr, "Unknown event %d", event->type);
  1126         break;
  1127     }
  1128     fprintf(stderr, "\n");
  1129 }
  1130 
  1131 static void
  1132 SDLTest_ScreenShot(SDL_Renderer *renderer)
  1133 {
  1134     SDL_Rect viewport;
  1135     SDL_Surface *surface;
  1136 
  1137     if (!renderer) {
  1138         return;
  1139     }
  1140 
  1141     SDL_RenderGetViewport(renderer, &viewport);
  1142     surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
  1143 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
  1144                     0x00FF0000, 0x0000FF00, 0x000000FF,
  1145 #else
  1146                     0x000000FF, 0x0000FF00, 0x00FF0000,
  1147 #endif
  1148                     0x00000000);
  1149     if (!surface) {
  1150         fprintf(stderr, "Couldn't create surface: %s\n", SDL_GetError());
  1151         return;
  1152     }
  1153 
  1154     if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
  1155                              surface->pixels, surface->pitch) < 0) {
  1156         fprintf(stderr, "Couldn't read screen: %s\n", SDL_GetError());
  1157         return;
  1158     }
  1159 
  1160     if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
  1161         fprintf(stderr, "Couldn't save screenshot.bmp: %s\n", SDL_GetError());
  1162         return;
  1163     }
  1164 }
  1165 
  1166 static void
  1167 FullscreenTo(int index, int windowId)
  1168 {
  1169     Uint32 flags;
  1170     struct SDL_Rect rect = { 0, 0, 0, 0 };
  1171     SDL_Window *window = SDL_GetWindowFromID(windowId);
  1172     if (!window) {
  1173         return;
  1174     }
  1175 
  1176     SDL_GetDisplayBounds( index, &rect );
  1177 
  1178     flags = SDL_GetWindowFlags(window);
  1179     if (flags & SDL_WINDOW_FULLSCREEN) {
  1180         SDL_SetWindowFullscreen( window, SDL_FALSE );
  1181         SDL_Delay( 15 );
  1182     }
  1183 
  1184     SDL_SetWindowPosition( window, rect.x, rect.y );
  1185     SDL_SetWindowFullscreen( window, SDL_TRUE );
  1186 }
  1187 
  1188 void
  1189 SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done)
  1190 {
  1191     int i;
  1192     static SDL_MouseMotionEvent lastEvent;
  1193 
  1194     if (state->verbose & VERBOSE_EVENT) {
  1195         SDLTest_PrintEvent(event);
  1196     }
  1197 
  1198     switch (event->type) {
  1199     case SDL_WINDOWEVENT:
  1200         switch (event->window.event) {
  1201         case SDL_WINDOWEVENT_CLOSE:
  1202             {
  1203                 SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
  1204                 if (window) {
  1205                     SDL_DestroyWindow(window);
  1206                     for (i = 0; i < state->num_windows; ++i) {
  1207                         if (window == state->windows[i]) {
  1208                             state->windows[i] = NULL;
  1209                             break;
  1210                         }
  1211                     }
  1212                 }
  1213             }
  1214             break;
  1215         }
  1216         break;
  1217     case SDL_KEYDOWN:
  1218         switch (event->key.keysym.sym) {
  1219             /* Add hotkeys here */
  1220         case SDLK_PRINTSCREEN: {
  1221                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1222                 if (window) {
  1223                     for (i = 0; i < state->num_windows; ++i) {
  1224                         if (window == state->windows[i]) {
  1225                             SDLTest_ScreenShot(state->renderers[i]);
  1226                         }
  1227                     }
  1228                 }
  1229             }
  1230             break;
  1231         case SDLK_EQUALS:
  1232             if (event->key.keysym.mod & KMOD_CTRL) {
  1233                 /* Ctrl-+ double the size of the window */
  1234                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1235                 if (window) {
  1236                     int w, h;
  1237                     SDL_GetWindowSize(window, &w, &h);
  1238                     SDL_SetWindowSize(window, w*2, h*2);
  1239                 }
  1240             }
  1241             break;
  1242         case SDLK_MINUS:
  1243             if (event->key.keysym.mod & KMOD_CTRL) {
  1244                 /* Ctrl-- half the size of the window */
  1245                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1246                 if (window) {
  1247                     int w, h;
  1248                     SDL_GetWindowSize(window, &w, &h);
  1249                     SDL_SetWindowSize(window, w/2, h/2);
  1250                 }
  1251             }
  1252             break;
  1253         case SDLK_c:
  1254             if (event->key.keysym.mod & KMOD_CTRL) {
  1255                 /* Ctrl-C copy awesome text! */
  1256                 SDL_SetClipboardText("SDL rocks!\nYou know it!");
  1257                 printf("Copied text to clipboard\n");
  1258             }
  1259             if (event->key.keysym.mod & KMOD_ALT) {
  1260                 /* Alt-C toggle a render clip rectangle */
  1261                 for (i = 0; i < state->num_windows; ++i) {
  1262                     int w, h;
  1263                     if (state->renderers[i]) {
  1264                         SDL_Rect clip;
  1265                         SDL_GetWindowSize(state->windows[i], &w, &h);
  1266                         SDL_RenderGetClipRect(state->renderers[i], &clip);
  1267                         if (SDL_RectEmpty(&clip)) {
  1268                             clip.x = w/4;
  1269                             clip.y = h/4;
  1270                             clip.w = w/2;
  1271                             clip.h = h/2;
  1272                             SDL_RenderSetClipRect(state->renderers[i], &clip);
  1273                         } else {
  1274                             SDL_RenderSetClipRect(state->renderers[i], NULL);
  1275                         }
  1276                     }
  1277                 }
  1278             }
  1279             break;
  1280         case SDLK_v:
  1281             if (event->key.keysym.mod & KMOD_CTRL) {
  1282                 /* Ctrl-V paste awesome text! */
  1283                 char *text = SDL_GetClipboardText();
  1284                 if (*text) {
  1285                     printf("Clipboard: %s\n", text);
  1286                 } else {
  1287                     printf("Clipboard is empty\n");
  1288                 }
  1289                 SDL_free(text);
  1290             }
  1291             break;
  1292         case SDLK_g:
  1293             if (event->key.keysym.mod & KMOD_CTRL) {
  1294                 /* Ctrl-G toggle grab */
  1295                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1296                 if (window) {
  1297                     SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window) ? SDL_TRUE : SDL_FALSE);
  1298                 }
  1299             }
  1300             break;
  1301         case SDLK_m:
  1302             if (event->key.keysym.mod & KMOD_CTRL) {
  1303                 /* Ctrl-M maximize */
  1304                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1305                 if (window) {
  1306                     Uint32 flags = SDL_GetWindowFlags(window);
  1307                     if (flags & SDL_WINDOW_MAXIMIZED) {
  1308                         SDL_RestoreWindow(window);
  1309                     } else {
  1310                         SDL_MaximizeWindow(window);
  1311                     }
  1312                 }
  1313             }
  1314             break;
  1315         case SDLK_r:
  1316             if (event->key.keysym.mod & KMOD_CTRL) {
  1317                 /* Ctrl-R toggle mouse relative mode */
  1318                 SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode() ? SDL_TRUE : SDL_FALSE);
  1319             }
  1320             break;
  1321         case SDLK_z:
  1322             if (event->key.keysym.mod & KMOD_CTRL) {
  1323                 /* Ctrl-Z minimize */
  1324                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1325                 if (window) {
  1326                     SDL_MinimizeWindow(window);
  1327                 }
  1328             }
  1329             break;
  1330         case SDLK_RETURN:
  1331             if (event->key.keysym.mod & KMOD_CTRL) {
  1332                 /* Ctrl-Enter toggle fullscreen */
  1333                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1334                 if (window) {
  1335                     Uint32 flags = SDL_GetWindowFlags(window);
  1336                     if (flags & SDL_WINDOW_FULLSCREEN) {
  1337                         SDL_SetWindowFullscreen(window, SDL_FALSE);
  1338                     } else {
  1339                         SDL_SetWindowFullscreen(window, SDL_TRUE);
  1340                     }
  1341                 }
  1342             } else if (event->key.keysym.mod & KMOD_ALT) {
  1343                 /* Alt-Enter toggle fullscreen desktop */
  1344                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1345                 if (window) {
  1346                     Uint32 flags = SDL_GetWindowFlags(window);
  1347                     if (flags & SDL_WINDOW_FULLSCREEN) {
  1348                         SDL_SetWindowFullscreen(window, SDL_FALSE);
  1349                     } else {
  1350                         SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
  1351                     }
  1352                 }
  1353             }
  1354             break;
  1355         case SDLK_b:
  1356             if (event->key.keysym.mod & KMOD_CTRL) {
  1357                 /* Ctrl-B toggle window border */
  1358                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1359                 if (window) {
  1360                     const Uint32 flags = SDL_GetWindowFlags(window);
  1361                     const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0) ? SDL_TRUE : SDL_FALSE;
  1362                     SDL_SetWindowBordered(window, b);
  1363                 }
  1364             }
  1365             break;
  1366         case SDLK_0:
  1367             if (event->key.keysym.mod & KMOD_CTRL) {
  1368                 SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1369                 SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window);
  1370             }
  1371             break;
  1372         case SDLK_1:
  1373             if (event->key.keysym.mod & KMOD_CTRL) {
  1374                 FullscreenTo(0, event->key.windowID);
  1375             }
  1376             break;
  1377         case SDLK_2:
  1378             if (event->key.keysym.mod & KMOD_CTRL) {
  1379                 FullscreenTo(1, event->key.windowID);
  1380             }
  1381             break;
  1382         case SDLK_ESCAPE:
  1383             *done = 1;
  1384             break;
  1385         case SDLK_SPACE:
  1386         {
  1387             char message[256];
  1388             SDL_Window *window = SDL_GetWindowFromID(event->key.windowID);
  1389 
  1390             SDL_snprintf(message, sizeof(message), "(%i, %i), rel (%i, %i)\n", lastEvent.x, lastEvent.y, lastEvent.xrel, lastEvent.yrel);
  1391             SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Last mouse position", message, window);
  1392             break;
  1393         }
  1394         default:
  1395             break;
  1396         }
  1397         break;
  1398     case SDL_QUIT:
  1399         *done = 1;
  1400         break;
  1401     case SDL_MOUSEMOTION:
  1402         lastEvent = event->motion;
  1403         break;
  1404     }
  1405 }
  1406 
  1407 void
  1408 SDLTest_CommonQuit(SDLTest_CommonState * state)
  1409 {
  1410     int i;
  1411 
  1412     SDL_free(state->windows);
  1413     if (state->renderers) {
  1414         for (i = 0; i < state->num_windows; ++i) {
  1415             if (state->renderers[i]) {
  1416                 SDL_DestroyRenderer(state->renderers[i]);
  1417             }
  1418         }
  1419         SDL_free(state->renderers);
  1420     }
  1421     if (state->flags & SDL_INIT_VIDEO) {
  1422         SDL_VideoQuit();
  1423     }
  1424     if (state->flags & SDL_INIT_AUDIO) {
  1425         SDL_AudioQuit();
  1426     }
  1427     SDL_free(state);
  1428 }
  1429 
  1430 /* vi: set ts=4 sw=4 expandtab: */