Initial commit

engines/titanic/pet_control/pet_sound.cpp

@@ -0,0 +1,312 @@
+/* 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 "titanic/pet_control/pet_sound.h"
+#include "titanic/pet_control/pet_control.h"
+#include "titanic/pet_control/pet_real_life.h"
+#include "titanic/game_manager.h"
+#include "titanic/titanic.h"
+#include "common/config-manager.h"
+
+namespace Titanic {
+
+CPetSound::CPetSound() : CPetGlyph(), _draggingSlider(nullptr), _draggingSliderNum(MASTER_SLIDER) {
+}
+
+bool CPetSound::setup(CPetControl *petControl, CPetGlyphs *owner) {
+	CPetGlyph::setup(petControl, owner);
+
+	_masterVolume.setOrientation(ORIENTATION_HORIZONTAL);
+	_masterVolume.setBounds(Rect(17, 0, 147, 15));
+	_masterVolume.setSlidingBounds(Rect(35, 5, 127, 11));
+	_masterVolume.setThumbSize(Point(25, 15));
+	_masterVolume.translate(Point(415, 376));
+
+	_musicVolume.setOrientation(ORIENTATION_HORIZONTAL);
+	_musicVolume.setBounds(Rect(17, 20, 147, 35));
+	_musicVolume.setSlidingBounds(Rect(35, 25, 127, 31));
+	_musicVolume.setThumbSize(Point(25, 15));
+	_musicVolume.translate(Point(415, 376));
+
+	_parrotVolume.setOrientation(ORIENTATION_HORIZONTAL);
+	_parrotVolume.setBounds(Rect(17, 40, 147, 55));
+	_parrotVolume.setSlidingBounds(Rect(35, 45, 127, 51));
+	_parrotVolume.setThumbSize(Point(25, 15));
+	_parrotVolume.translate(Point(415, 376));
+
+	_speechVolume.setOrientation(ORIENTATION_HORIZONTAL);
+	_speechVolume.setBounds(Rect(17, 60, 147, 75));
+	_speechVolume.setSlidingBounds(Rect(35, 65, 127, 71));
+	_speechVolume.setThumbSize(Point(25, 15));
+	_speechVolume.translate(Point(415, 376));
+
+	_element.setBounds(Rect(0, 0, 165, 77));
+	_element.translate(Point(415, 376));
+
+	Rect rect(0, 0, 88, 16);
+	rect.translate(320, 376);
+	_textMasterVolume.setBounds(rect);
+	_textMasterVolume.resize(3);
+	_textMasterVolume.setHasBorder(false);
+	_textMasterVolume.setText(MASTER_VOLUME);
+
+	rect.translate(0, 20);
+	_textMusicVolume.setBounds(rect);
+	_textMusicVolume.resize(3);
+	_textMusicVolume.setHasBorder(false);
+	_textMusicVolume.setText(MUSIC_VOLUME);
+
+	rect.translate(0, 20);
+	_textParrotVolume.setBounds(rect);
+	_textParrotVolume.resize(3);
+	_textParrotVolume.setHasBorder(false);
+	_textParrotVolume.setText(PARROT_VOLUME);
+
+	rect.translate(0, 20);
+	_textSpeechVolume.setBounds(rect);
+	_textSpeechVolume.resize(3);
+	_textSpeechVolume.setHasBorder(false);
+	_textSpeechVolume.setText(SPEECH_VOLUME);
+
+	return true;
+}
+
+bool CPetSound::reset() {
+	CPetControl *pet = getPetControl();
+	if (pet) {
+		setName("PetSound", pet);
+		_element.reset("PetVolChannels", pet, MODE_UNSELECTED);
+		_musicVolume.setupThumb2("PetVolSlug", pet);
+		_masterVolume.setupThumb2("PetVolSlug", pet);
+		_parrotVolume.setupThumb2("PetVolSlug", pet);
+		_speechVolume.setupThumb2("PetVolSlug", pet);
+
+		CPetSection *section = getPetSection();
+		uint col = section->getColor(0);
+		_textMusicVolume.setLineColor(0, col);
+		_textMasterVolume.setLineColor(0, col);
+		_textParrotVolume.setLineColor(0, col);
+		_textSpeechVolume.setLineColor(0, col);
+	}
+
+	return false;
+}
+
+void CPetSound::setSliders() {
+	// Get the mute settings
+	bool muteAll = ConfMan.hasKey("mute") ? ConfMan.getBool("mute") : false;
+	bool musicMute = muteAll || (ConfMan.hasKey("music_mute") && ConfMan.getBool("music_mute"));
+	bool sfxMute = muteAll || (ConfMan.hasKey("sfx_mute") && ConfMan.getBool("sfx_mute"));
+	bool speechMute = muteAll || (ConfMan.hasKey("speech_mute") && ConfMan.getBool("speech_mute"));
+
+	// Get the volume levels
+	uint musicVol = musicMute ? 0 : MIN(255, ConfMan.getInt("music_volume"));
+	uint parrotVol = sfxMute ? 0 : MIN(255, ConfMan.getInt("sfx_volume"));
+	uint speechVol = speechMute ? 0 : MIN(255, ConfMan.getInt("speech_volume"));
+	uint masterVol = MAX(musicVol, MAX(parrotVol, speechVol));
+
+	const double FACTOR = 1.0 / 255.0;
+	_masterVolume.setSliderOffset(masterVol * FACTOR);
+	_musicVolume.setSliderOffset(musicVol * FACTOR);
+	_parrotVolume.setSliderOffset(parrotVol * FACTOR);
+	_speechVolume.setSliderOffset(speechVol * FACTOR);
+}
+
+void CPetSound::sliderChanged(double offset, SliderType sliderNum) {
+	uint newVol = (uint)(offset * 255.0);
+
+	switch (sliderNum) {
+	case MASTER_SLIDER:
+		ConfMan.setBool("music_mute", false);
+		ConfMan.setBool("sfx_mute", false);
+		ConfMan.setBool("sfx_mute", false);
+		ConfMan.setInt("music_volume", newVol);
+		ConfMan.setInt("sfx_volume", newVol);
+		ConfMan.setInt("speech_volume", newVol);
+
+		_musicVolume.setSliderOffset(newVol * 0.01);
+		_parrotVolume.setSliderOffset(newVol * 0.01);
+		_speechVolume.setSliderOffset(newVol * 0.01);
+		break;
+	case MUSIC_SLIDER:
+		ConfMan.setBool("music_mute", false);
+		ConfMan.setInt("music_volume", newVol);
+		break;
+	case PARROT_SLIDER:
+		ConfMan.setBool("sfx_mute", false);
+		ConfMan.setInt("sfx_volume", newVol);
+		break;
+	case SPEECH_SLIDER:
+		ConfMan.setBool("speech_mute", false);
+		ConfMan.setInt("speech_volume", newVol);
+		break;
+	default:
+		return;
+	}
+
+	ConfMan.setBool("mute", false);
+	g_vm->syncSoundSettings();
+}
+
+void CPetSound::draw2(CScreenManager *screenManager) {
+	_element.draw(screenManager);
+
+	_musicVolume.draw(screenManager);
+	_masterVolume.draw(screenManager);
+	_parrotVolume.draw(screenManager);
+	_speechVolume.draw(screenManager);
+
+	_textMusicVolume.draw(screenManager);
+	_textMasterVolume.draw(screenManager);
+	_textParrotVolume.draw(screenManager);
+	_textSpeechVolume.draw(screenManager);
+}
+
+bool CPetSound::MouseButtonDownMsg(const Point &pt) {
+	if (_musicVolume.checkThumb(pt) || _masterVolume.checkThumb(pt) ||
+		_speechVolume.checkThumb(pt))
+		return true;
+
+	if (_parrotVolume.checkThumb(pt)) {
+		CPetControl *pet = getPetControl();
+		if (pet)
+			pet->playSound(2);
+
+		return true;
+	}
+
+	Rect rectLeft(0, 0, 10, 11);
+	Rect rectRight(0, 0, 10, 11);
+	rectLeft.translate(415, 379);
+	rectRight.translate(567, 378);
+
+	CPetSlider *sliders[4] = { &_masterVolume, &_musicVolume, &_parrotVolume, &_speechVolume };
+	for (int idx = MASTER_SLIDER; idx <= SPEECH_SLIDER; ++idx) {
+		CPetSlider *slider = sliders[idx];
+		const bool isLeft = rectLeft.contains(pt);
+		const bool isRight = rectRight.contains(pt);
+		double offset = 0.0;
+
+		if (isLeft) {
+			slider->stepPosition(-1);
+			offset = slider->getOffsetPixels();
+		} else if (isRight) {
+			slider->stepPosition(1);
+			offset = slider->getOffsetPixels();
+		}
+
+		if (isLeft || isRight) {
+			sliderChanged(offset, (SliderType)idx);
+			return true;
+		}
+
+		// Move to next slider row
+		rectLeft.translate(0, 20);
+		rectRight.translate(0, 20);
+	}
+
+	return false;
+}
+
+bool CPetSound::MouseDragStartMsg(CMouseDragStartMsg *msg) {
+	if (_masterVolume.resetThumbFocus()) {
+		_draggingSlider = &_masterVolume;
+		getOwner()->startDragging(this, msg);
+		_draggingSliderNum = MASTER_SLIDER;
+		return true;
+	} else if (_musicVolume.resetThumbFocus()) {
+		_draggingSlider = &_musicVolume;
+		getOwner()->startDragging(this, msg);
+		_draggingSliderNum = MUSIC_SLIDER;
+		return true;
+	} else if (_parrotVolume.resetThumbFocus()) {
+		_draggingSlider = &_parrotVolume;
+		getOwner()->startDragging(this, msg);
+		_draggingSliderNum = PARROT_SLIDER;
+		return true;
+	} else if (_speechVolume.resetThumbFocus()) {
+		_draggingSlider = &_speechVolume;
+		getOwner()->startDragging(this, msg);
+		_draggingSliderNum = SPEECH_SLIDER;
+		return true;
+	}
+
+	_draggingSlider = nullptr;
+	return false;
+}
+
+bool CPetSound::MouseDragMoveMsg(CMouseDragMoveMsg *msg) {
+	if (!_draggingSlider)
+		return false;
+
+	if (_draggingSlider->MouseDragMoveMsg(msg->_mousePos)) {
+		double offset = _draggingSlider->getOffsetPixels();
+		sliderChanged(offset, _draggingSliderNum);
+		getPetControl()->makeDirty();
+		return true;
+	}
+
+	return false;
+}
+
+bool CPetSound::MouseDragEndMsg(CMouseDragEndMsg *msg) {
+	if (!_draggingSlider)
+		return false;
+
+	// Flush the changed settings
+	ConfMan.flushToDisk();
+
+	bool result = _draggingSlider->MouseDragEndMsg(msg->_mousePos);
+	getOwner()->endDragging();
+
+	return result;
+}
+
+bool CPetSound::MouseButtonUpMsg(const Point &pt) {
+	SliderType sliderNum = MASTER_SLIDER;
+	CPetSlider *slider = nullptr;
+
+	if (_masterVolume.MouseButtonUpMsg(pt)) {
+		sliderNum = MASTER_SLIDER;
+		slider = &_masterVolume;
+	} else if (_musicVolume.MouseButtonUpMsg(pt)) {
+		sliderNum = MUSIC_SLIDER;
+		slider = &_musicVolume;
+	} else if (_parrotVolume.MouseButtonUpMsg(pt)) {
+		sliderNum = PARROT_SLIDER;
+		slider = &_parrotVolume;
+	} else if (_speechVolume.MouseButtonUpMsg(pt)) {
+		sliderNum = SPEECH_SLIDER;
+		slider = &_speechVolume;
+	} else {
+		return false;
+	}
+
+	double offset = slider->getOffsetPixels();
+	sliderChanged(offset, sliderNum);
+	return true;
+}
+
+void CPetSound::getTooltip(CTextControl *text) {
+	text->setText(CHANGE_VOLUME_SETTINGS);
+}
+
+} // End of namespace Titanic