const char *Window::getDisplayName(int displayindex) const
{
const char *name = SDL_GetDisplayName(displayindex);
if (name == nullptr)
throw love::Exception("Invalid display index: %d", displayindex + 1);
return name;
}
int
main(int argc, char *argv[])
{
SDL_DisplayMode mode;
int num_displays, dpy;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Load the SDL library */
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
return 1;
}
SDL_Log("Using video target '%s'.\n", SDL_GetCurrentVideoDriver());
num_displays = SDL_GetNumVideoDisplays();
SDL_Log("See %d displays.\n", num_displays);
for (dpy = 0; dpy < num_displays; dpy++) {
const int num_modes = SDL_GetNumDisplayModes(dpy);
SDL_Rect rect = { 0, 0, 0, 0 };
int m;
SDL_GetDisplayBounds(dpy, &rect);
SDL_Log("%d: \"%s\" (%dx%d, (%d, %d)), %d modes.\n", dpy, SDL_GetDisplayName(dpy), rect.w, rect.h, rect.x, rect.y, num_modes);
if (SDL_GetCurrentDisplayMode(dpy, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " CURRENT: failed to query (%s)\n", SDL_GetError());
} else {
print_mode("CURRENT", &mode);
}
if (SDL_GetDesktopDisplayMode(dpy, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " DESKTOP: failed to query (%s)\n", SDL_GetError());
} else {
print_mode("DESKTOP", &mode);
}
for (m = 0; m < num_modes; m++) {
if (SDL_GetDisplayMode(dpy, m, &mode) == -1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " MODE %d: failed to query (%s)\n", m, SDL_GetError());
} else {
char prefix[64];
SDL_snprintf(prefix, sizeof (prefix), " MODE %d", m);
print_mode(prefix, &mode);
}
}
SDL_Log("\n");
}
return 0;
}
Display ( unsigned int index):
index(index) {
name = SDL_GetDisplayName(index);
int numDisplayModes = SDL_GetNumDisplayModes(index);
for (int i = 0; i < numDisplayModes; ++i) {
SDL_DisplayMode displayMode;
if (SDL_GetDisplayMode(index, i, &displayMode) != -1) {
displayModes.push_back(DisplayMode(i, displayMode));
}
}
}
internal void OutputSystemInfo()
{
SDL_Log("System Info\n");
int ram = SDL_GetSystemRAM();
SDL_Log("Ram: %dMB\n", ram);
int cpu_count = SDL_GetCPUCount();
SDL_Log("CPU Count: %d\n", cpu_count);
const char *platform = SDL_GetPlatform();
SDL_Log("Platform: %s\n", platform);
int display_num = SDL_GetNumVideoDisplays();
SDL_Log("Display Count: %d\n", display_num);
for (int i = 0; i < display_num; i++)
{
SDL_Rect rect;
SDL_GetDisplayBounds(i, &rect);
const char *name = SDL_GetDisplayName(i);
SDL_Log("Display: %s\n", name);
SDL_Log("-X: %d, ", rect.x);
SDL_Log("Y: %d, ", rect.y);
SDL_Log("Width: %d, ", rect.w);
SDL_Log("Height: %d\n", rect.h);
for (int j = 0; j < SDL_GetNumDisplayModes(i); j++)
{
SDL_DisplayMode mode;
SDL_GetDisplayMode(i, j, &mode);
SDL_Log("--Mode: \n");
SDL_Log("---Width: %d\n", mode.w);
SDL_Log("---Height: %d\n", mode.h);
SDL_Log("---Refresh Rate: %d\n", mode.refresh_rate);
}
}
}
static int display_gui(void)
{
int id, jd;
int i, n = SDL_GetNumVideoDisplays();
if ((id = gui_vstack(0)))
{
conf_header(id, _("Display"), GUI_BACK);
for (i = 0; i < n; i++)
{
const char *name = SDL_GetDisplayName(i);
jd = gui_state(id, name, GUI_SML, DISPLAY_SELECT, i);
gui_set_hilite(jd, (i == config_get_d(CONFIG_DISPLAY)));
}
gui_layout(id, 0, 0);
}
return id;
}
value System::GetDisplay (int id) {
if (!init) {
id_bounds = val_id ("bounds");
id_currentMode = val_id ("currentMode");
id_dpi = val_id ("dpi");
id_height = val_id ("height");
id_name = val_id ("name");
id_pixelFormat = val_id ("pixelFormat");
id_refreshRate = val_id ("refreshRate");
id_supportedModes = val_id ("supportedModes");
id_width = val_id ("width");
init = true;
}
int numDisplays = GetNumDisplays ();
if (id < 0 || id >= numDisplays) {
return alloc_null ();
}
value display = alloc_empty_object ();
alloc_field (display, id_name, alloc_string (SDL_GetDisplayName (id)));
SDL_Rect bounds = { 0, 0, 0, 0 };
SDL_GetDisplayBounds (id, &bounds);
alloc_field (display, id_bounds, Rectangle (bounds.x, bounds.y, bounds.w, bounds.h).Value ());
float dpi = 72.0;
#ifndef EMSCRIPTEN
SDL_GetDisplayDPI (id, &dpi, NULL, NULL);
#endif
alloc_field (display, id_dpi, alloc_float (dpi));
SDL_DisplayMode currentDisplayMode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
SDL_DisplayMode displayMode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
SDL_GetCurrentDisplayMode (id, ¤tDisplayMode);
int numDisplayModes = SDL_GetNumDisplayModes (id);
value supportedModes = alloc_array (numDisplayModes);
value mode;
for (int i = 0; i < numDisplayModes; i++) {
SDL_GetDisplayMode (id, i, &displayMode);
if (displayMode.format == currentDisplayMode.format && displayMode.w == currentDisplayMode.w && displayMode.h == currentDisplayMode.h && displayMode.refresh_rate == currentDisplayMode.refresh_rate) {
alloc_field (display, id_currentMode, alloc_int (i));
}
mode = alloc_empty_object ();
alloc_field (mode, id_height, alloc_int (displayMode.h));
switch (displayMode.format) {
case SDL_PIXELFORMAT_ARGB8888:
alloc_field (mode, id_pixelFormat, alloc_int (ARGB32));
break;
case SDL_PIXELFORMAT_BGRA8888:
case SDL_PIXELFORMAT_BGRX8888:
alloc_field (mode, id_pixelFormat, alloc_int (BGRA32));
break;
default:
alloc_field (mode, id_pixelFormat, alloc_int (RGBA32));
}
alloc_field (mode, id_refreshRate, alloc_int (displayMode.refresh_rate));
alloc_field (mode, id_width, alloc_int (displayMode.w));
val_array_set_i (supportedModes, i, mode);
}
alloc_field (display, id_supportedModes, supportedModes);
return display;
}
SDL_bool
SDLTest_CommonInit(SDLTest_CommonState * state)
{
int i, j, m, n, w, h;
SDL_DisplayMode fullscreen_mode;
if (state->flags & SDL_INIT_VIDEO) {
if (state->verbose & VERBOSE_VIDEO) {
n = SDL_GetNumVideoDrivers();
if (n == 0) {
fprintf(stderr, "No built-in video drivers\n");
} else {
fprintf(stderr, "Built-in video drivers:");
for (i = 0; i < n; ++i) {
if (i > 0) {
fprintf(stderr, ",");
}
fprintf(stderr, " %s", SDL_GetVideoDriver(i));
}
fprintf(stderr, "\n");
}
}
if (SDL_VideoInit(state->videodriver) < 0) {
fprintf(stderr, "Couldn't initialize video driver: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->verbose & VERBOSE_VIDEO) {
fprintf(stderr, "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->verbose & VERBOSE_MODES) {
SDL_Rect bounds;
SDL_DisplayMode mode;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
n = SDL_GetNumVideoDisplays();
fprintf(stderr, "Number of displays: %d\n", n);
for (i = 0; i < n; ++i) {
fprintf(stderr, "Display %d: %s\n", i, SDL_GetDisplayName(i));
SDL_zero(bounds);
SDL_GetDisplayBounds(i, &bounds);
fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y);
SDL_GetDesktopDisplayMode(i, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask);
fprintf(stderr,
" 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) {
fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask);
fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask);
fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask);
if (Amask)
fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask);
}
/* Print available fullscreen video modes */
m = SDL_GetNumDisplayModes(i);
if (m == 0) {
fprintf(stderr, "No available fullscreen video modes\n");
} else {
fprintf(stderr, " Fullscreen video modes:\n");
for (j = 0; j < m; ++j) {
SDL_GetDisplayMode(i, j, &mode);
SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask);
fprintf(stderr,
" 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) {
fprintf(stderr, " Red Mask = 0x%.8x\n",
Rmask);
fprintf(stderr, " Green Mask = 0x%.8x\n",
Gmask);
fprintf(stderr, " Blue Mask = 0x%.8x\n",
Bmask);
if (Amask)
fprintf(stderr,
" Alpha Mask = 0x%.8x\n",
Amask);
}
}
}
}
}
if (state->verbose & VERBOSE_RENDER) {
SDL_RendererInfo info;
n = SDL_GetNumRenderDrivers();
if (n == 0) {
fprintf(stderr, "No built-in render drivers\n");
} else {
fprintf(stderr, "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_malloc(state->num_windows *
sizeof(*state->windows));
state->renderers =
(SDL_Renderer **) SDL_malloc(state->num_windows *
sizeof(*state->renderers));
if (!state->windows || !state->renderers) {
fprintf(stderr, "Out of memory!\n");
return SDL_FALSE;
}
for (i = 0; i < state->num_windows; ++i) {
char title[1024];
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, state->window_x, state->window_y,
state->window_w, state->window_h,
state->window_flags);
if (!state->windows[i]) {
fprintf(stderr, "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) {
fprintf(stderr, "Can't set up fullscreen display mode: %s\n",
SDL_GetError());
return SDL_FALSE;
}
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]);
state->renderers[i] = NULL;
if (!state->skip_renderer
&& (state->renderdriver
|| !(state->window_flags & SDL_WINDOW_OPENGL))) {
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 == n) {
fprintf(stderr,
"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]) {
fprintf(stderr, "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) {
SDL_RenderSetScale(state->renderers[i], state->scale, state->scale);
}
if (state->verbose & VERBOSE_RENDER) {
SDL_RendererInfo info;
fprintf(stderr, "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) {
fprintf(stderr, "No built-in audio drivers\n");
} else {
fprintf(stderr, "Built-in audio drivers:");
for (i = 0; i < n; ++i) {
if (i > 0) {
fprintf(stderr, ",");
}
fprintf(stderr, " %s", SDL_GetAudioDriver(i));
}
fprintf(stderr, "\n");
}
}
if (SDL_AudioInit(state->audiodriver) < 0) {
fprintf(stderr, "Couldn't initialize audio driver: %s\n",
SDL_GetError());
return SDL_FALSE;
}
if (state->verbose & VERBOSE_VIDEO) {
fprintf(stderr, "Audio driver: %s\n",
SDL_GetCurrentAudioDriver());
}
if (SDL_OpenAudio(&state->audiospec, NULL) < 0) {
fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
return SDL_FALSE;
}
}
return SDL_TRUE;
}
static int video_gui(void)
{
static const struct conf_option multisample_opts[] = {
{ N_("Off"), 0 },
{ N_("2x"), 2 },
{ N_("4x"), 4 },
{ N_("8x"), 8 },
};
int id, jd;
if ((id = gui_vstack(0)))
{
char resolution[sizeof ("12345678 x 12345678")];
const char *display;
int dpy = config_get_d(CONFIG_DISPLAY);
sprintf(resolution, "%d x %d",
config_get_d(CONFIG_WIDTH),
config_get_d(CONFIG_HEIGHT));
if (!(display = SDL_GetDisplayName(dpy)))
display = _("Unknown Display");
conf_header(id, _("Graphics"), GUI_BACK);
if ((jd = conf_state(id, _("Display"), "Longest Name", VIDEO_DISPLAY)))
{
gui_set_trunc(jd, TRUNC_TAIL);
gui_set_label(jd, display);
}
conf_toggle(id, _("Fullscreen"), VIDEO_FULLSCREEN,
config_get_d(CONFIG_FULLSCREEN), _("On"), 1, _("Off"), 0);
if ((jd = conf_state (id, _("Resolution"), resolution,
VIDEO_RESOLUTION)))
{
/*
* Because we always use the desktop display mode, disable
* display mode switching in fullscreen.
*/
if (config_get_d(CONFIG_FULLSCREEN))
{
gui_set_state(jd, GUI_NONE, 0);
gui_set_color(jd, gui_gry, gui_gry);
}
}
#if ENABLE_HMD
conf_toggle(id, _("HMD"), VIDEO_HMD,
config_get_d(CONFIG_HMD), _("On"), 1, _("Off"), 0);
#endif
gui_space(id);
conf_toggle(id, _("V-Sync"), VIDEO_VSYNC,
config_get_d(CONFIG_VSYNC), _("On"), 1, _("Off"), 0);
conf_select(id, _("Antialiasing"), VIDEO_MULTISAMPLE,
config_get_d(CONFIG_MULTISAMPLE),
multisample_opts, ARRAYSIZE(multisample_opts));
gui_space(id);
conf_toggle(id, _("Reflection"), VIDEO_REFLECTION,
config_get_d(CONFIG_REFLECTION), _("On"), 1, _("Off"), 0);
conf_toggle(id, _("Background"), VIDEO_BACKGROUND,
config_get_d(CONFIG_BACKGROUND), _("On"), 1, _("Off"), 0);
conf_toggle(id, _("Shadow"), VIDEO_SHADOW,
config_get_d(CONFIG_SHADOW), _("On"), 1, _("Off"), 0);
gui_layout(id, 0, 0);
}
return id;
}
const char* desktop_get_display_name(int display) {
return SDL_GetDisplayName(display);
} //desktop_get_display_name
void
loop()
{
int i;
SDL_Event event;
/* Check for events */
while (SDL_PollEvent(&event)) {
SDLTest_CommonEvent(state, &event, &done);
if (event.type == SDL_WINDOWEVENT) {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d resized to %dx%d\n",
event.window.windowID,
event.window.data1,
event.window.data2);
}
}
if (event.window.event == SDL_WINDOWEVENT_MOVED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d moved to %d,%d (display %s)\n",
event.window.windowID,
event.window.data1,
event.window.data2,
SDL_GetDisplayName(SDL_GetWindowDisplayIndex(window)));
}
}
}
if (event.type == SDL_KEYUP) {
SDL_bool updateCursor = SDL_FALSE;
if (event.key.keysym.sym == SDLK_LEFT) {
--system_cursor;
if (system_cursor < 0) {
system_cursor = SDL_NUM_SYSTEM_CURSORS - 1;
}
updateCursor = SDL_TRUE;
} else if (event.key.keysym.sym == SDLK_RIGHT) {
++system_cursor;
if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) {
system_cursor = 0;
}
updateCursor = SDL_TRUE;
}
if (updateCursor) {
SDL_Log("Changing cursor to \"%s\"", cursorNames[system_cursor]);
SDL_FreeCursor(cursor);
cursor = SDL_CreateSystemCursor((SDL_SystemCursor)system_cursor);
SDL_SetCursor(cursor);
}
}
}
for (i = 0; i < state->num_windows; ++i) {
SDL_Renderer *renderer = state->renderers[i];
SDL_RenderClear(renderer);
SDL_RenderPresent(renderer);
}
#ifdef __EMSCRIPTEN__
if (done) {
emscripten_cancel_main_loop();
}
#endif
}
SDLWindowManager::SDLWindowManager(Application* application):
WindowManager(application)
{
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == -1)
{
throw RuntimeException("SDL initialization failed.");
}
int displayCount = SDL_GetNumVideoDisplays();
displays.resize(displayCount);
primaryDisplay = &displays[0];
for (int i = 0; i < displayCount; ++i)
{
Display* display = &displays[i];
const char* displayName = SDL_GetDisplayName(i);
if (displayName)
{
display->setName(displayName);
}
SDL_DisplayMode sdlCurrentDisplayMode;
SDL_GetCurrentDisplayMode(i, &sdlCurrentDisplayMode);
int displayModeCount = SDL_GetNumDisplayModes(i);
for (int j = 0; j < displayModeCount; ++j)
{
SDL_DisplayMode sdlDisplayMode;
SDL_GetDisplayMode(i, j, &sdlDisplayMode);
SDL_PixelFormat* format = SDL_AllocFormat(sdlDisplayMode.format);
if (!format)
{
std::cerr << "Failed to create SDL pixel format: " << SDL_GetPixelFormatName(sdlDisplayMode.format) << '\n';
continue;
}
int width = sdlDisplayMode.w;
int height = sdlDisplayMode.h;
int refreshRate = sdlDisplayMode.refresh_rate;
int redBits, greenBits, blueBits, alphaBits;
SDLPixelFormatMap::getChannelBits(format, &redBits, &greenBits, &blueBits, &alphaBits);
SDL_FreeFormat(format);
display->addMode(
DisplayMode(width, height, redBits, greenBits, blueBits, alphaBits, refreshRate));
if (sdlCurrentDisplayMode.w == sdlDisplayMode.w &&
sdlCurrentDisplayMode.h == sdlDisplayMode.h &&
sdlCurrentDisplayMode.format == sdlDisplayMode.format &&
sdlCurrentDisplayMode.refresh_rate == sdlDisplayMode.refresh_rate)
{
display->setCurrentMode(j);
}
}
}
keyboard = new Keyboard("Default Keyboard");
mouse = new Mouse("Default Mouse");
application->getInputManager()->registerKeyboard(keyboard);
application->getInputManager()->registerMouse(mouse);
}
int
main(int argc, char *argv[])
{
static const char *cursorNames[] = {
"arrow",
"ibeam",
"wait",
"crosshair",
"waitarrow",
"sizeNWSE",
"sizeNESW",
"sizeWE",
"sizeNS",
"sizeALL",
"NO",
"hand",
};
int i, done;
SDL_Event event;
int system_cursor = -1;
SDL_Cursor *cursor = NULL;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
SDL_assert(SDL_arraysize(cursorNames) == SDL_NUM_SYSTEM_CURSORS);
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return 1;
}
state->skip_renderer = SDL_TRUE;
for (i = 1; i < argc;) {
int consumed;
consumed = SDLTest_CommonArg(state, i);
if (consumed == 0) {
consumed = -1;
}
if (consumed < 0) {
SDL_Log("Usage: %s %s\n", argv[0], SDLTest_CommonUsage(state));
quit(1);
}
i += consumed;
}
if (!SDLTest_CommonInit(state)) {
quit(2);
}
/* Main render loop */
done = 0;
while (!done) {
/* Check for events */
while (SDL_PollEvent(&event)) {
SDLTest_CommonEvent(state, &event, &done);
if (event.type == SDL_WINDOWEVENT) {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d resized to %dx%d\n",
event.window.windowID,
event.window.data1,
event.window.data2);
}
}
if (event.window.event == SDL_WINDOWEVENT_MOVED) {
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
if (window) {
SDL_Log("Window %d moved to %d,%d (display %s)\n",
event.window.windowID,
event.window.data1,
event.window.data2,
SDL_GetDisplayName(SDL_GetWindowDisplayIndex(window)));
}
}
}
if (event.type == SDL_KEYUP) {
SDL_bool updateCursor = SDL_FALSE;
if (event.key.keysym.sym == SDLK_LEFT) {
--system_cursor;
if (system_cursor < 0) {
system_cursor = SDL_NUM_SYSTEM_CURSORS - 1;
}
updateCursor = SDL_TRUE;
} else if (event.key.keysym.sym == SDLK_RIGHT) {
++system_cursor;
if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) {
system_cursor = 0;
}
updateCursor = SDL_TRUE;
}
if (updateCursor) {
SDL_Log("Changing cursor to \"%s\"", cursorNames[system_cursor]);
SDL_FreeCursor(cursor);
cursor = SDL_CreateSystemCursor((SDL_SystemCursor)system_cursor);
SDL_SetCursor(cursor);
}
}
}
}
SDL_FreeCursor(cursor);
quit(0);
/* keep the compiler happy ... */
return(0);
}