void sdl_window::activate()
{
SDL_RaiseWindow(iHandle);
#ifdef WIN32
SetWindowPos(static_cast<HWND>(native_handle()), 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
#endif
}
void VID_Restore (void)
{
if (!sdl_window)
return;
SDL_RestoreWindow(sdl_window);
SDL_RaiseWindow(sdl_window);
}
/**
* @brief Window Creation and recreation.
*/
bool WindowManager::createWindow(bool fullScreen)
{
// If Window Already Exists, destory so we can recreate it.
if(m_window)
{
//std::cout << "Destroy SDL Window" << std::endl;
SDL_DestroyWindow(m_window);
m_window = nullptr;
}
int display_height = (m_height / 2);
int display_width = (m_width / 2);
// create window in in full screen or windowed mode.
if(fullScreen)
{
m_window = SDL_CreateWindow("EtherTerm 0.4.6 Alpha Demo - Full Screen",
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_width,
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_height,
m_width,
m_height,
SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN_DESKTOP);
if(!m_window) // window init success
{
SDL_Log("Terminal::restartWindowSize() SDL_CreateWindow globalWindow: %s",
SDL_GetError());
assert(m_window);
}
}
else
{
m_window = SDL_CreateWindow("EtherTerm 0.4.6 Alpha Demo - Windowed",
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_width,
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_height,
m_width,
m_height,
SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if(!m_window) // window init success
{
SDL_Log("Terminal::restartWindowSize() SDL_CreateWindow globalWindow: %s",
SDL_GetError());
assert(m_window);
}
}
// Set the Window ID
m_window_id = SDL_GetWindowID(m_window);
std::string title = "EtherTerm 0.4.6 Alpha Demo w/ Multiple Windows - Window ID: ";
title.append(std::to_string(m_window_id));
SDL_SetWindowTitle(m_window, title.c_str());
// Display and move focus to the new window.
SDL_ShowWindow(m_window);
SDL_RaiseWindow(m_window);
return true;
}
void LWindow::focus() {
//Restore window if needed
if( !mShown ) {
SDL_ShowWindow( mWindow );
}
//Move window forward
SDL_RaiseWindow( mWindow );
}
int trap_MessageBox(lua_State *s)
{
const char *msg;
extern SDL_Window *v_window;
trap_args(s, "MessageBox", "s", &msg);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "", msg, v_window);
SDL_RaiseWindow(v_window);
return 0;
}
/////////////////////////////////////////////////////////
// set topmost position on/off
//
/////////////////////////////////////////////////////////
int topmostGemWindow(WindowInfo &info, int state)
{
static int topmost_state = 0;
state=!(!state);
if (state)
{
SDL_RaiseWindow(info.win); // FIXME not permanent
}
topmost_state = state;
return topmost_state;
}
static SDL_bool
WatchJoystick(SDL_Joystick * joystick)
{
SDL_Window *window = NULL;
const char *name = NULL;
retval = SDL_FALSE;
done = SDL_FALSE;
/* Create a window to display joystick axis position */
window = SDL_CreateWindow("Joystick Test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, 0);
if (window == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* Print info about the joystick we are watching */
name = SDL_JoystickName(joystick);
SDL_Log("Watching joystick %d: (%s)\n", SDL_JoystickInstanceID(joystick),
name ? name : "Unknown Joystick");
SDL_Log("Joystick has %d axes, %d hats, %d balls, and %d buttons\n",
SDL_JoystickNumAxes(joystick), SDL_JoystickNumHats(joystick),
SDL_JoystickNumBalls(joystick), SDL_JoystickNumButtons(joystick));
/* Loop, getting joystick events! */
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop_arg(loop, joystick, 0, 1);
#else
while (!done) {
loop(joystick);
}
#endif
SDL_DestroyRenderer(screen);
screen = NULL;
SDL_DestroyWindow(window);
return retval;
}
/** Native windows should implement BringToFront by making this window the top-most window (i.e. focused).
*
* @param bForce Forces the window to the top of the Z order, even if that means stealing focus from other windows
* In general do not pass true for this. It is really only useful for some windows, like game windows where not forcing it to the front
* could cause mouse capture and mouse lock to happen but without the window visible
*/
void FLinuxWindow::BringToFront( bool bForce )
{
// TODO Forces the the window to top of z order? Only that? SDL is using XMapRaised which changes the z order
// so we do not steal focus here I guess.
if(bForce)
{
SDL_RaiseWindow(HWnd);
}
else
{
SDL_ShowWindow(HWnd);
}
}
void PlasmacoreView::configure()
{
if (isConfigured) { return; }
isConfigured = true;
pwindowID = Plasmacore::singleton.getResourceID( this );
SDL_RaiseWindow(window); // Should we immediately post a focus event? (Mac version does...)
fprintf( stderr, "PlasmacoreView %s:\n", name );
fprintf( stderr, " SDL WID %d:\n", swindowID );
fprintf( stderr, " PCore WID %d:\n", pwindowID );
}
void App::openShaderDialog() {
char *out_filepath = nullptr;
nfdresult_t result = NFD_OpenDialog("frag,glsl,fsh,txt", nullptr, &out_filepath);
SDL_RaiseWindow(sdl_window); // workaround: focus window again after dialog closes
if (result == NFD_OKAY) {
struct stat attr;
if (!stat(out_filepath, &attr)) { // file exists
shader_file_mtime = (int)attr.st_mtime;
loadShader(out_filepath);
}
free(out_filepath);
}
}
void App::saveShaderDialog() {
char *out_filepath = nullptr;
nfdresult_t result = NFD_SaveDialog("frag,glsl,fsh,txt", nullptr, &out_filepath);
SDL_RaiseWindow(sdl_window); // workaround: focus window again after dialog closes
if (result == NFD_OKAY) {
if (shader_filepath) free(shader_filepath);
shader_filepath = out_filepath;
writeStringToFile(shader_filepath, src_edit_buffer);
struct stat attr;
if (!stat(shader_filepath, &attr)) { // file exists
shader_file_mtime = 0; // force autoreload
}
}
}
void App::openShaderDialog() {
char *out_file_path = nullptr;
nfdresult_t result = NFD_OpenDialog("frag,glsl,fsh,txt", nullptr, &out_file_path);
SDL_RaiseWindow(sdl_window); // workaround: focus window again after dialog closes
if (result == NFD_OKAY) {
if (file_path) free(file_path);
file_path = out_file_path;
struct stat attr;
if (!stat(file_path, &attr)) { // file exists
file_mod_time = attr.st_mtime;
loadShader(file_path, /*initial*/true);
}
}
}
static void video_new_window(int w, int h, bool fs, bool resizable) {
uint32_t flags = SDL_WINDOW_OPENGL;
if(fs) {
flags |= get_fullscreen_flag();
} else if(resizable) {
flags |= SDL_WINDOW_RESIZABLE;
}
video_new_window_internal(w, h, flags, false);
log_info("Created a new window: %ix%i (%s)",
video.current.width,
video.current.height,
modeflagsstr(SDL_GetWindowFlags(video.window))
);
events_pause_keyrepeat();
SDL_RaiseWindow(video.window);
}
GHOST_WindowSDL::GHOST_WindowSDL(GHOST_SystemSDL *system,
const STR_String& title,
GHOST_TInt32 left,
GHOST_TInt32 top,
GHOST_TUns32 width,
GHOST_TUns32 height,
GHOST_TWindowState state,
const GHOST_TEmbedderWindowID parentWindow,
GHOST_TDrawingContextType type,
const bool stereoVisual,
const bool exclusive,
const GHOST_TUns16 numOfAASamples
)
: GHOST_Window(width, height, state, stereoVisual, exclusive, numOfAASamples),
m_system(system),
m_valid_setup(false),
m_invalid_window(false),
m_sdl_custom_cursor(NULL)
{
/* creating the window _must_ come after setting attributes */
m_sdl_win = SDL_CreateWindow(
title,
left, top,
width, height,
SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
/* now set up the rendering context. */
if (setDrawingContextType(type) == GHOST_kSuccess) {
m_valid_setup = true;
GHOST_PRINT("Created window\n");
}
if (exclusive) {
SDL_RaiseWindow(m_sdl_win);
}
setTitle(title);
}
void Runtime::debugStart(TextEditInput *editWidget, const char *file) {
char buf[OS_PATHNAME_SIZE + 1];
bool open;
int size;
if (g_debugee != -1) {
net_print(g_debugee, "l\n");
open = net_input(g_debugee, buf, sizeof(buf), "\n") > 0;
} else {
open = false;
}
if (!open) {
launchDebug(file);
pause(PAUSE_DEBUG_LAUNCH);
SDL_RaiseWindow(_window);
g_debugee = net_connect("localhost", g_debugPort);
if (g_debugee != -1) {
net_print(g_debugee, "l\n");
size = net_input(g_debugee, buf, sizeof(buf), "\n");
if (size > 0) {
int *marker = editWidget->getMarkers();
for (int i = 0; i < MAX_MARKERS; i++) {
if (marker[i] != -1) {
net_printf(g_debugee, "b %d\n", marker[i]);
}
}
editWidget->gotoLine(buf);
appLog("Debug session ready");
}
} else {
appLog("Failed to attach to debug window");
}
} else {
debugStop();
}
}
void App::openImageDialog(TextureSlot *texture_slot, bool load_cube_cross) {
char *out_filepath = nullptr;
nfdresult_t result = NFD_OpenDialog("tga,png,bmp,jpg,hdr", nullptr, &out_filepath);
SDL_RaiseWindow(sdl_window); // workaround: focus window again after dialog closes
if (result == NFD_OKAY) {
if (load_cube_cross) {
int out_size;
GLuint loaded_texture_cube = loadTextureCubeCross(out_filepath,
/*build_mipmaps*/true, &out_size);
if (loaded_texture_cube) {
texture_slot->clear();
texture_slot->target = GL_TEXTURE_CUBE_MAP;
texture_slot->texture = loaded_texture_cube;
texture_slot->image_width = out_size;
texture_slot->image_height = out_size;
texture_slot->image_filepath = out_filepath;
}
} else {
int out_width, out_height;
GLuint loaded_texture = loadTexture2D(out_filepath,
/*build_mipmaps*/true, &out_width, &out_height);
if (loaded_texture) { // loading successful
texture_slot->clear();
texture_slot->target = GL_TEXTURE_2D;
setWrapTexture2D(GL_REPEAT, GL_REPEAT);
texture_slot->texture = loaded_texture;
texture_slot->image_width = out_width;
texture_slot->image_height = out_height;
texture_slot->image_filepath = out_filepath;
}
}
}
}
static SDL_bool
WatchJoystick(SDL_Joystick * joystick)
{
SDL_Window *window = NULL;
SDL_Renderer *screen = NULL;
SDL_Texture *background, *button, *axis, *marker;
const char *name = NULL;
SDL_bool retval = SDL_FALSE;
SDL_bool done = SDL_FALSE, next=SDL_FALSE;
SDL_Event event;
SDL_Rect dst;
int s, _s;
Uint8 alpha=200, alpha_step = -1;
Uint32 alpha_ticks;
char mapping[4096], temp[4096];
MappingStep *step;
MappingStep steps[] = {
{342, 132, 0.0, MARKER_BUTTON, "x", -1, -1, -1, -1, ""},
{387, 167, 0.0, MARKER_BUTTON, "a", -1, -1, -1, -1, ""},
{431, 132, 0.0, MARKER_BUTTON, "b", -1, -1, -1, -1, ""},
{389, 101, 0.0, MARKER_BUTTON, "y", -1, -1, -1, -1, ""},
{174, 132, 0.0, MARKER_BUTTON, "back", -1, -1, -1, -1, ""},
{233, 132, 0.0, MARKER_BUTTON, "guide", -1, -1, -1, -1, ""},
{289, 132, 0.0, MARKER_BUTTON, "start", -1, -1, -1, -1, ""},
{116, 217, 0.0, MARKER_BUTTON, "dpleft", -1, -1, -1, -1, ""},
{154, 249, 0.0, MARKER_BUTTON, "dpdown", -1, -1, -1, -1, ""},
{186, 217, 0.0, MARKER_BUTTON, "dpright", -1, -1, -1, -1, ""},
{154, 188, 0.0, MARKER_BUTTON, "dpup", -1, -1, -1, -1, ""},
{77, 40, 0.0, MARKER_BUTTON, "leftshoulder", -1, -1, -1, -1, ""},
{91, 0, 0.0, MARKER_BUTTON, "lefttrigger", -1, -1, -1, -1, ""},
{396, 36, 0.0, MARKER_BUTTON, "rightshoulder", -1, -1, -1, -1, ""},
{375, 0, 0.0, MARKER_BUTTON, "righttrigger", -1, -1, -1, -1, ""},
{75, 154, 0.0, MARKER_BUTTON, "leftstick", -1, -1, -1, -1, ""},
{305, 230, 0.0, MARKER_BUTTON, "rightstick", -1, -1, -1, -1, ""},
{75, 154, 0.0, MARKER_AXIS, "leftx", -1, -1, -1, -1, ""},
{75, 154, 90.0, MARKER_AXIS, "lefty", -1, -1, -1, -1, ""},
{305, 230, 0.0, MARKER_AXIS, "rightx", -1, -1, -1, -1, ""},
{305, 230, 90.0, MARKER_AXIS, "righty", -1, -1, -1, -1, ""},
};
/* Create a window to display joystick axis position */
window = SDL_CreateWindow("Game Controller Map", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, 0);
if (window == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
background = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
button = LoadTexture(screen, "button.bmp", SDL_TRUE);
axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
SDL_RaiseWindow(window);
/* scale for platforms that don't give you the window size you asked for. */
SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
/* Print info about the joystick we are watching */
name = SDL_JoystickName(joystick);
SDL_Log("Watching joystick %d: (%s)\n", SDL_JoystickInstanceID(joystick),
name ? name : "Unknown Joystick");
SDL_Log("Joystick has %d axes, %d hats, %d balls, and %d buttons\n",
SDL_JoystickNumAxes(joystick), SDL_JoystickNumHats(joystick),
SDL_JoystickNumBalls(joystick), SDL_JoystickNumButtons(joystick));
SDL_Log("\n\n\
====================================================================================\n\
Press the buttons on your controller when indicated\n\
(Your controller may look different than the picture)\n\
If you want to correct a mistake, press backspace or the back button on your device\n\
To skip a button, press SPACE or click/touch the screen\n\
To exit, press ESC\n\
====================================================================================\n");
/* Initialize mapping with GUID and name */
SDL_JoystickGetGUIDString(SDL_JoystickGetGUID(joystick), temp, SDL_arraysize(temp));
SDL_snprintf(mapping, SDL_arraysize(mapping), "%s,%s,platform:%s,",
temp, name ? name : "Unknown Joystick", SDL_GetPlatform());
/* Loop, getting joystick events! */
for(s=0; s<SDL_arraysize(steps) && !done;) {
/* blank screen, set up for drawing this frame. */
step = &steps[s];
SDL_strlcpy(step->mapping, mapping, SDL_arraysize(step->mapping));
step->axis = -1;
step->button = -1;
step->hat = -1;
step->hat_value = -1;
SDL_SetClipboardText("TESTING TESTING 123");
switch(step->marker) {
case MARKER_AXIS:
marker = axis;
break;
case MARKER_BUTTON:
marker = button;
break;
default:
break;
}
dst.x = step->x;
dst.y = step->y;
SDL_QueryTexture(marker, NULL, NULL, &dst.w, &dst.h);
next=SDL_FALSE;
SDL_SetRenderDrawColor(screen, 0xFF, 0xFF, 0xFF, SDL_ALPHA_OPAQUE);
while (!done && !next) {
if (SDL_GetTicks() - alpha_ticks > 5) {
alpha_ticks = SDL_GetTicks();
alpha += alpha_step;
if (alpha == 255) {
alpha_step = -1;
}
if (alpha < 128) {
alpha_step = 1;
}
}
SDL_RenderClear(screen);
SDL_RenderCopy(screen, background, NULL, NULL);
SDL_SetTextureAlphaMod(marker, alpha);
SDL_SetTextureColorMod(marker, 10, 255, 21);
SDL_RenderCopyEx(screen, marker, NULL, &dst, step->angle, NULL, 0);
SDL_RenderPresent(screen);
if (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_JOYAXISMOTION:
if (event.jaxis.value > 20000 || event.jaxis.value < -20000) {
for (_s = 0; _s < s; _s++) {
if (steps[_s].axis == event.jaxis.axis) {
break;
}
}
if (_s == s) {
step->axis = event.jaxis.axis;
SDL_strlcat(mapping, step->field, SDL_arraysize(mapping));
SDL_snprintf(temp, SDL_arraysize(temp), ":a%u,", event.jaxis.axis);
SDL_strlcat(mapping, temp, SDL_arraysize(mapping));
s++;
next=SDL_TRUE;
}
}
break;
case SDL_JOYHATMOTION:
if (event.jhat.value == SDL_HAT_CENTERED) {
break; /* ignore centering, we're probably just coming back to the center from the previous item we set. */
}
for (_s = 0; _s < s; _s++) {
if (steps[_s].hat == event.jhat.hat && steps[_s].hat_value == event.jhat.value) {
break;
}
}
if (_s == s) {
step->hat = event.jhat.hat;
step->hat_value = event.jhat.value;
SDL_strlcat(mapping, step->field, SDL_arraysize(mapping));
SDL_snprintf(temp, SDL_arraysize(temp), ":h%u.%u,", event.jhat.hat, event.jhat.value );
SDL_strlcat(mapping, temp, SDL_arraysize(mapping));
s++;
next=SDL_TRUE;
}
break;
case SDL_JOYBALLMOTION:
break;
case SDL_JOYBUTTONUP:
for (_s = 0; _s < s; _s++) {
if (steps[_s].button == event.jbutton.button) {
break;
}
}
if (_s == s) {
step->button = event.jbutton.button;
SDL_strlcat(mapping, step->field, SDL_arraysize(mapping));
SDL_snprintf(temp, SDL_arraysize(temp), ":b%u,", event.jbutton.button);
SDL_strlcat(mapping, temp, SDL_arraysize(mapping));
s++;
next=SDL_TRUE;
}
break;
case SDL_FINGERDOWN:
case SDL_MOUSEBUTTONDOWN:
/* Skip this step */
s++;
next=SDL_TRUE;
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_BACKSPACE || event.key.keysym.sym == SDLK_AC_BACK) {
/* Undo! */
if (s > 0) {
SDL_strlcpy(mapping, step->mapping, SDL_arraysize(step->mapping));
s--;
next = SDL_TRUE;
}
break;
}
if (event.key.keysym.sym == SDLK_SPACE) {
/* Skip this step */
s++;
next=SDL_TRUE;
break;
}
if ((event.key.keysym.sym != SDLK_ESCAPE)) {
break;
}
/* Fall through to signal quit */
case SDL_QUIT:
done = SDL_TRUE;
break;
default:
break;
}
}
}
}
if (s == SDL_arraysize(steps) ) {
SDL_Log("Mapping:\n\n%s\n\n", mapping);
/* Print to stdout as well so the user can cat the output somewhere */
printf("%s\n", mapping);
}
while(SDL_PollEvent(&event)) {};
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return retval;
}
static SDL_bool
WatchJoystick(SDL_Joystick * joystick)
{
SDL_Window *window = NULL;
SDL_Renderer *screen = NULL;
const char *name = NULL;
SDL_bool retval = SDL_FALSE;
SDL_bool done = SDL_FALSE;
SDL_Event event;
int i;
/* Create a window to display joystick axis position */
window = SDL_CreateWindow("Joystick Test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, 0);
if (window == NULL) {
fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* Print info about the joystick we are watching */
name = SDL_JoystickName(joystick);
printf("Watching joystick %d: (%s)\n", SDL_JoystickInstanceID(joystick),
name ? name : "Unknown Joystick");
printf("Joystick has %d axes, %d hats, %d balls, and %d buttons\n",
SDL_JoystickNumAxes(joystick), SDL_JoystickNumHats(joystick),
SDL_JoystickNumBalls(joystick), SDL_JoystickNumButtons(joystick));
/* Loop, getting joystick events! */
while (!done) {
/* blank screen, set up for drawing this frame. */
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_JOYAXISMOTION:
printf("Joystick %d axis %d value: %d\n",
event.jaxis.which,
event.jaxis.axis, event.jaxis.value);
break;
case SDL_JOYHATMOTION:
printf("Joystick %d hat %d value:",
event.jhat.which, event.jhat.hat);
if (event.jhat.value == SDL_HAT_CENTERED)
printf(" centered");
if (event.jhat.value & SDL_HAT_UP)
printf(" up");
if (event.jhat.value & SDL_HAT_RIGHT)
printf(" right");
if (event.jhat.value & SDL_HAT_DOWN)
printf(" down");
if (event.jhat.value & SDL_HAT_LEFT)
printf(" left");
printf("\n");
break;
case SDL_JOYBALLMOTION:
printf("Joystick %d ball %d delta: (%d,%d)\n",
event.jball.which,
event.jball.ball, event.jball.xrel, event.jball.yrel);
break;
case SDL_JOYBUTTONDOWN:
printf("Joystick %d button %d down\n",
event.jbutton.which, event.jbutton.button);
break;
case SDL_JOYBUTTONUP:
printf("Joystick %d button %d up\n",
event.jbutton.which, event.jbutton.button);
break;
case SDL_KEYDOWN:
if ((event.key.keysym.sym != SDLK_ESCAPE) &&
(event.key.keysym.sym != SDLK_AC_BACK)) {
break;
}
/* Fall through to signal quit */
case SDL_FINGERDOWN:
case SDL_MOUSEBUTTONDOWN:
case SDL_QUIT:
done = SDL_TRUE;
break;
default:
break;
}
}
/* Update visual joystick state */
SDL_SetRenderDrawColor(screen, 0x00, 0xFF, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i < SDL_JoystickNumButtons(joystick); ++i) {
if (SDL_JoystickGetButton(joystick, i) == SDL_PRESSED) {
DrawRect(screen, (i%20) * 34, SCREEN_HEIGHT - 68 + (i/20) * 34, 32, 32);
}
}
SDL_SetRenderDrawColor(screen, 0xFF, 0x00, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i < SDL_JoystickNumAxes(joystick); ++i) {
/* Draw the X/Y axis */
int x, y;
x = (((int) SDL_JoystickGetAxis(joystick, i)) + 32768);
x *= SCREEN_WIDTH;
x /= 65535;
if (x < 0) {
x = 0;
} else if (x > (SCREEN_WIDTH - 16)) {
x = SCREEN_WIDTH - 16;
}
++i;
if (i < SDL_JoystickNumAxes(joystick)) {
y = (((int) SDL_JoystickGetAxis(joystick, i)) + 32768);
} else {
y = 32768;
}
y *= SCREEN_HEIGHT;
y /= 65535;
if (y < 0) {
y = 0;
} else if (y > (SCREEN_HEIGHT - 16)) {
y = SCREEN_HEIGHT - 16;
}
DrawRect(screen, x, y, 16, 16);
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0xFF, SDL_ALPHA_OPAQUE);
for (i = 0; i < SDL_JoystickNumHats(joystick); ++i) {
/* Derive the new position */
int x = SCREEN_WIDTH/2;
int y = SCREEN_HEIGHT/2;
const Uint8 hat_pos = SDL_JoystickGetHat(joystick, i);
if (hat_pos & SDL_HAT_UP) {
y = 0;
} else if (hat_pos & SDL_HAT_DOWN) {
y = SCREEN_HEIGHT-8;
}
if (hat_pos & SDL_HAT_LEFT) {
x = 0;
} else if (hat_pos & SDL_HAT_RIGHT) {
x = SCREEN_WIDTH-8;
}
DrawRect(screen, x, y, 8, 8);
}
SDL_RenderPresent(screen);
if (SDL_JoystickGetAttached( joystick ) == 0) {
done = SDL_TRUE;
retval = SDL_TRUE; /* keep going, wait for reattach. */
}
}
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return retval;
}
void Debugger::handle_events()
{
SDL_Event ev;
while (SDL_PollEvent(&ev))
{
//DEBUGLOG("GOTEVENT 0x%x -", ev.type);
switch(ev.type)
{
case SDL_QUIT:
BaseD::quitting = true;
break;
case SDL_WINDOWEVENT:
{
switch(ev.window.event)
{
case SDL_WINDOWEVENT_RESIZED:
{
int w = ev.window.data1;
int h = ev.window.data2;
DEBUGLOG("window resize: w = %d, h = %d\n", w, h);
/*if (w > monitor_display_mode.w)
w = monitor_display_mode.w;
if (h > monitor_display_mode.h)
h = monitor_display_mode.h;*/
int wd, hd;
//if (w > SCREEN_WIDTH)
//{
wd = w - Render_Context::w;
//}
//else
//{
// wd = SCREEN_WIDTH - height;
//}
hd = h - Render_Context::h;
if (abs(wd) < abs(hd)) wd = hd;
else if (abs(wd) > abs(hd)) hd = wd;
Render_Context::w += wd;
Render_Context::h += hd;
DEBUGLOG("\twindow resize: w = %d, h = %d\n", Render_Context::w, Render_Context::h);
//DEBUGLOG("%d - %d = %d\n", Render_Context::h, monitor_display_mode.h, Render_Context::h - monitor_display_mode.h);
if (Render_Context::w > monitor_display_mode.w)
{
int tmp_wd = Render_Context::w - monitor_display_mode.w;
Render_Context::w -= tmp_wd;
Render_Context::h -= tmp_wd;
DEBUGLOG("\t\twindow resize: tmp_wd = %d, w = %d, h = %d\n", tmp_wd, Render_Context::w, Render_Context::h);
}
if (Render_Context::h > monitor_display_mode.h)
{
int tmp_hd = Render_Context::h - monitor_display_mode.h;
Render_Context::w -= tmp_hd;
Render_Context::h -= tmp_hd;
DEBUGLOG("\t\twindow resize: tmp_hd = %d, w = %d, h = %d\n", tmp_hd, Render_Context::w, Render_Context::h);
}
SDL_SetWindowSize(sdlWindow, Render_Context::w, Render_Context::h);
DEBUGLOG("\t\t\twindow resize: w = %d, h = %d\n", Render_Context::w, Render_Context::h);
} break;
/*case SDL_WINDOWEVENT_LEAVE:
{
DEBUGLOG("Window %d Lost mouse focus\n", ev.window.windowID);
}
break;
case SDL_WINDOWEVENT_ENTER:
{
DEBUGLOG("Window %d Gained mouse focus\n", ev.window.windowID);
}
break;*/
case SDL_WINDOWEVENT_FOCUS_LOST:
{
DEBUGLOG("Window %d Lost keyboard focus\n", ev.window.windowID);
if (ev.window.windowID == Render_Context::windowID)
{
// OFF context menus
menu_bar.context_menus.deactivate_all();
}
}
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
{
DEBUGLOG("Window %d Gained keyboard focus\n", ev.window.windowID);
//SDL_GetMouseState(&mouse::x, &mouse::y);
sub_window_experience = NULL;
for (int i=0; i < NUM_WINDOWS; i++)
{
if (ev.window.windowID == window_map[i]->windowID)
{
if (window_map[i]->oktoshow)
{
DEBUGLOG("Window_map %d gained experience. :D\n", i);
sub_window_experience = (Experience *)window_map[i];
//window_map[i]->raise();
}
break;
}
}
}
break;
case SDL_WINDOWEVENT_SHOWN:
{
SDL_Log("Window %d shown", ev.window.windowID);
for (int i=0; i < NUM_WINDOWS; i++)
{
if (ev.window.windowID == window_map[i]->windowID)
{
if (!window_map[i]->oktoshow)
{
window_map[i]->hide();
/* maybe right here, instead of raising the main window, we should
have a history of displayed windows.. and the last one should be raised.
*/
sub_window_experience = NULL;
//SDL_RaiseWindow(Render_Context::sdlWindow);
}
else
{
sub_window_experience = NULL;
DEBUGLOG("Window_map %d gained experience. :D\n", i);
sub_window_experience = (Experience *)window_map[i];
window_map[i]->raise();
}
break;
}
}
}
break;
case SDL_WINDOWEVENT_CLOSE:
{
SDL_Log("Window %d closed", ev.window.windowID);
if (ev.window.windowID == Render_Context::windowID)
{
// quit app
SDL_Event quit_ev;
quit_ev.type = SDL_QUIT;
SDL_PushEvent(&quit_ev);
}
else
{
for (int i=0; i < NUM_WINDOWS; i++)
{
if (ev.window.windowID == window_map[i]->windowID)
{
window_map[i]->hide();
// maybe right here, instead of raising the main window, we should
// have a history of displayed windows.. and the last one should be raised.
sub_window_experience = NULL;
//SDL_RaiseWindow(Render_Context::sdlWindow);
break;
}
}
}
}
break;
default:break;
}
} break;
case SDL_DROPFILE:
{
char *dropped_filedir = ev.drop.file;
// Shows directory of dropped file
/*SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_INFORMATION,
"File dropped on window",
dropped_filedir,
sdlWindow
);*/
BaseD::nfd.free_pathset();
check_paths_and_reload(&dropped_filedir, 1, true);
SDL_free(dropped_filedir); // Free dropped_filedir memory
SDL_RaiseWindow(sdlWindow);
} break;
case SDL_USEREVENT:
{
if (ev.user.code == UserEvents::sound_stop)
{
sound_stop();
}
} break;
case SDL_MOUSEMOTION:
{
mouse::x = ev.motion.x;
mouse::y = ev.motion.y;
} break;
/*case SDL_MOUSEBUTTONDOWN:
DEBUGLOG("MOUSE BUTTON DOWN -");
break;
case SDL_MOUSEBUTTONUP:
DEBUGLOG("MOUSE BUTTON UP -");
break;*/
default:break;
}
if (sub_window_experience)
{
sub_window_experience->receive_event(ev);
}
else exp->receive_event(ev);
}
}
SDL_bool WatchGameController(SDL_GameController *gamecontroller) {
const char *name = SDL_GameControllerName(gamecontroller);
const char *basetitle = "Game Controller Test: ";
const size_t titlelen = SDL_strlen(basetitle) + SDL_strlen(name) + 1;
char *title = (char *)SDL_malloc(titlelen);
SDL_Window *window = NULL;
retval = SDL_FALSE;
done = SDL_FALSE;
if (title) {
SDL_snprintf(title, titlelen, "%s%s", basetitle, name);
}
/* Create a window to display controller state */
window =
SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
SCREEN_WIDTH, SCREEN_HEIGHT, 0);
if (window == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n",
SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n",
SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* scale for platforms that don't give you the window size you asked for. */
SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
background = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
button = LoadTexture(screen, "button.bmp", SDL_TRUE);
axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
if (!background || !button || !axis) {
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetTextureColorMod(button, 10, 255, 21);
SDL_SetTextureColorMod(axis, 10, 255, 21);
/* !!! FIXME: */
/*SDL_RenderSetLogicalSize(screen, background->w, background->h);*/
/* Print info about the controller we are watching */
SDL_Log("Watching controller %s\n", name ? name : "Unknown Controller");
/* Loop, getting controller events! */
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop_arg(loop, gamecontroller, 0, 1);
#else
while (!done) {
loop(gamecontroller);
}
#endif
SDL_DestroyRenderer(screen);
screen = NULL;
background = NULL;
button = NULL;
axis = NULL;
SDL_DestroyWindow(window);
return retval;
}
void window::begin_text_input_on_window(const window& window)
{
SDL_RaiseWindow(window.handle.get());
SDL_StartTextInput();
}
int graphics_SetMode(int width, int height, int fullscreen,
int resizable, const char* title, const char* renderer, char** error) {
graphics_calculateUnitToPixels(width, height);
#if defined(ANDROID)
if (!fullscreen) {
// do not use windowed on Android
*error = strdup("Windowed mode is not supported on Android");
return 0;
}
#endif
char errormsg[512];
// initialize SDL video if not done yet
if (!graphics_InitVideoSubsystem(error)) {
return 0;
}
// think about the renderer we want
#ifndef WINDOWS
#ifdef ANDROID
char preferredrenderer[20] = "opengles";
#else
char preferredrenderer[20] = "opengl";
#endif
#else
char preferredrenderer[20] = "direct3d";
#endif
int softwarerendering = 0;
if (renderer) {
if (strcasecmp(renderer, "software") == 0) {
#ifdef ANDROID
// we don't want software rendering on Android
#else
softwarerendering = 1;
strcpy(preferredrenderer, "software");
#endif
} else {
if (strcasecmp(renderer, "opengl") == 0) {
#ifdef ANDROID
// opengles is the opengl we want for android :-)
strcpy(preferredrenderer, "opengles");
#else
// regular opengl on desktop platforms
strcpy(preferredrenderer, "opengl");
#endif
}
#ifdef WINDOWS
// only windows knows direct3d obviously
if (strcasecmp(renderer,"direct3d") == 0) {
strcpy(preferredrenderer, "direct3d");
}
#endif
}
}
// get renderer index
int rendererindex = -1;
if (strlen(preferredrenderer) > 0 && !softwarerendering) {
int count = SDL_GetNumRenderDrivers();
if (count > 0) {
int r = 0;
while (r < count) {
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(r, &info);
if (strcasecmp(info.name, preferredrenderer) == 0) {
rendererindex = r;
break;
}
r++;
}
}
}
// see if anything changes at all
unsigned int oldw = 0;
unsigned int oldh = 0;
graphics_GetWindowDimensions(&oldw,&oldh);
if (mainwindow && mainrenderer &&
width == (int)oldw && height == (int)oldh) {
SDL_RendererInfo info;
SDL_GetRendererInfo(mainrenderer, &info);
if (strcasecmp(preferredrenderer, info.name) == 0) {
// same renderer and resolution
if (strcmp(SDL_GetWindowTitle(mainwindow), title) != 0) {
SDL_SetWindowTitle(mainwindow, title);
}
// toggle fullscreen if desired
if (graphics_IsFullscreen() != fullscreen) {
graphics_ToggleFullscreen();
}
return 1;
}
}
// Check if we support the video mode for fullscreen -
// This is done to avoid SDL allowing impossible modes and
// giving us a fake resized/padded/whatever output we don't want.
if (fullscreen) {
// check all video modes in the list SDL returns for us
int count = graphics_GetNumberOfVideoModes();
int i = 0;
int supportedmode = 0;
while (i < count) {
int w,h;
graphics_GetVideoMode(i, &w, &h);
if (w == width && h == height) {
supportedmode = 1;
break;
}
i++;
}
if (!supportedmode) {
// check for desktop video mode aswell
int w,h;
graphics_GetDesktopVideoMode(&w,&h);
if (w == 0 || h == 0 || width != w || height != h) {
*error = strdup("Video mode is not supported");
return 0;
}
}
}
// notify texture manager of device shutdown
texturemanager_deviceLost();
// destroy old window/renderer if we got one
graphics_Close(1);
// create window
if (fullscreen) {
mainwindow = SDL_CreateWindow(title, 0, 0, width, height,
SDL_WINDOW_FULLSCREEN);
mainwindowfullscreen = 1;
} else {
mainwindow = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_MINIMIZED);
mainwindowfullscreen = 0;
}
if (!mainwindow) {
snprintf(errormsg, sizeof(errormsg),
"Failed to open SDL window: %s", SDL_GetError());
errormsg[sizeof(errormsg)-1] = 0;
*error = strdup(errormsg);
return 0;
}
// see if we actually ended up with the resolution we wanted:
int actualwidth, actualheight;
SDL_GetWindowSize(mainwindow, &actualwidth, &actualheight);
if (actualwidth != width || actualheight != height) {
if (fullscreen) { // we failed to get the requested resolution:
SDL_DestroyWindow(mainwindow);
snprintf(errormsg, sizeof(errormsg), "Failed to open "
"SDL window: ended up with other resolution than requested");
*error = strdup(errormsg);
return 0;
}
}
// Create renderer
if (!softwarerendering) {
mainrenderer = SDL_CreateRenderer(mainwindow, rendererindex,
SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC);
if (!mainrenderer) {
softwarerendering = 1;
strcpy(preferredrenderer, "software");
}
}
if (softwarerendering) {
mainrenderer = SDL_CreateRenderer(mainwindow, -1,
SDL_RENDERER_SOFTWARE);
}
if (!mainrenderer) {
// we failed to create the renderer
if (mainwindow) {
// destroy window aswell in case it is open
SDL_DestroyWindow(mainwindow);
mainwindow = NULL;
}
if (softwarerendering) {
snprintf(errormsg, sizeof(errormsg),
"Failed to create SDL renderer (backend software): %s",
SDL_GetError());
} else {
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(rendererindex, &info);
snprintf(errormsg, sizeof(errormsg),
"Failed to create SDL renderer (backend %s): %s",
info.name, SDL_GetError());
}
errormsg[sizeof(errormsg)-1] = 0;
*error = strdup(errormsg);
return 0;
} else {
SDL_RendererInfo info;
SDL_GetRendererInfo(mainrenderer, &info);
}
// notify texture manager that device is back
texturemanager_deviceRestored();
// Transfer textures back to SDL
/*if (!graphicstexturelist_TransferTexturesToHW()) {
SDL_RendererInfo info;
SDL_GetRendererInfo(mainrenderer, &info);
snprintf(errormsg, sizeof(errormsg),
"Failed to create SDL renderer (backend %s): "
"Cannot recreate textures", info.name);
*error = strdup(errormsg);
SDL_DestroyRenderer(mainrenderer);
SDL_DestroyWindow(mainwindow);
return 0;
}*/
// Re-focus window if previously focussed
if (!inbackground) {
SDL_RaiseWindow(mainwindow);
}
graphicsactive = 1;
return 1;
}
SDL_bool
WatchGameController(SDL_GameController * gamecontroller)
{
/* This is indexed by SDL_GameControllerButton. */
static const struct { int x; int y; } button_positions[] = {
{387, 167}, /* A */
{431, 132}, /* B */
{342, 132}, /* X */
{389, 101}, /* Y */
{174, 132}, /* BACK */
{233, 132}, /* GUIDE */
{289, 132}, /* START */
{75, 154}, /* LEFTSTICK */
{305, 230}, /* RIGHTSTICK */
{77, 40}, /* LEFTSHOULDER */
{396, 36}, /* RIGHTSHOULDER */
{154, 188}, /* DPAD_UP */
{154, 249}, /* DPAD_DOWN */
{116, 217}, /* DPAD_LEFT */
{186, 217}, /* DPAD_RIGHT */
};
/* This is indexed by SDL_GameControllerAxis. */
static const struct { int x; int y; double angle; } axis_positions[] = {
{75, 154, 0.0}, /* LEFTX */
{75, 154, 90.0}, /* LEFTY */
{305, 230, 0.0}, /* RIGHTX */
{305, 230, 90.0}, /* RIGHTY */
{91, 0, 90.0}, /* TRIGGERLEFT */
{375, 0, 90.0}, /* TRIGGERRIGHT */
};
const char *name = SDL_GameControllerName(gamecontroller);
const char *basetitle = "Game Controller Test: ";
const size_t titlelen = SDL_strlen(basetitle) + SDL_strlen(name) + 1;
char *title = (char *)SDL_malloc(titlelen);
SDL_Texture *background, *button, *axis;
SDL_Window *window = NULL;
SDL_Renderer *screen = NULL;
SDL_bool retval = SDL_FALSE;
SDL_bool done = SDL_FALSE;
SDL_Event event;
int i;
if (title) {
SDL_snprintf(title, titlelen, "%s%s", basetitle, name);
}
/* Create a window to display controller state */
window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, 0);
if (window == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* scale for platforms that don't give you the window size you asked for. */
SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
background = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
button = LoadTexture(screen, "button.bmp", SDL_TRUE);
axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
if (!background || !button || !axis) {
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetTextureColorMod(button, 10, 255, 21);
SDL_SetTextureColorMod(axis, 10, 255, 21);
/* !!! FIXME: */
/*SDL_RenderSetLogicalSize(screen, background->w, background->h);*/
/* Print info about the controller we are watching */
SDL_Log("Watching controller %s\n", name ? name : "Unknown Controller");
/* Loop, getting controller events! */
while (!done) {
/* blank screen, set up for drawing this frame. */
SDL_SetRenderDrawColor(screen, 0xFF, 0xFF, 0xFF, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderCopy(screen, background, NULL, NULL);
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
if (event.key.keysym.sym != SDLK_ESCAPE) {
break;
}
/* Fall through to signal quit */
case SDL_QUIT:
done = SDL_TRUE;
break;
default:
break;
}
}
/* Update visual controller state */
for (i = 0; i < SDL_CONTROLLER_BUTTON_MAX; ++i) {
if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
const SDL_Rect dst = { button_positions[i].x, button_positions[i].y, 50, 50 };
SDL_RenderCopyEx(screen, button, NULL, &dst, 0, NULL, 0);
}
}
for (i = 0; i < SDL_CONTROLLER_AXIS_MAX; ++i) {
const Sint16 deadzone = 8000; /* !!! FIXME: real deadzone */
const Sint16 value = SDL_GameControllerGetAxis(gamecontroller, (SDL_GameControllerAxis)(i));
if (value < -deadzone) {
const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
const double angle = axis_positions[i].angle;
SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, 0);
} else if (value > deadzone) {
const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
const double angle = axis_positions[i].angle + 180.0;
SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, 0);
}
}
SDL_RenderPresent(screen);
if (!SDL_GameControllerGetAttached(gamecontroller)) {
done = SDL_TRUE;
retval = SDL_TRUE; /* keep going, wait for reattach. */
}
}
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return retval;
}
static int display(struct vidisp_st *st, const char *title,
const struct vidframe *frame)
{
void *pixels;
uint8_t *p;
int pitch, ret;
unsigned i, h;
if (!vidsz_cmp(&st->size, &frame->size)) {
if (st->size.w && st->size.h) {
info("sdl: reset size: %u x %u ---> %u x %u\n",
st->size.w, st->size.h,
frame->size.w, frame->size.h);
}
sdl_reset(st);
}
if (!st->window) {
Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_INPUT_FOCUS;
char capt[256];
if (st->fullscreen)
flags |= SDL_WINDOW_FULLSCREEN;
if (title) {
re_snprintf(capt, sizeof(capt), "%s - %u x %u",
title, frame->size.w, frame->size.h);
}
else {
re_snprintf(capt, sizeof(capt), "%u x %u",
frame->size.w, frame->size.h);
}
st->window = SDL_CreateWindow(capt,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
frame->size.w, frame->size.h,
flags);
if (!st->window) {
warning("sdl: unable to create sdl window: %s\n",
SDL_GetError());
return ENODEV;
}
st->size = frame->size;
SDL_RaiseWindow(st->window);
SDL_SetWindowBordered(st->window, true);
SDL_ShowWindow(st->window);
}
if (!st->renderer) {
Uint32 flags = 0;
flags |= SDL_RENDERER_ACCELERATED;
flags |= SDL_RENDERER_PRESENTVSYNC;
st->renderer = SDL_CreateRenderer(st->window, -1, flags);
if (!st->renderer) {
warning("sdl: unable to create renderer: %s\n",
SDL_GetError());
return ENOMEM;
}
}
if (!st->texture) {
st->texture = SDL_CreateTexture(st->renderer,
SDL_PIXELFORMAT_IYUV,
SDL_TEXTUREACCESS_STREAMING,
frame->size.w, frame->size.h);
if (!st->texture) {
warning("sdl: unable to create texture: %s\n",
SDL_GetError());
return ENODEV;
}
}
ret = SDL_LockTexture(st->texture, NULL, &pixels, &pitch);
if (ret != 0) {
warning("sdl: unable to lock texture (ret=%d)\n", ret);
return ENODEV;
}
p = pixels;
for (i=0; i<3; i++) {
const uint8_t *s = frame->data[i];
const unsigned stp = frame->linesize[0] / frame->linesize[i];
const unsigned sz = frame->size.w / stp;
for (h = 0; h < frame->size.h; h += stp) {
memcpy(p, s, sz);
s += frame->linesize[i];
p += (pitch / stp);
}
}
SDL_UnlockTexture(st->texture);
/* Blit the sprite onto the screen */
SDL_RenderCopy(st->renderer, st->texture, NULL, NULL);
/* Update the screen! */
SDL_RenderPresent(st->renderer);
return 0;
}
void GraphicsWindowSDL2::raiseWindow()
{
SDL_RaiseWindow(mWindow);
}
static void SDL_change_mode(int x_res, int y_res, int w_x_res, int w_y_res)
{
Uint32 flags;
assert(pthread_equal(pthread_self(), dosemu_pthread_self));
v_printf("SDL: using mode %dx%d %dx%d %d\n", x_res, y_res, w_x_res,
w_y_res, SDL_csd.bits);
if (surface) {
SDL_FreeSurface(surface);
SDL_DestroyTexture(texture_buf);
}
if (x_res > 0 && y_res > 0) {
texture_buf = SDL_CreateTexture(renderer,
pixel_format,
SDL_TEXTUREACCESS_STREAMING,
x_res, y_res);
if (!texture_buf) {
error("SDL target texture failed: %s\n", SDL_GetError());
leavedos(99);
}
surface = SDL_CreateRGBSurface(0, x_res, y_res, SDL_csd.bits,
SDL_csd.r_mask, SDL_csd.g_mask, SDL_csd.b_mask, 0);
if (!surface) {
error("SDL surface failed: %s\n", SDL_GetError());
leavedos(99);
}
} else {
surface = NULL;
texture_buf = NULL;
}
if (config.X_fixed_aspect)
SDL_RenderSetLogicalSize(renderer, w_x_res, w_y_res);
flags = SDL_GetWindowFlags(window);
if (!(flags & SDL_WINDOW_MAXIMIZED))
SDL_SetWindowSize(window, w_x_res, w_y_res);
set_resizable(use_bitmap_font
|| vga.mode_class == GRAPH, w_x_res, w_y_res);
if (!initialized) {
initialized = 1;
SDL_ShowWindow(window);
SDL_RaiseWindow(window);
m_cursor_visible = 1;
if (config.X_fullscreen)
render_gain_focus();
}
SDL_RenderClear(renderer);
SDL_RenderPresent(renderer);
if (texture_buf) {
SDL_SetRenderTarget(renderer, texture_buf);
SDL_RenderClear(renderer);
}
m_x_res = w_x_res;
m_y_res = w_y_res;
win_width = x_res;
win_height = y_res;
/* forget about those rectangles */
sdl_rects_num = 0;
update_mouse_coords();
}
void Window::focus() const {
SDL_RaiseWindow(_wnd);
}
void
WatchGameController(SDL_GameController * gamecontroller)
{
SDL_Window *window = NULL;
SDL_Renderer *screen = NULL;
const char *name = NULL;
int done = 0;
SDL_Event event;
int i;
/* Create a window to display controller axis position */
window = SDL_CreateWindow("Game Controller Test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (window == NULL) {
fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError());
return;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* Print info about the controller we are watching */
name = SDL_GameControllerName(gamecontroller);
printf("Watching controller %s\n", name ? name : "Unknown Controller");
/* Loop, getting controller events! */
while (!done) {
/* blank screen, set up for drawing this frame. */
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_CONTROLLERAXISMOTION:
printf("Controller %d axis %d value: %d\n",
event.caxis.which,
event.caxis.axis, event.caxis.value);
break;
case SDL_CONTROLLERBUTTONDOWN:
printf("Controller %d button %d down\n",
event.cbutton.which, event.cbutton.button);
break;
case SDL_CONTROLLERBUTTONUP:
printf("Controller %d button %d up\n",
event.cbutton.which, event.cbutton.button);
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym != SDLK_ESCAPE) {
break;
}
/* Fall through to signal quit */
case SDL_QUIT:
done = 1;
s_ForceQuit = SDL_TRUE;
break;
default:
break;
}
}
/* Update visual controller state */
SDL_SetRenderDrawColor(screen, 0x00, 0xFF, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i <SDL_CONTROLLER_BUTTON_MAX; ++i) {
if (SDL_GameControllerGetButton(gamecontroller, i) == SDL_PRESSED) {
DrawRect(screen, i * 34, SCREEN_HEIGHT - 34, 32, 32);
}
}
SDL_SetRenderDrawColor(screen, 0xFF, 0x00, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i < SDL_CONTROLLER_AXIS_MAX / 2; ++i) {
/* Draw the X/Y axis */
int x, y;
x = (((int) SDL_GameControllerGetAxis(gamecontroller, i * 2 + 0)) + 32768);
x *= SCREEN_WIDTH;
x /= 65535;
if (x < 0) {
x = 0;
} else if (x > (SCREEN_WIDTH - 16)) {
x = SCREEN_WIDTH - 16;
}
y = (((int) SDL_GameControllerGetAxis(gamecontroller, i * 2 + 1)) + 32768);
y *= SCREEN_HEIGHT;
y /= 65535;
if (y < 0) {
y = 0;
} else if (y > (SCREEN_HEIGHT - 16)) {
y = SCREEN_HEIGHT - 16;
}
DrawRect(screen, x, y, 16, 16);
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0xFF, SDL_ALPHA_OPAQUE);
SDL_RenderPresent(screen);
if ( !done )
done = SDL_GameControllerGetAttached( gamecontroller ) == 0;
}
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
}
void SDLWindow::Focus () {
SDL_RaiseWindow (sdlWindow);
}
/**
* @brief Set Current Window to Focus
*/
void WindowManager::grabWindow()
{
SDL_RaiseWindow(m_window);
}
