static PyObject* _sdl_wmgetcaption (PyObject *self) { char *title, *icon; ASSERT_VIDEO_SURFACE_SET(NULL); SDL_WM_GetCaption (&title, &icon); return Py_BuildValue ("(ss)", title, icon); }
/** * Resets the screen surfaces based on the current display options, * as they don't automatically take effect. * @param resetVideo Reset display surface. */ void Screen::resetDisplay(bool resetVideo) { int width = Options::displayWidth; int height = Options::displayHeight; #ifdef __linux__ Uint32 oldFlags = _flags; #endif makeVideoFlags(); if (!_surface || (_surface && (_surface->getSurface()->format->BitsPerPixel != _bpp || _surface->getSurface()->w != _baseWidth || _surface->getSurface()->h != _baseHeight))) // don't reallocate _surface if not necessary, it's a waste of CPU cycles { if (_surface) delete _surface; _surface = new Surface(_baseWidth, _baseHeight, 0, 0, Screen::is32bitEnabled() ? 32 : 8); // only HQX needs 32bpp for this surface; the OpenGL class has its own 32bpp buffer if (_surface->getSurface()->format->BitsPerPixel == 8) _surface->setPalette(deferredPalette); } SDL_SetColorKey(_surface->getSurface(), 0, 0); // turn off color key! if (resetVideo || _screen->format->BitsPerPixel != _bpp) { #ifdef __linux__ // Workaround for segfault when switching to opengl if (!(oldFlags & SDL_OPENGL) && (_flags & SDL_OPENGL)) { Uint8 cursor = 0; char *_oldtitle = 0; SDL_WM_GetCaption(&_oldtitle, NULL); std::string title(_oldtitle); SDL_QuitSubSystem(SDL_INIT_VIDEO); SDL_InitSubSystem(SDL_INIT_VIDEO); SDL_ShowCursor(SDL_ENABLE); SDL_EnableUNICODE(1); SDL_WM_SetCaption(title.c_str(), 0); SDL_SetCursor(SDL_CreateCursor(&cursor, &cursor, 1,1,0,0)); } #endif Log(LOG_INFO) << "Attempting to set display to " << width << "x" << height << "x" << _bpp << "..."; _screen = SDL_SetVideoMode(width, height, _bpp, _flags); if (_screen == 0) { Log(LOG_ERROR) << SDL_GetError(); Log(LOG_INFO) << "Attempting to set display to default resolution..."; _screen = SDL_SetVideoMode(640, 400, _bpp, _flags); if (_screen == 0) { throw Exception(SDL_GetError()); } } Log(LOG_INFO) << "Display set to " << getWidth() << "x" << getHeight() << "x" << (int)_screen->format->BitsPerPixel << "."; } else { clear(); } Options::displayWidth = getWidth(); Options::displayHeight = getHeight(); _scaleX = getWidth() / (double)_baseWidth; _scaleY = getHeight() / (double)_baseHeight; _clear.x = 0; _clear.y = 0; _clear.w = getWidth(); _clear.h = getHeight(); double pixelRatioY = 1.0; if (Options::nonSquarePixelRatio && !Options::allowResize) { pixelRatioY = 1.2; } bool cursorInBlackBands; if (!Options::keepAspectRatio) { cursorInBlackBands = false; } else if (Options::fullscreen) { cursorInBlackBands = Options::cursorInBlackBandsInFullscreen; } else if (!Options::borderless) { cursorInBlackBands = Options::cursorInBlackBandsInWindow; } else { cursorInBlackBands = Options::cursorInBlackBandsInBorderlessWindow; } if (_scaleX > _scaleY && Options::keepAspectRatio) { int targetWidth = (int)floor(_scaleY * (double)_baseWidth); _topBlackBand = _bottomBlackBand = 0; _leftBlackBand = (getWidth() - targetWidth) / 2; if (_leftBlackBand < 0) { _leftBlackBand = 0; } _rightBlackBand = getWidth() - targetWidth - _leftBlackBand; _cursorTopBlackBand = 0; if (cursorInBlackBands) { _scaleX = _scaleY; _cursorLeftBlackBand = _leftBlackBand; } else { _cursorLeftBlackBand = 0; } } else if (_scaleY > _scaleX && Options::keepAspectRatio) { int targetHeight = (int)floor(_scaleX * (double)_baseHeight * pixelRatioY); _topBlackBand = (getHeight() - targetHeight) / 2; if (_topBlackBand < 0) { _topBlackBand = 0; } _bottomBlackBand = getHeight() - targetHeight - _topBlackBand; if (_bottomBlackBand < 0) { _bottomBlackBand = 0; } _leftBlackBand = _rightBlackBand = 0; _cursorLeftBlackBand = 0; if (cursorInBlackBands) { _scaleY = _scaleX; _cursorTopBlackBand = _topBlackBand; } else { _cursorTopBlackBand = 0; } } else { _topBlackBand = _bottomBlackBand = _leftBlackBand = _rightBlackBand = _cursorTopBlackBand = _cursorLeftBlackBand = 0; } if (isOpenGLEnabled()) { #ifndef __NO_OPENGL glOutput.init(_baseWidth, _baseHeight); glOutput.linear = Options::useOpenGLSmoothing; // setting from shader file will override this, though glOutput.set_shader(FileMap::getFilePath(Options::useOpenGLShader).c_str()); glOutput.setVSync(Options::vSyncForOpenGL); OpenGL::checkErrors = Options::checkOpenGLErrors; #endif } if (_screen->format->BitsPerPixel == 8) { setPalette(getPalette()); } }
char* graphics_viewport_title() { SDL_WM_GetCaption((char**)&main_title, (char**)&icon_title); return main_title; }
static int PULSE_OpenAudio(_THIS, SDL_AudioSpec *spec) { int state; Uint16 test_format; pa_sample_spec paspec; pa_buffer_attr paattr; pa_channel_map pacmap; pa_stream_flags_t flags = 0; paspec.format = PA_SAMPLE_INVALID; for ( test_format = SDL_FirstAudioFormat(spec->format); test_format; ) { switch ( test_format ) { case AUDIO_U8: paspec.format = PA_SAMPLE_U8; break; case AUDIO_S16LSB: paspec.format = PA_SAMPLE_S16LE; break; case AUDIO_S16MSB: paspec.format = PA_SAMPLE_S16BE; break; } if ( paspec.format != PA_SAMPLE_INVALID ) break; test_format = SDL_NextAudioFormat(); } if (paspec.format == PA_SAMPLE_INVALID ) { SDL_SetError("Couldn't find any suitable audio formats"); return(-1); } spec->format = test_format; paspec.channels = spec->channels; paspec.rate = spec->freq; #ifdef PA_STREAM_ADJUST_LATENCY spec->samples /= 2; #endif SDL_CalculateAudioSpec(spec); mixlen = spec->size; mixbuf = (Uint8 *)SDL_AllocAudioMem(mixlen); if ( mixbuf == NULL ) { return(-1); } SDL_memset(mixbuf, spec->silence, spec->size); #ifdef PA_STREAM_ADJUST_LATENCY paattr.tlength = mixlen * 4; paattr.prebuf = -1; paattr.maxlength = -1; paattr.minreq = mixlen; flags = PA_STREAM_ADJUST_LATENCY; #else paattr.tlength = mixlen*2; paattr.prebuf = mixlen*2; paattr.maxlength = mixlen*2; paattr.minreq = mixlen; #endif SDL_NAME(pa_channel_map_init_auto)( &pacmap, spec->channels, PA_CHANNEL_MAP_WAVEEX); if (!(mainloop = SDL_NAME(pa_mainloop_new)())) { PULSE_CloseAudio(this); SDL_SetError("pa_mainloop_new() failed"); return(-1); } if (this->hidden->caption == NULL) { char *title = NULL; SDL_WM_GetCaption(&title, NULL); PULSE_SetCaption(this, title); } mainloop_api = SDL_NAME(pa_mainloop_get_api)(mainloop); if (!(context = SDL_NAME(pa_context_new)(mainloop_api, this->hidden->caption))) { PULSE_CloseAudio(this); SDL_SetError("pa_context_new() failed"); return(-1); } if (SDL_NAME(pa_context_connect)(context, NULL, 0, NULL) < 0) { PULSE_CloseAudio(this); SDL_SetError("Could not setup connection to PulseAudio"); return(-1); } do { if (SDL_NAME(pa_mainloop_iterate)(mainloop, 1, NULL) < 0) { PULSE_CloseAudio(this); SDL_SetError("pa_mainloop_iterate() failed"); return(-1); } state = SDL_NAME(pa_context_get_state)(context); if (!PA_CONTEXT_IS_GOOD(state)) { PULSE_CloseAudio(this); SDL_SetError("Could not connect to PulseAudio"); return(-1); } } while (state != PA_CONTEXT_READY); stream = SDL_NAME(pa_stream_new)( context, "Simple DirectMedia Layer", &paspec, &pacmap ); if ( stream == NULL ) { PULSE_CloseAudio(this); SDL_SetError("Could not setup PulseAudio stream"); return(-1); } if (SDL_NAME(pa_stream_connect_playback)(stream, NULL, &paattr, flags, NULL, NULL) < 0) { PULSE_CloseAudio(this); SDL_SetError("Could not connect PulseAudio stream"); return(-1); } do { if (SDL_NAME(pa_mainloop_iterate)(mainloop, 1, NULL) < 0) { PULSE_CloseAudio(this); SDL_SetError("pa_mainloop_iterate() failed"); return(-1); } state = SDL_NAME(pa_stream_get_state)(stream); if (!PA_STREAM_IS_GOOD(state)) { PULSE_CloseAudio(this); SDL_SetError("Could not create to PulseAudio stream"); return(-1); } } while (state != PA_STREAM_READY); return(0); }
static SDL_Surface *ROM_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags) { Rect wrect, orect; #if TARGET_API_MAC_CARBON Rect tmprect; #endif /* Free any previous video mode */ ROM_UnsetVideoMode(this, current); /* Create the ROM window and SDL video surface */ current->flags = 0; /* Clear flags */ current->w = width; current->h = height; SetRect(&wrect, 0, 0, width, height); if ( SDL_Window ) { /* If we recreate the window, don't move it around */ #if TARGET_API_MAC_CARBON orect = *GetWindowPortBounds(SDL_Window, &tmprect); #else orect = SDL_Window->portRect; #endif OffsetRect(&wrect, orect.left, orect.top); } else { /* Center the window the first time we show it */ OffsetRect(&wrect, (SDL_modelist[0]->w-width)/2, (SDL_modelist[0]->h-height)/2); } #if defined(__MACOSX__) && !USE_QUICKTIME /* Hum.. fullscreen mode is broken */ flags &= ~SDL_FULLSCREEN; #endif if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { /* Create the fullscreen window and use screen bits */ current->flags |= SDL_HWSURFACE|SDL_FULLSCREEN; if ( SDL_Window ) { DisposeWindow(SDL_Window); } #if USE_QUICKTIME BeginFullScreen(&fullscreen_ctx, nil, 0,0, &SDL_Window, nil, 0); #else SDL_Window = NewCWindow(nil, &wrect, "\p", true, plainDBox, (WindowPtr)-1, false, 0); ROM_HideMenuBar(this); #endif current->pitch = (**(**SDL_Display).gdPMap).rowBytes & 0x3FFF; current->pixels = (**(**SDL_Display).gdPMap).baseAddr; this->UpdateRects = ROM_DirectUpdate; } else { GWorldPtr memworld; PixMapHandle pixmap; int style; style = noGrowDocProc; if ( flags & SDL_NOFRAME ) { style = plainDBox; current->flags |= SDL_NOFRAME; } else if ( flags & SDL_RESIZABLE ) { style = zoomDocProc; current->flags |= SDL_RESIZABLE; } if ( SDL_Window && (style == current_style) ) { /* Resize existing window, if necessary */ if ( ((orect.right-orect.left) != width) || ((orect.bottom-orect.top) != height) ) { SizeWindow(SDL_Window, width, height, false); } } else { /* Recreate the window in the new style */ if ( SDL_Window ) { DisposeWindow(SDL_Window); } SDL_Window = NewCWindow(nil, &wrect, "\p", true, style, (WindowPtr)-1, true, 0); /* Set the window title, if any */ { char *title; SDL_WM_GetCaption(&title, NULL); if ( title ) { Mac_SetCaption(this, title, NULL); } } } current_style = style; SetPalette(SDL_Window, SDL_CPal, false); ActivatePalette(SDL_Window); if ( NewGWorld(&memworld, 0, #if TARGET_API_MAC_CARBON GetWindowPortBounds(SDL_Window, &tmprect), #else &SDL_Window->portRect, #endif SDL_CTab, nil, 0) != noErr ) { SDL_SetError("NewGWorld() failed"); return(NULL); } SetWRefCon(SDL_Window, (long)memworld); pixmap = GetGWorldPixMap(memworld); LockPixels(pixmap); current->pitch = (**pixmap).rowBytes & 0x3FFF; current->pixels = GetPixBaseAddr(pixmap); this->UpdateRects = ROM_WindowUpdate; } SetPortWindowPort(SDL_Window); SelectWindow(SDL_Window); /* Handle OpenGL support */ if ( flags & SDL_OPENGL ) { if ( Mac_GL_Init(this) == 0 ) { current->flags |= SDL_OPENGL; } else { current = NULL; } } if ( (flags & SDL_HWPALETTE) && (flags & SDL_FULLSCREEN) ) current->flags |= SDL_HWPALETTE; /* We're live! */ return(current); }
/*! returns the window caption */ char* engine::get_caption() { char* caption; SDL_WM_GetCaption(&caption, NULL); return caption; }
string Window::getText() { char* c = 0; SDL_WM_GetCaption(&c, 0); return string(c); }
static int l_surface_new(lua_State *L) { lua_remove(L, 1); // Value inserted by __call THRenderTargetCreationParams oParams; oParams.iWidth = luaL_checkint(L, 1); oParams.iHeight = luaL_checkint(L, 2); int iArg = 3; if(lua_type(L, iArg) == LUA_TNUMBER) oParams.iBPP = luaL_checkint(L, iArg++); else oParams.iBPP = 0; oParams.iSDLFlags = 0; oParams.bHardware = false; oParams.bDoubleBuffered = false; oParams.bFullscreen = false; oParams.bPresentImmediate = false; oParams.bReuseContext = false; oParams.bOpenGL = false; #define FLAG(name, field, flag) \ else if(stricmp(sOption, name) == 0) \ oParams.field = true, oParams.iSDLFlags |= flag for(int iArgCount = lua_gettop(L); iArg <= iArgCount; ++iArg) { const char* sOption = luaL_checkstring(L, iArg); if(sOption[0] == 0) continue; FLAG("hardware" , bHardware , SDL_HWSURFACE ); FLAG("doublebuf" , bDoubleBuffered , SDL_DOUBLEBUF ); FLAG("fullscreen" , bFullscreen , SDL_FULLSCREEN); FLAG("present immediate", bPresentImmediate, 0 ); FLAG("reuse context" , bReuseContext , 0 ); FLAG("opengl" , bOpenGL , SDL_OPENGL ); } #undef FLAG #ifndef CORSIX_TH_USE_DX9_RENDERER if(SDL_WasInit(SDL_INIT_VIDEO)) { char *sTitle, *sIcon; char *sTitle2 = NULL, *sIcon2 = NULL; size_t iLen; SDL_WM_GetCaption(&sTitle, &sIcon); if(sTitle) { iLen = strlen(sTitle) + 1; sTitle2 = (char*)malloc(iLen); memcpy(sTitle2, sTitle, iLen); } if(sIcon) { iLen = strlen(sIcon) + 1; sIcon2 = (char*)malloc(iLen); memcpy(sIcon2, sIcon, iLen); } SDL_QuitSubSystem(SDL_INIT_VIDEO); SDL_InitSubSystem(SDL_INIT_VIDEO); SDL_WM_SetCaption(sTitle2, sIcon2); free(sTitle2); free(sIcon2); } #endif THRenderTarget* pCanvas = luaT_stdnew<THRenderTarget>(L); if(pCanvas->create(&oParams)) return 1; lua_pushnil(L); lua_pushstring(L, pCanvas->getLastError()); return 2; }