469 lines
13 KiB
C++
469 lines
13 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "sherlock/sherlock.h"
|
|
#include "sherlock/scalpel/settings.h"
|
|
#include "sherlock/scalpel/scalpel_screen.h"
|
|
#include "sherlock/scalpel/scalpel_user_interface.h"
|
|
#include "sherlock/scalpel/scalpel_fixed_text.h"
|
|
#include "sherlock/scalpel/scalpel.h"
|
|
|
|
#include "backends/keymapper/keymapper.h"
|
|
|
|
namespace Sherlock {
|
|
|
|
namespace Scalpel {
|
|
|
|
static const int SETUP_POINTS_INTL[12][4] = {
|
|
{ 4, 154, 101, 53 }, // Exit
|
|
{ 4, 165, 101, 53 }, // Music Toggle
|
|
{ 219, 165, 316, 268 }, // Voice Toggle
|
|
{ 103, 165, 217, 160 }, // Sound Effects Toggle
|
|
{ 219, 154, 316, 268 }, // Help Button Left/Right
|
|
{ 103, 154, 217, 160 }, // New Font Style
|
|
{ 4, 187, 101, 53 }, // Joystick Toggle
|
|
{ 103, 187, 217, 160 }, // Calibrate Joystick
|
|
{ 219, 176, 316, 268 }, // Fade Style
|
|
{ 103, 176, 217, 160 }, // Window Open Style
|
|
{ 4, 176, 101, 53 }, // Portraits Toggle
|
|
{ 219, 187, 316, 268 } // _key Pad Accel. Toggle
|
|
};
|
|
|
|
// Different from original to accommodate hotkeys
|
|
static const int SETUP_POINTS_ZH[12][4] = {
|
|
{ 3, 159, 73, 38 }, // Exit // OK
|
|
{ 3, 178, 73, 38 }, // Music Toggle // OK
|
|
{ 0, 0, 0, 0 }, // Voice Toggle
|
|
{ 74, 178, 145, 109 }, // Sound Effects Toggle // OK
|
|
{ 146, 178, 233, 191 }, // Help Button Left/Right // OK
|
|
{ 0, 0, 0, 0 }, // New Font Style // OK
|
|
{ 0, 0, 0, 0 }, // Joystick Toggle // OK
|
|
{ 0, 0, 0, 0 }, // Calibrate Joystick // OK
|
|
{ 234, 159, 317, 276 }, // Fade Style // OK
|
|
{ 146, 159, 233, 191 }, // Window Open Style // OK
|
|
{ 74, 159, 145, 109 }, // Portraits Toggle // OK
|
|
{ 234, 178, 317, 276 } // _key Pad Accel. Toggle
|
|
};
|
|
|
|
/*----------------------------------------------------------------*/
|
|
|
|
bool Settings::doesButtonExist(int num) const {
|
|
if (_vm->getLanguage() == Common::Language::ZH_TWN)
|
|
return num != 2 && num != 5 && num != 6 && num != 7;
|
|
return true;
|
|
}
|
|
|
|
void Settings::makeButtonNumDisabled(int num, const Common::String &s) {
|
|
if (!doesButtonExist(num))
|
|
return;
|
|
|
|
ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
|
|
makeButtonNum(num, s);
|
|
screen.buttonPrint(getButtonTextPoint(num), COMMAND_NULL, false, s);
|
|
}
|
|
|
|
Common::Rect Settings::getButtonRect(int num) const {
|
|
if (_vm->getLanguage() == Common::Language::ZH_TWN) {
|
|
return Common::Rect(SETUP_POINTS_ZH[num][0], SETUP_POINTS_ZH[num][1],
|
|
SETUP_POINTS_ZH[num][2], SETUP_POINTS_ZH[num][1] + 19);
|
|
} else {
|
|
return Common::Rect(SETUP_POINTS_INTL[num][0], SETUP_POINTS_INTL[num][1],
|
|
SETUP_POINTS_INTL[num][2], SETUP_POINTS_INTL[num][1] + 10);
|
|
}
|
|
}
|
|
|
|
void Settings::makeButtonNum(int num, const Common::String &s) {
|
|
if (!doesButtonExist(num))
|
|
return;
|
|
|
|
ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
|
|
screen.makeButton(getButtonRect(num), getButtonTextPoint(num), s);
|
|
}
|
|
|
|
Common::Point Settings::getButtonTextPoint(int num) const {
|
|
if (_vm->getLanguage() == Common::Language::ZH_TWN) {
|
|
return Common::Point(SETUP_POINTS_ZH[num][3], SETUP_POINTS_ZH[num][1] + 2);
|
|
} else {
|
|
return Common::Point(SETUP_POINTS_INTL[num][3], SETUP_POINTS_INTL[num][1]);
|
|
}
|
|
}
|
|
|
|
void Settings::drawInterface(bool flag) {
|
|
People &people = *_vm->_people;
|
|
ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
|
|
Sound &sound = *_vm->_sound;
|
|
Music &music = *_vm->_music;
|
|
UserInterface &ui = *_vm->_ui;
|
|
Common::String tempStr;
|
|
|
|
if (!flag) {
|
|
screen._backBuffer1.fillRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, CONTROLS_Y1 + 1), BORDER_COLOR);
|
|
screen._backBuffer1.fillRect(Common::Rect(0, CONTROLS_Y1 + 1, 2, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
|
|
screen._backBuffer1.fillRect(Common::Rect(SHERLOCK_SCREEN_WIDTH - 2, CONTROLS_Y1 + 1, SHERLOCK_SCREEN_WIDTH,
|
|
SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
|
|
screen._backBuffer1.hLine(0, SHERLOCK_SCREEN_HEIGHT - 1, SHERLOCK_SCREEN_WIDTH - 1, BORDER_COLOR);
|
|
screen._backBuffer1.fillRect(Common::Rect(2, CONTROLS_Y1 + 1, SHERLOCK_SCREEN_WIDTH - 2,
|
|
SHERLOCK_SCREEN_HEIGHT - 1), INV_BACKGROUND);
|
|
}
|
|
|
|
tempStr = FIXED(Settings_Exit);
|
|
_actionExit = kActionScalpelSettingsExit;
|
|
makeButtonNum(0, tempStr);
|
|
|
|
if (music._musicOn) {
|
|
tempStr = FIXED(Settings_MusicOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_MusicOff);
|
|
}
|
|
_actionMusic = kActionScalpelSettingsToggleMusic;
|
|
makeButtonNum(1, tempStr);
|
|
|
|
if (people._portraitsOn) {
|
|
tempStr = FIXED(Settings_PortraitsOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_PortraitsOff);
|
|
}
|
|
_actionPortraits = kActionScalpelSettingsTogglePortraits;
|
|
makeButtonNum(10, tempStr);
|
|
|
|
// WORKAROUND: We don't support the joystick in ScummVM, so draw the next two buttons as disabled
|
|
tempStr = FIXED(Settings_JoystickOff);
|
|
makeButtonNumDisabled(6, tempStr);
|
|
|
|
tempStr = FIXED(Settings_NewFontStyle);
|
|
_actionNewFontStyle = kActionScalpelSettingsChangeFontStyle;
|
|
makeButtonNum(5, tempStr);
|
|
|
|
if (sound._digitized) {
|
|
tempStr = FIXED(Settings_SoundEffectsOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_SoundEffectsOff);
|
|
}
|
|
_actionSoundEffects = kActionScalpelSettingsToggleSoundEffects;
|
|
makeButtonNum(3, tempStr);
|
|
|
|
if (ui._slideWindows) {
|
|
tempStr = FIXED(Settings_WindowsSlide);
|
|
} else {
|
|
tempStr = FIXED(Settings_WindowsAppear);
|
|
}
|
|
_actionWindows = kActionScalpelSettingsToggleWindowsMode;
|
|
makeButtonNum(9, tempStr);
|
|
|
|
tempStr = FIXED(Settings_CalibrateJoystick);
|
|
makeButtonNumDisabled(7, tempStr);
|
|
|
|
if (ui._helpStyle) {
|
|
tempStr = FIXED(Settings_AutoHelpRight);
|
|
} else {
|
|
tempStr = FIXED(Settings_AutoHelpLeft);
|
|
}
|
|
_actionAutoHelp = kActionScalpelSettingsChangeAutohelpLoc;
|
|
makeButtonNum(4, tempStr);
|
|
|
|
if (sound._voices) {
|
|
tempStr = FIXED(Settings_VoicesOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_VoicesOff);
|
|
}
|
|
_actionVoices = kActionScalpelSettingsToggleVoices;
|
|
makeButtonNum(2, tempStr);
|
|
|
|
if (screen._fadeStyle) {
|
|
tempStr = FIXED(Settings_FadeByPixel);
|
|
} else {
|
|
tempStr = FIXED(Settings_FadeDirectly);
|
|
}
|
|
_actionFade = kActionScalpelSettingsChangeFadeMode;
|
|
makeButtonNum(8, tempStr);
|
|
|
|
if (screen._fadeStyle) {
|
|
// German version uses a different action for fade modes
|
|
if (_vm->getLanguage() == Common::Language::DE_DEU)
|
|
_actionFade = kActionScalpelSettingsFadeByPixels;
|
|
} else {
|
|
if (_vm->getLanguage() == Common::Language::DE_DEU)
|
|
_actionFade = kActionScalpelSettingsFadeDirectly;
|
|
}
|
|
|
|
tempStr = FIXED(Settings_KeyPadSlow);
|
|
makeButtonNumDisabled(11, tempStr);
|
|
|
|
_actionsIndexed[0] = _actionExit;
|
|
_actionsIndexed[1] = _actionMusic;
|
|
_actionsIndexed[2] = _actionVoices;
|
|
_actionsIndexed[3] = _actionSoundEffects;
|
|
_actionsIndexed[4] = _actionAutoHelp;
|
|
_actionsIndexed[5] = _actionNewFontStyle;
|
|
_actionsIndexed[8] = _actionFade;
|
|
_actionsIndexed[9] = _actionWindows;
|
|
_actionsIndexed[10] = _actionPortraits;
|
|
|
|
// Show the window immediately, or slide it on-screen
|
|
if (!flag) {
|
|
if (!ui._slideWindows) {
|
|
screen.slamRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
|
|
} else {
|
|
ui.summonWindow(true, CONTROLS_Y1);
|
|
}
|
|
|
|
ui._windowOpen = true;
|
|
} else {
|
|
screen.slamRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
|
|
}
|
|
}
|
|
|
|
int Settings::drawButtons(const Common::Point &pt, Common::CustomEventType action) {
|
|
Events &events = *_vm->_events;
|
|
People &people = *_vm->_people;
|
|
ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
|
|
Music &music = *_vm->_music;
|
|
Sound &sound = *_vm->_sound;
|
|
UserInterface &ui = *_vm->_ui;
|
|
int found = -1;
|
|
byte color;
|
|
Common::String tempStr;
|
|
|
|
for (int idx = 0; idx < 12; ++idx) {
|
|
if (!doesButtonExist(idx))
|
|
continue;
|
|
if ((getButtonRect(idx).contains(pt) && (events._pressed || events._released))
|
|
|| (action == _actionsIndexed[idx])) {
|
|
found = idx;
|
|
color = COMMAND_HIGHLIGHTED;
|
|
} else {
|
|
color = COMMAND_FOREGROUND;
|
|
}
|
|
|
|
// Print the button text
|
|
switch (idx) {
|
|
case 0:
|
|
tempStr = FIXED(Settings_Exit);
|
|
break;
|
|
case 1:
|
|
if (music._musicOn) {
|
|
tempStr = FIXED(Settings_MusicOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_MusicOff);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (sound._voices) {
|
|
tempStr = FIXED(Settings_VoicesOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_VoicesOff);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (sound._digitized) {
|
|
tempStr = FIXED(Settings_SoundEffectsOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_SoundEffectsOff);
|
|
}
|
|
break;
|
|
case 4:
|
|
if (ui._helpStyle) {
|
|
tempStr = FIXED(Settings_AutoHelpRight);
|
|
} else {
|
|
tempStr = FIXED(Settings_AutoHelpLeft);
|
|
}
|
|
break;
|
|
case 5:
|
|
tempStr = FIXED(Settings_NewFontStyle);
|
|
break;
|
|
case 6:
|
|
// Joystick Off - disabled in ScummVM
|
|
continue;
|
|
case 7:
|
|
// Calibrate Joystick - disabled in ScummVM
|
|
continue;
|
|
case 8:
|
|
if (screen._fadeStyle) {
|
|
tempStr = FIXED(Settings_FadeByPixel);
|
|
} else {
|
|
tempStr = FIXED(Settings_FadeDirectly);
|
|
}
|
|
break;
|
|
case 9:
|
|
if (ui._slideWindows) {
|
|
tempStr = FIXED(Settings_WindowsSlide);
|
|
} else {
|
|
tempStr = FIXED(Settings_WindowsAppear);
|
|
}
|
|
break;
|
|
case 10:
|
|
if (people._portraitsOn) {
|
|
tempStr = FIXED(Settings_PortraitsOn);
|
|
} else {
|
|
tempStr = FIXED(Settings_PortraitsOff);
|
|
}
|
|
break;
|
|
case 11:
|
|
// Key Pad Slow - disabled in ScummVM
|
|
continue;
|
|
default:
|
|
continue;
|
|
}
|
|
screen.buttonPrint(getButtonTextPoint(idx), color, true, tempStr);
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
void Settings::show(SherlockEngine *vm) {
|
|
Events &events = *vm->_events;
|
|
People &people = *vm->_people;
|
|
Scene &scene = *vm->_scene;
|
|
Screen &screen = *vm->_screen;
|
|
Sound &sound = *vm->_sound;
|
|
Music &music = *vm->_music;
|
|
Talk &talk = *vm->_talk;
|
|
ScalpelUserInterface &ui = *(ScalpelUserInterface *)vm->_ui;
|
|
bool updateConfig = false;
|
|
|
|
assert(vm->getGameID() == GType_SerratedScalpel);
|
|
Settings settings(vm);
|
|
settings.drawInterface(false);
|
|
|
|
Common::Keymapper *keymapper = g_system->getEventManager()->getKeymapper();
|
|
keymapper->getKeymap("scalpel")->setEnabled(false);
|
|
keymapper->getKeymap("scalpel-settings")->setEnabled(true);
|
|
|
|
do {
|
|
if (ui._menuCounter)
|
|
ui.whileMenuCounter();
|
|
|
|
int found = -1;
|
|
ui._action = kActionNone;
|
|
|
|
scene.doBgAnim();
|
|
if (talk._talkToAbort)
|
|
return;
|
|
|
|
events.setButtonState();
|
|
Common::Point pt = events.mousePos();
|
|
|
|
if (events._pressed || events._released || events.actionHit()) {
|
|
ui.clearInfo();
|
|
ui._action = kActionNone;
|
|
|
|
if (events.actionHit()) {
|
|
ui._action = events.getAction();
|
|
|
|
if (ui._action == kActionScalpelSettingsSelect) {
|
|
events._pressed = false;
|
|
events._oldButtons = 0;
|
|
ui._actionPress = kActionNone;
|
|
events._released = true;
|
|
}
|
|
}
|
|
|
|
// Handle highlighting button under mouse
|
|
found = settings.drawButtons(pt, ui._action);
|
|
}
|
|
|
|
if ((found == 0 && events._released) || (ui._action == settings._actionExit))
|
|
// Exit
|
|
break;
|
|
|
|
if ((found == 1 && events._released) || ui._action == settings._actionMusic) {
|
|
// Toggle music
|
|
music._musicOn = !music._musicOn;
|
|
if (!music._musicOn)
|
|
music.stopMusic();
|
|
else
|
|
music.startSong();
|
|
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
|
|
if ((found == 2 && events._released) || ui._action == settings._actionVoices) {
|
|
sound._voices = !sound._voices;
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
|
|
if ((found == 3 && events._released) || ui._action == settings._actionSoundEffects) {
|
|
// Toggle sound effects
|
|
sound._digitized = !sound._digitized;
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
|
|
if ((found == 4 && events._released) || ui._action == settings._actionAutoHelp) {
|
|
// Help button style
|
|
ui._helpStyle = !ui._helpStyle;
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
|
|
if ((found == 5 && events._released) || ui._action == settings._actionNewFontStyle) {
|
|
// New font style
|
|
int fontNum = screen.fontNumber() + 1;
|
|
if (fontNum == 3)
|
|
fontNum = 0;
|
|
|
|
screen.setFont(fontNum);
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
|
|
if ((found == 8 && events._released) || ui._action == settings._actionFade) {
|
|
// Toggle fade style
|
|
screen._fadeStyle = !screen._fadeStyle;
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
|
|
if ((found == 9 && events._released) || ui._action == settings._actionWindows) {
|
|
// Window style
|
|
ui._slideWindows = !ui._slideWindows;
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
|
|
if ((found == 10 && events._released) || ui._action == settings._actionPortraits) {
|
|
// Toggle portraits being shown
|
|
people._portraitsOn = !people._portraitsOn;
|
|
updateConfig = true;
|
|
settings.drawInterface(true);
|
|
}
|
|
} while (!vm->shouldQuit());
|
|
|
|
ui.banishWindow();
|
|
|
|
keymapper->getKeymap("scalpel-settings")->setEnabled(false);
|
|
keymapper->getKeymap("scalpel")->setEnabled(true);
|
|
|
|
if (updateConfig)
|
|
vm->saveConfig();
|
|
|
|
ui._actionPress = kActionNone;
|
|
ui._actionInput = false;
|
|
ui._windowBounds.top = CONTROLS_Y1;
|
|
ui._action = (Common::CustomEventType) -1;
|
|
}
|
|
|
|
} // End of namespace Scalpel
|
|
|
|
} // End of namespace Sherlock
|