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;
}
