7bb53f3bf1
get at least 640x400 window. And finally we have means of implementing nice looking GUI. Also updated all backends. If your backend has ability to run with 640x400 or 640x480 resolution then read patch tracker item to find out details. Other port maintainers shouldn't worry, as this patch doesn't affect them, they still get their 320x200. svn-id: r17055
407 lines
9.9 KiB
C++
407 lines
9.9 KiB
C++
/* ScummVM - Scumm Interpreter
|
|
* Copyright (C) 2001 Ludvig Strigeus
|
|
* Copyright (C) 2001-2005 The ScummVM project
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* $Header$
|
|
*
|
|
*/
|
|
|
|
#include "backends/sdl/sdl-common.h"
|
|
#include "common/config-manager.h"
|
|
#include "common/util.h"
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "scummvm.xpm"
|
|
|
|
|
|
OSystem *OSystem_SDL_create() {
|
|
return new OSystem_SDL();
|
|
}
|
|
|
|
void OSystem_SDL::initIntern() {
|
|
|
|
int joystick_num = ConfMan.getInt("joystick_num");
|
|
uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
|
|
|
|
#ifdef _WIN32_WCE
|
|
if (ConfMan.hasKey("use_GDI") && ConfMan.getBool("use_GDI")) {
|
|
SDL_VideoInit("windib", 0);
|
|
sdlFlags ^= SDL_INIT_VIDEO;
|
|
}
|
|
#endif
|
|
|
|
if (joystick_num > -1)
|
|
sdlFlags |= SDL_INIT_JOYSTICK;
|
|
|
|
if (SDL_Init(sdlFlags) == -1) {
|
|
error("Could not initialize SDL: %s", SDL_GetError());
|
|
}
|
|
|
|
_graphicsMutex = createMutex();
|
|
|
|
SDL_ShowCursor(SDL_DISABLE);
|
|
|
|
// Enable unicode support if possible
|
|
SDL_EnableUNICODE(1);
|
|
|
|
_cksumValid = false;
|
|
#ifndef _WIN32_WCE
|
|
_mode = GFX_DOUBLESIZE;
|
|
_scaleFactor = 2;
|
|
_scalerProc = Normal2x;
|
|
_fullscreen = ConfMan.getBool("fullscreen");
|
|
_adjustAspectRatio = ConfMan.getBool("aspect_ratio");
|
|
#else
|
|
_mode = GFX_NORMAL;
|
|
_scaleFactor = 1;
|
|
_scalerProc = Normal1x;
|
|
_fullscreen = true;
|
|
_adjustAspectRatio = false;
|
|
#endif
|
|
_scalerType = 0;
|
|
_modeFlags = 0;
|
|
|
|
|
|
#ifndef MACOSX // Don't set icon on OS X, as we use a nicer external icon there
|
|
// Setup the icon
|
|
setupIcon();
|
|
#endif
|
|
|
|
// enable joystick
|
|
if (joystick_num > -1 && SDL_NumJoysticks() > 0) {
|
|
printf("Using joystick: %s\n", SDL_JoystickName(0));
|
|
_joystick = SDL_JoystickOpen(joystick_num);
|
|
}
|
|
}
|
|
|
|
OSystem_SDL::OSystem_SDL()
|
|
:
|
|
#ifdef USE_OSD
|
|
_osdSurface(0), _osdAlpha(SDL_ALPHA_TRANSPARENT), _osdFadeStartTime(0),
|
|
#endif
|
|
_hwscreen(0), _screen(0), _screenWidth(0), _screenHeight(0),
|
|
_tmpscreen(0), _overlayVisible(false), _overlayScale(1),
|
|
_overlayscreen(0), _tmpscreen2(0),
|
|
_samplesPerSec(0),
|
|
_cdrom(0), _scalerProc(0), _modeChanged(false), _dirtyChecksums(0),
|
|
_mouseVisible(false), _mouseDrawn(false), _mouseData(0), _mouseSurface(0),
|
|
_mouseOrigSurface(0), _mouseHotspotX(0), _mouseHotspotY(0), _cursorTargetScale(1),
|
|
_cursorHasOwnPalette(false), _cursorPaletteDisabled(true),
|
|
_joystick(0),
|
|
_currentShakePos(0), _newShakePos(0),
|
|
_paletteDirtyStart(0), _paletteDirtyEnd(0),
|
|
_graphicsMutex(0), _transactionMode(kTransactionNone) {
|
|
|
|
// allocate palette storage
|
|
_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
|
|
_cursorPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
|
|
|
|
_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
|
|
|
|
// reset mouse state
|
|
memset(&_km, 0, sizeof(_km));
|
|
memset(&_mouseCurState, 0, sizeof(_mouseCurState));
|
|
|
|
initIntern();
|
|
}
|
|
|
|
OSystem_SDL::~OSystem_SDL() {
|
|
free(_dirtyChecksums);
|
|
free(_currentPalette);
|
|
free(_cursorPalette);
|
|
free(_mouseData);
|
|
}
|
|
|
|
uint32 OSystem_SDL::getMillis() {
|
|
return SDL_GetTicks();
|
|
}
|
|
|
|
void OSystem_SDL::delayMillis(uint msecs) {
|
|
SDL_Delay(msecs);
|
|
}
|
|
|
|
void OSystem_SDL::setTimerCallback(TimerProc callback, int timer) {
|
|
SDL_SetTimer(timer, (SDL_TimerCallback) callback);
|
|
}
|
|
|
|
void OSystem_SDL::setWindowCaption(const char *caption) {
|
|
SDL_WM_SetCaption(caption, caption);
|
|
}
|
|
|
|
bool OSystem_SDL::hasFeature(Feature f) {
|
|
return
|
|
(f == kFeatureFullscreenMode) ||
|
|
(f == kFeatureAspectRatioCorrection) ||
|
|
(f == kFeatureAutoComputeDirtyRects) ||
|
|
(f == kFeatureCursorHasPalette);
|
|
}
|
|
|
|
void OSystem_SDL::setFeatureState(Feature f, bool enable) {
|
|
switch (f) {
|
|
case kFeatureFullscreenMode:
|
|
setFullscreenMode(enable);
|
|
break;
|
|
case kFeatureAspectRatioCorrection:
|
|
setAspectRatioCorrection(enable);
|
|
break;
|
|
case kFeatureAutoComputeDirtyRects:
|
|
if (enable)
|
|
_modeFlags |= DF_WANT_RECT_OPTIM;
|
|
else
|
|
_modeFlags &= ~DF_WANT_RECT_OPTIM;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool OSystem_SDL::getFeatureState(Feature f) {
|
|
assert (_transactionMode == kTransactionNone);
|
|
|
|
switch (f) {
|
|
case kFeatureFullscreenMode:
|
|
return _fullscreen;
|
|
case kFeatureAspectRatioCorrection:
|
|
return _adjustAspectRatio;
|
|
case kFeatureAutoComputeDirtyRects:
|
|
return _modeFlags & DF_WANT_RECT_OPTIM;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void OSystem_SDL::quit() {
|
|
if (_cdrom) {
|
|
SDL_CDStop(_cdrom);
|
|
SDL_CDClose(_cdrom);
|
|
}
|
|
unloadGFXMode();
|
|
deleteMutex(_graphicsMutex);
|
|
|
|
if (_joystick)
|
|
SDL_JoystickClose(_joystick);
|
|
SDL_ShowCursor(SDL_ENABLE);
|
|
SDL_Quit();
|
|
|
|
exit(0);
|
|
}
|
|
|
|
void OSystem_SDL::setupIcon() {
|
|
int w, h, ncols, nbytes, i;
|
|
unsigned int rgba[256], icon[32 * 32];
|
|
unsigned char mask[32][4];
|
|
|
|
sscanf(scummvm_icon[0], "%d %d %d %d", &w, &h, &ncols, &nbytes);
|
|
if ((w != 32) || (h != 32) || (ncols > 255) || (nbytes > 1)) {
|
|
warning("Could not load the icon (%d %d %d %d)", w, h, ncols, nbytes);
|
|
return;
|
|
}
|
|
for (i = 0; i < ncols; i++) {
|
|
unsigned char code;
|
|
char color[32];
|
|
unsigned int col;
|
|
sscanf(scummvm_icon[1 + i], "%c c %s", &code, color);
|
|
if (!strcmp(color, "None"))
|
|
col = 0x00000000;
|
|
else if (!strcmp(color, "black"))
|
|
col = 0xFF000000;
|
|
else if (color[0] == '#') {
|
|
sscanf(color + 1, "%06x", &col);
|
|
col |= 0xFF000000;
|
|
} else {
|
|
warning("Could not load the icon (%d %s - %s) ", code, color, scummvm_icon[1 + i]);
|
|
return;
|
|
}
|
|
|
|
rgba[code] = col;
|
|
}
|
|
memset(mask, 0, sizeof(mask));
|
|
for (h = 0; h < 32; h++) {
|
|
const char *line = scummvm_icon[1 + ncols + h];
|
|
for (w = 0; w < 32; w++) {
|
|
icon[w + 32 * h] = rgba[(int)line[w]];
|
|
if (rgba[(int)line[w]] & 0xFF000000) {
|
|
mask[h][w >> 3] |= 1 << (7 - (w & 0x07));
|
|
}
|
|
}
|
|
}
|
|
|
|
SDL_Surface *sdl_surf = SDL_CreateRGBSurfaceFrom(icon, 32, 32, 32, 32 * 4, 0xFF0000, 0x00FF00, 0x0000FF, 0xFF000000);
|
|
SDL_WM_SetIcon(sdl_surf, (unsigned char *) mask);
|
|
SDL_FreeSurface(sdl_surf);
|
|
}
|
|
|
|
OSystem::MutexRef OSystem_SDL::createMutex(void) {
|
|
return (MutexRef) SDL_CreateMutex();
|
|
}
|
|
|
|
void OSystem_SDL::lockMutex(MutexRef mutex) {
|
|
SDL_mutexP((SDL_mutex *) mutex);
|
|
}
|
|
|
|
void OSystem_SDL::unlockMutex(MutexRef mutex) {
|
|
SDL_mutexV((SDL_mutex *) mutex);
|
|
}
|
|
|
|
void OSystem_SDL::deleteMutex(MutexRef mutex) {
|
|
SDL_DestroyMutex((SDL_mutex *) mutex);
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark --- Audio ---
|
|
#pragma mark -
|
|
|
|
bool OSystem_SDL::setSoundCallback(SoundProc proc, void *param) {
|
|
SDL_AudioSpec desired;
|
|
SDL_AudioSpec obtained;
|
|
|
|
memset(&desired, 0, sizeof(desired));
|
|
|
|
if (ConfMan.hasKey("output_rate"))
|
|
_samplesPerSec = ConfMan.getInt("output_rate");
|
|
else
|
|
_samplesPerSec = SAMPLES_PER_SEC;
|
|
|
|
// Originally, we always used 2048 samples. This loop will produce the
|
|
// same result at 22050 Hz, and should hopefully produce something
|
|
// sensible for other frequencies. Note that it must be a power of two.
|
|
|
|
uint16 samples = 0x8000;
|
|
|
|
for (;;) {
|
|
if (samples / (_samplesPerSec / 1000) < 100)
|
|
break;
|
|
samples >>= 1;
|
|
}
|
|
|
|
desired.freq = _samplesPerSec;
|
|
desired.format = AUDIO_S16SYS;
|
|
desired.channels = 2;
|
|
desired.samples = samples;
|
|
desired.callback = proc;
|
|
desired.userdata = param;
|
|
if (SDL_OpenAudio(&desired, &obtained) != 0) {
|
|
return false;
|
|
}
|
|
// Note: This should be the obtained output rate, but it seems that at
|
|
// least on some platforms SDL will lie and claim it did get the rate
|
|
// even if it didn't. Probably only happens for "weird" rates, though.
|
|
_samplesPerSec = obtained.freq;
|
|
SDL_PauseAudio(0);
|
|
return true;
|
|
}
|
|
|
|
void OSystem_SDL::clearSoundCallback() {
|
|
SDL_CloseAudio();
|
|
}
|
|
|
|
int OSystem_SDL::getOutputSampleRate() const {
|
|
return _samplesPerSec;
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark --- CD Audio ---
|
|
#pragma mark -
|
|
|
|
bool OSystem_SDL::openCD(int drive) {
|
|
if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1)
|
|
_cdrom = NULL;
|
|
else {
|
|
_cdrom = SDL_CDOpen(drive);
|
|
// Did it open? Check if _cdrom is NULL
|
|
if (!_cdrom) {
|
|
warning("Couldn't open drive: %s", SDL_GetError());
|
|
} else {
|
|
_cdNumLoops = 0;
|
|
_cdStopTime = 0;
|
|
_cdEndTime = 0;
|
|
}
|
|
}
|
|
|
|
return (_cdrom != NULL);
|
|
}
|
|
|
|
void OSystem_SDL::stopCD() { /* Stop CD Audio in 1/10th of a second */
|
|
_cdStopTime = SDL_GetTicks() + 100;
|
|
_cdNumLoops = 0;
|
|
}
|
|
|
|
void OSystem_SDL::playCD(int track, int num_loops, int start_frame, int duration) {
|
|
if (!num_loops && !start_frame)
|
|
return;
|
|
|
|
if (!_cdrom)
|
|
return;
|
|
|
|
if (duration > 0)
|
|
duration += 5;
|
|
|
|
_cdTrack = track;
|
|
_cdNumLoops = num_loops;
|
|
_cdStartFrame = start_frame;
|
|
|
|
SDL_CDStatus(_cdrom);
|
|
if (start_frame == 0 && duration == 0)
|
|
SDL_CDPlayTracks(_cdrom, track, 0, 1, 0);
|
|
else
|
|
SDL_CDPlayTracks(_cdrom, track, start_frame, 0, duration);
|
|
_cdDuration = duration;
|
|
_cdStopTime = 0;
|
|
_cdEndTime = SDL_GetTicks() + _cdrom->track[track].length * 1000 / CD_FPS;
|
|
}
|
|
|
|
bool OSystem_SDL::pollCD() {
|
|
if (!_cdrom)
|
|
return false;
|
|
|
|
return (_cdNumLoops != 0 && (SDL_GetTicks() < _cdEndTime || SDL_CDStatus(_cdrom) != CD_STOPPED));
|
|
}
|
|
|
|
void OSystem_SDL::updateCD() {
|
|
if (!_cdrom)
|
|
return;
|
|
|
|
if (_cdStopTime != 0 && SDL_GetTicks() >= _cdStopTime) {
|
|
SDL_CDStop(_cdrom);
|
|
_cdNumLoops = 0;
|
|
_cdStopTime = 0;
|
|
return;
|
|
}
|
|
|
|
if (_cdNumLoops == 0 || SDL_GetTicks() < _cdEndTime)
|
|
return;
|
|
|
|
if (_cdNumLoops != 1 && SDL_CDStatus(_cdrom) != CD_STOPPED) {
|
|
// Wait another second for it to be done
|
|
_cdEndTime += 1000;
|
|
return;
|
|
}
|
|
|
|
if (_cdNumLoops > 0)
|
|
_cdNumLoops--;
|
|
|
|
if (_cdNumLoops != 0) {
|
|
if (_cdStartFrame == 0 && _cdDuration == 0)
|
|
SDL_CDPlayTracks(_cdrom, _cdTrack, 0, 1, 0);
|
|
else
|
|
SDL_CDPlayTracks(_cdrom, _cdTrack, _cdStartFrame, 0, _cdDuration);
|
|
_cdEndTime = SDL_GetTicks() + _cdrom->track[_cdTrack].length * 1000 / CD_FPS;
|
|
}
|
|
}
|