AudioOptions_gump.cc

Go to the documentation of this file.

/*
 *  Copyright (C) 2003-2004  The Exult Team
 *
 *  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.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "SDL_events.h"

#include <iostream>

#include "Audio.h"
#include "AudioOptions_gump.h"
#include "Configuration.h"
#include "Gump_button.h"
#include "Gump_ToggleButton.h"
#include "exult.h"
#include "exult_flx.h"
#include "gamewin.h"
#include "mouse.h"
#include "xmidi.h"
#include "Enabled_button.h"

using std::cerr;
using std::endl;

static const int rowy[] = { 5,  
          19, 29, 41, 53, 65, 77,  
          89, 101,  
          115, 125,  
          135, 156 };
static const int colx[] = { 35, 55, 130 };

static const char* oktext = "OK";
static const char* canceltext = "CANCEL";

class AudioOptions_button : public Text_button {
public:
  AudioOptions_button(Gump *par, const std::string &text, int px, int py)
    : Text_button(par, text, px, py, 59, 11)
    {  }
          // What to do when 'clicked':
  virtual void activate();
};

void AudioOptions_button::activate()
{
  if (text == canceltext) {
    ((AudioOptions_gump*)parent)->cancel();
  } else if (text == oktext) {
    ((AudioOptions_gump*)parent)->close();
  }
}

class AudioTextToggle : public Gump_ToggleTextButton {
public:
  AudioTextToggle(Gump* par, std::string *s, int px, int py, int width,
             int selectionnum, int numsel)
    : Gump_ToggleTextButton(par, s, selectionnum, numsel, px, py, width)
  { }

  friend class AudioOptions_gump;
  virtual void toggle(int state) { 
    ((AudioOptions_gump*)parent)->toggle((Gump_button*)this, state);
  }
};


class AudioEnabledToggle : public Enabled_button {
public:
  AudioEnabledToggle(Gump* par, int px, int py, int selectionnum)
    : Enabled_button(par, selectionnum, px, py, 59)
  { }

  friend class AudioOptions_gump;
  virtual void toggle(int state) {
    ((AudioOptions_gump*)parent)->toggle((Gump_button*)this, state);
  }
};  

void AudioOptions_gump::close()
{
  save_settings();
  done = 1;
}

void AudioOptions_gump::cancel()
{
  done = 1;
}

void AudioOptions_gump::toggle(Gump_button* btn, int state)
{
  if (btn == buttons[0]) {    // audio on/off
    audio_enabled = state;
    rebuild_buttons();
    paint();
  } else if (btn == buttons[1]) { // midi on/off 
    midi_enabled = state;
    rebuild_midi_buttons();
    paint();
  } else if (btn == buttons[2]) { // midi driver
    midi_driver = state;
    rebuild_mididriveroption_buttons();
    paint();
  } else if (btn == buttons[3]) { // midi conversion
    midi_conversion = state;
  } else if (btn == buttons[4]) { // midi reverb/chorus
    midi_reverb_chorus = state;
  } else if (btn == buttons[5]) { // midi looping
    midi_looping = state;
  } else if (btn == buttons[6]) { // sfx on/off
    sfx_enabled = state;
    rebuild_sfx_buttons();
    paint();
#ifdef ENABLE_MIDISFX
  } else if (btn == buttons[7]) { // sfx conversion
    if (state == 1) {
      sfx_conversion = XMIDI_CONVERT_GS127_TO_GS;
    } else {
      sfx_conversion = XMIDI_CONVERT_NOCONVERSION;
    }
#endif
  } else if (btn == buttons[8]) { // speech on/off
    speech_enabled = state;
  }
}

void AudioOptions_gump::rebuild_buttons()
{
  for (unsigned int i = 1; i < 9; ++i) {
    delete buttons[i];
    buttons[i] = 0;
  }

  if (!audio_enabled) return;

  // midi on/off
  buttons[1] = new AudioEnabledToggle(this, colx[2], rowy[2], midi_enabled);
  if (midi_enabled)
    rebuild_midi_buttons();
  
  // sfx on/off
  buttons[6] = new AudioEnabledToggle(this, colx[2], rowy[8], sfx_enabled);
  if (sfx_enabled)
    rebuild_sfx_buttons();
  
  // speech on/off
  buttons[8] = new AudioEnabledToggle(this,colx[2],rowy[11], speech_enabled);
}

void AudioOptions_gump::rebuild_midi_buttons()
{
  for (unsigned int i = 2; i < 6; ++i) {
    delete buttons[i];
    buttons[i] = 0;
  }

  if (!midi_enabled) return;

  std::string* midi_drivertext = new std::string[NUM_MIDI_DRIVER_TYPES];
  midi_drivertext[MIDI_DRIVER_NORMAL] = std::string("Normal");
  midi_drivertext[MIDI_DRIVER_OGG] = std::string("Digital");
#ifdef USE_FMOPL_MIDI
  midi_drivertext[MIDI_DRIVER_FMSYNTH] = std::string("FMSynth");
#endif
#ifdef USE_MT32EMU_MIDI
  midi_drivertext[MIDI_DRIVER_MT32EMU] = std::string("MT32Emu");
#endif


  // midi driver
  buttons[2] = new AudioTextToggle(this, midi_drivertext, 
                   colx[2], rowy[3], 59, midi_driver, NUM_MIDI_DRIVER_TYPES);

  rebuild_mididriveroption_buttons();

  // looping on/off
  buttons[5] = new AudioEnabledToggle(this, colx[2], rowy[6], midi_looping);

}


void AudioOptions_gump::rebuild_sfx_buttons()
{
  delete buttons[7];
  buttons[7] = 0;

  if (!sfx_enabled)
    return;

#ifdef ENABLE_MIDISFX
  std::string* sfx_conversiontext = new std::string[2];
  sfx_conversiontext[0] = "None";
  sfx_conversiontext[1] = "GS";

  // sfx conversion
  buttons[7] = new AudioTextToggle(this, sfx_conversiontext, colx[2], rowy[9],
                   59, sfx_conversion/4,2);
#endif
}

void AudioOptions_gump::rebuild_mididriveroption_buttons()
{
  delete buttons[3];
  buttons[3] = 0;
  delete buttons[4];
  buttons[4] = 0;

  std::string* midi_conversiontext = new std::string[4];
  midi_conversiontext[0] = std::string("None");
  midi_conversiontext[1] = std::string("GM");
  midi_conversiontext[2] = std::string("GS");
  midi_conversiontext[3] = std::string("GS127");

  std::string* midi_reverbchorustext = new std::string[4];
  midi_reverbchorustext[0] = std::string("Disabled");
  midi_reverbchorustext[1] = std::string("Reverb");
  midi_reverbchorustext[2] = std::string("Chorus");
  midi_reverbchorustext[3] = std::string("Both");

  if (midi_driver == MIDI_DRIVER_NORMAL) {
    // midi conversion
    buttons[3] = new AudioTextToggle(this, midi_conversiontext, 
                     colx[2], rowy[4], 59,
                     midi_conversion, 4);
    // reverb/chorus combo
    buttons[4] = new AudioTextToggle(this, midi_reverbchorustext, 
                     colx[2], rowy[5], 59,
                     midi_reverb_chorus, 4);
  }
}

void AudioOptions_gump::load_settings()
{
  std::string s;
  audio_enabled = (Audio::get_ptr()->is_audio_enabled() ? 1 : 0);
  midi_enabled = (Audio::get_ptr()->is_music_enabled() ? 1 : 0);
  sfx_enabled = (Audio::get_ptr()->are_effects_enabled() ? 1 : 0);
  speech_enabled = (Audio::get_ptr()->is_speech_enabled() ? 1 : 0);
  midi_looping = (Audio::get_ptr()->is_music_looping_allowed() ? 1 : 0);

  if (Audio::get_ptr()->get_midi()) {
    midi_conversion = Audio::get_ptr()->get_midi()->get_music_conversion();
    midi_driver = Audio::get_ptr()->get_midi()->get_output_driver_type();
#ifdef ENABLE_MIDISFX
    sfx_conversion =Audio::get_ptr()->get_midi()->get_effects_conversion();
#endif
  } else {
    // String for default value for driver type
    std::string driver_default = "normal";

    config->value("config/audio/midi/convert",s,"gm");
    if (s == "gs")
      midi_conversion = XMIDI_CONVERT_MT32_TO_GS;
    else if (s == "none")
      midi_conversion = XMIDI_CONVERT_NOCONVERSION;
    else if (s == "gs127")
      midi_conversion = XMIDI_CONVERT_MT32_TO_GS127;
    else if (s == "gs127drum")
      midi_conversion = XMIDI_CONVERT_MT32_TO_GS;
    else
    {
      midi_conversion = XMIDI_CONVERT_MT32_TO_GM;
      config->set("config/audio/midi/convert","gm",true);

      driver_default = "s";
    }

    config->value("config/audio/midi/driver",s,driver_default.c_str());
    if (s == "digital") 
    {
      midi_driver = MIDI_DRIVER_OGG;
      config->set("config/audio/effects/driver","digital",true);
    }
#ifdef USE_FMOPL_MIDI
    else if (s == "fmsynth")
    {
      midi_driver = MIDI_DRIVER_FMSYNTH;
      config->set("config/audio/effects/driver","fmsynth",true);
    }
#endif
#ifdef USE_MT32EMU_MIDI
    else if (s == "mt32emu")
      midi_driver = MIDI_DRIVER_MT32EMU;
#endif
    else
      midi_driver = MIDI_DRIVER_NORMAL;


#ifdef ENABLE_MIDISFX
    config->value("config/audio/effects/convert",s,"gs");
    if (s == "none")
      sfx_conversion = XMIDI_CONVERT_NOCONVERSION;
    else if (s == "gs127")
      sfx_conversion = XMIDI_CONVERT_NOCONVERSION;
    else
      sfx_conversion = XMIDI_CONVERT_GS127_TO_GS;
#endif
  }

  config->value("config/audio/midi/reverb/enabled",s,"no");
  midi_reverb_chorus = (s == "yes" ? 1 : 0);

  config->value("config/audio/midi/chorus/enabled",s,"no");
  midi_reverb_chorus |= (s == "yes" ? 2 : 0);
  
  
}

AudioOptions_gump::AudioOptions_gump() : Modal_gump(0, EXULT_FLX_AUDIOOPTIONS_SHP, SF_EXULT_FLX)
{
  set_object_area(Rectangle(0,0,0,0), 8, 172);//++++++ ???

  for (int i=0; i<12; i++) buttons[i] = 0;

  load_settings();

  rebuild_buttons();


  // audio on/off
    buttons[0] = new AudioEnabledToggle(this, colx[2], rowy[0], audio_enabled);
  // Ok
  buttons[9] = new AudioOptions_button(this, oktext, colx[0], rowy[12]);
  // Cancel
  buttons[10] = new AudioOptions_button(this, canceltext, colx[2], rowy[12]);
}

AudioOptions_gump::~AudioOptions_gump()
{
  for (int i=0; i<12; i++)
    if (buttons[i]) delete buttons[i];
}

void AudioOptions_gump::save_settings()
{
  Audio::get_ptr()->set_audio_enabled(audio_enabled == 1);
  Audio::get_ptr()->set_music_enabled(midi_enabled == 1);
  if (!midi_enabled)    // Stop what's playing.
    Audio::get_ptr()->stop_music();
  Audio::get_ptr()->set_effects_enabled(sfx_enabled == 1);
  if (!sfx_enabled)   // Stop what's playing.
    Audio::get_ptr()->stop_sound_effects();
  Audio::get_ptr()->set_speech_enabled(speech_enabled == 1);
  Audio::get_ptr()->set_allow_music_looping(midi_looping == 1);

  config->set("config/audio/enabled", audio_enabled ? "yes" : "no", true);
  config->set("config/audio/midi/enabled",midi_enabled ? "yes" : "no", true);
  config->set("config/audio/effects/enabled",sfx_enabled?"yes":"no", true);
  config->set("config/audio/speech/enabled",speech_enabled?"yes":"no", true);

  config->set("config/audio/midi/chorus/enabled", (midi_reverb_chorus&2) ? "yes" : "no", true);
  config->set("config/audio/midi/reverb/enabled", (midi_reverb_chorus&1)? "yes" : "no", true);
  config->set("config/audio/midi/looping", midi_looping ? "yes" : "no", true);

  if (Audio::get_ptr()->get_midi()) {
    Audio::get_ptr()->get_midi()->set_music_conversion(midi_conversion);
    Audio::get_ptr()->get_midi()->set_effects_conversion(sfx_conversion);
    Audio::get_ptr()->get_midi()->set_output_driver_type(midi_driver);
  } else {
    switch(midi_conversion) {
    case XMIDI_CONVERT_MT32_TO_GS:
      config->set("config/audio/midi/convert","gs",true);
      break;
    case XMIDI_CONVERT_NOCONVERSION:
      config->set("config/audio/midi/convert","none",true);
      break;
    case XMIDI_CONVERT_MT32_TO_GS127:
      config->set("config/audio/midi/convert","gs127",true);
      break;
    default:
      config->set("config/audio/midi/convert","gm",true);
      break;
    }

    switch(midi_driver) {
    case MIDI_DRIVER_OGG:
      config->set("config/audio/midi/driver","digital",true);
      break;
#ifdef USE_FMOPL_MIDI
    case MIDI_DRIVER_FMSYNTH:
      config->set("config/audio/midi/driver","fmsynth",true);
      break;
#endif
#ifdef USE_MT32EMU_MIDI
    case MIDI_DRIVER_MT32EMU:
      config->set("config/audio/midi/driver","mt32emu",true);
      break;
#endif
    default:
      config->set("config/audio/midi/driver","normal",true);
      break;
    }

#ifdef ENABLE_MIDISFX
    switch(sfx_conversion) {
    case XMIDI_CONVERT_NOCONVERSION:
      config->set("config/audio/effects/convert","none",true);
      break;
    default:
      config->set("config/audio/effects/convert","gs",true);
      break;
    }
#endif
  }
}

void AudioOptions_gump::paint()
{
  Gump::paint();
  for (int i=0; i<11; i++)
    if (buttons[i])
      buttons[i]->paint();

  sman->paint_text(2, "Audio:", x + colx[0], y + rowy[0] + 1);
  if (audio_enabled) {
    sman->paint_text(2, "Music options:", x + colx[0], y + rowy[1] + 1);
    sman->paint_text(2, "music", x + colx[1], y + rowy[2] + 1);
    if (midi_enabled) {
      sman->paint_text(2, "driver", x + colx[1], y + rowy[3] + 1);
      if (midi_driver == MIDI_DRIVER_NORMAL) {
        sman->paint_text(2, "conversion", x+colx[1], y+rowy[4] + 1);
        sman->paint_text(2, "effects", x + colx[1], y + rowy[5] + 1);
      }
      sman->paint_text(2, "looping", x + colx[1], y + rowy[6] + 1);
    }
    sman->paint_text(2, "SFX options:", x + colx[0], y + rowy[7] + 1);
    sman->paint_text(2, "SFX", x + colx[1], y + rowy[8] + 1);
#ifdef ENABLE_MIDISFX
    if (sfx_enabled) {
      sman->paint_text(2, "conversion", x + colx[1], y + rowy[9] + 1);
    }
#endif
    sman->paint_text(2, "Speech options:", x + colx[0], y + rowy[10] + 1);
    sman->paint_text(2, "speech", x + colx[1], y + rowy[11] + 1);
  }
  gwin->set_painted();
}

void AudioOptions_gump::mouse_down(int mx, int my)
{
  pushed = Gump::on_button(mx, my);
          // First try checkmark.
  // Try buttons at bottom.
  if (!pushed)
    for (int i=0; i<11; i++)
      if (buttons[i] && buttons[i]->on_button(mx, my)) {
        pushed = buttons[i];
        break;
      }

  if (pushed)     // On a button?
  {
    pushed->push();
    return;
  }
}

void AudioOptions_gump::mouse_up(int mx, int my)
{
  if (pushed)     // Pushing a button?
  {
    pushed->unpush();
    if (pushed->on_button(mx, my))
      ((Gump_button*)pushed)->activate();
    pushed = 0;
  }
}

---