Ticket #8860: midicfg_V2.patch

File midicfg_V2.patch, 25.5 KB (added by athrxx, 12 years ago)

launcher patch new version

  • backends/midi/windows.cpp

     
    2929#include <mmsystem.h>
    3030#include "sound/mpu401.h"
    3131#include "common/util.h"
     32#include "common/config-manager.h"
    3233
    3334////////////////////////////////////////
    3435//
     
    4344        HANDLE _streamEvent;
    4445        HMIDIOUT _mo;
    4546        bool _isOpen;
     47       
     48        struct MidiCps {
     49                Common::String name;
     50                MidiDeviceFeatures features;
     51        } *_devs;
    4652
     53        int _numDevs;
     54        int _activeDev;
     55        int _volLeft;
     56        int _volRight;
     57
    4758        void check_error(MMRESULT result);
     59        MMRESULT updateActiveDeviceVolume();
    4860
    4961public:
    50         MidiDriver_WIN() : _isOpen(false) { }
     62        MidiDriver_WIN();
     63        ~MidiDriver_WIN();
    5164        int open();
    5265        void close();
    5366        void send(uint32 b);
    5467        void sysEx(const byte *msg, uint16 length);
     68
     69        int detectDevices();
     70        int setActiveDevice(int id);
     71        int getActiveDevice();
     72        MidiDeviceFeatures getDeviceFeatures(int id);
     73        Common::String getDeviceName(int id);
     74        int getDeviceId(Common::String deviceName);     
    5575};
    5676
     77MidiDriver_WIN::MidiDriver_WIN() : _isOpen(false), _devs(0), _numDevs(0), _activeDev(0), _volLeft(0xffff), _volRight(0xffff) {
     78        detectDevices();
     79}
     80
     81MidiDriver_WIN::~MidiDriver_WIN() {
     82        delete [] _devs;
     83}
     84
    5785int MidiDriver_WIN::open() {
    5886        if (_isOpen)
    5987                return MERR_ALREADY_OPEN;
    6088
    6189        _streamEvent = CreateEvent(NULL, true, true, NULL);
    62         MMRESULT res = midiOutOpen((HMIDIOUT *)&_mo, MIDI_MAPPER, (unsigned long)_streamEvent, 0, CALLBACK_EVENT);
     90        MMRESULT res = midiOutOpen((HMIDIOUT *)&_mo, getActiveDevice(), (unsigned long)_streamEvent, 0, CALLBACK_EVENT);
    6391        if (res != MMSYSERR_NOERROR) {
    6492                check_error(res);
    6593                CloseHandle(_streamEvent);
    6694                return MERR_DEVICE_NOT_AVAILABLE;
    67         }
     95        }       
    6896
    6997        _isOpen = true;
     98        updateActiveDeviceVolume();
     99
    70100        return 0;
    71101}
    72102
     
    141171        }
    142172}
    143173
     174int MidiDriver_WIN::detectDevices() {
     175        delete [] _devs;
     176       
     177        _numDevs = midiOutGetNumDevs();
     178        if (!_numDevs)
     179                return -1;
     180
     181        _devs = new MidiCps[_numDevs];
     182        MIDIOUTCAPS tmp;
     183
     184        for (int i = 0; i < _numDevs; i++) {
     185                if (midiOutGetDevCaps(i, &tmp, sizeof(MIDIOUTCAPS)) != MMSYSERR_NOERROR)
     186                        break;
     187                _devs[i].name = tmp.szPname;
     188                _devs[i].features = (MidiDeviceFeatures) (tmp.dwSupport & (MIDICAPS_VOLUME | MIDICAPS_LRVOLUME));
     189        }
     190
     191        return _numDevs;
     192}
     193
     194int MidiDriver_WIN::setActiveDevice(int id) {
     195        if (_isOpen)
     196                return 1;
     197
     198        if (id > -1 && id < _numDevs) {
     199                _activeDev = id;
     200                return 0;
     201        }
     202
     203        return -1;
     204}
     205
     206int MidiDriver_WIN::getActiveDevice() {
     207        _activeDev = _activeDev ? _activeDev : 
     208                (ConfMan.hasKey("music_driver") ? getDeviceId(ConfMan.get("music_driver")) : 0);
     209        return _activeDev;
     210}
     211
     212MidiDriver::MidiDeviceFeatures MidiDriver_WIN::getDeviceFeatures(int id) {
     213        if (id > -1 && id < _numDevs)
     214                return _devs[id].features;
     215
     216        return kMidiFeatsNone;
     217}
     218
     219Common::String MidiDriver_WIN::getDeviceName(int id) {
     220        if (id > -1 && id < _numDevs)
     221                return _devs[id].name;
     222
     223        return Common::String("");
     224}
     225
     226int MidiDriver_WIN::getDeviceId(Common::String deviceName) {
     227        for (int i = 0; i < _numDevs; i++) {
     228                if (deviceName.equals(_devs[i].name))
     229                        return i;               
     230        }
     231
     232        return -1;
     233}
     234
     235MMRESULT MidiDriver_WIN::updateActiveDeviceVolume() {
     236        int left = ConfMan.hasKey("mididevice_volume_left") ? ConfMan.getInt("mididevice_volume_left") << 8 : -1;
     237        int right = ConfMan.hasKey("mididevice_volume_right") ? ConfMan.getInt("mididevice_volume_right") << 8 : 0;
     238        MidiDeviceFeatures s = _devs[getActiveDevice()].features;
     239
     240        if (_isOpen && (s & kMidiFeatsVolume) && left != -1) {
     241                if (left == 0x10000)
     242                        left--;
     243                if (right == 0x10000)
     244                        right--;
     245                if (!(_devs[getActiveDevice()].features & kMidiFeatsVolumeLR))
     246                        right = left;
     247                return midiOutSetVolume(_mo, (right << 16) | (left & 0xffff));
     248        }
     249
     250        return MMSYSERR_NOTSUPPORTED;
     251}
     252
    144253MidiDriver *MidiDriver_WIN_create() {
    145254        return new MidiDriver_WIN();
    146255}
  • gui/launcher.cpp

     
    7070        kCmdGlobalMIDIOverride = 'OMID',
    7171        kCmdGlobalVolumeOverride = 'OVOL',
    7272
     73        kCmdChooseMidiDriverCmd = 'chmd',
    7374        kCmdChooseSoundFontCmd = 'chsf',
    7475
    7576        kCmdExtraBrowser = 'PEXT',
     
    404405                break;
    405406        }
    406407
     408        case kCmdChooseMidiDriverCmd: {
     409                updateMidiDevVolumeCtrls(_midiPopUp->getSelectedTag());
     410                break;
     411        }
     412
    407413        // Change path for the game
    408414        case kCmdGameBrowser: {
    409415                BrowserDialog browser("Select directory with game data", true);
  • gui/options.cpp

     
    5050        kSubtitleToggle                 = 'sttg',
    5151        kSubtitleSpeedChanged   = 'stsc',
    5252        kSpeechVolumeChanged    = 'vcvc',
     53        kMidiDevLeftVolChanged  = 'mlvc',
     54        kMidiDevRightVolChanged = 'mrvc',
     55        kChooseMidiDriverCmd    = 'chmd',
    5356        kChooseSoundFontCmd             = 'chsf',
    5457        kClearSoundFontCmd      = 'clsf',
    5558        kChooseSaveDirCmd               = 'chos',
     
    110113        _speechVolumeDesc = 0;
    111114        _speechVolumeSlider = 0;
    112115        _speechVolumeLabel = 0;
     116        _mididevLeftVolumeDesc = 0;
     117        _mididevLeftVolumeSlider = 0;
     118        _mididevLeftVolumeLabel = 0;
     119        _mididevRightVolumeDesc = 0;
     120        _mididevRightVolumeSlider = 0;
     121        _mididevRightVolumeLabel = 0;
    113122        _subToggleDesc = 0;
    114123        _subToggleButton = 0;
    115124        _subSpeedDesc = 0;
     
    166175        // Audio options
    167176        if (_midiPopUp) {
    168177                // Music driver
    169                 const MidiDriverDescription *md = MidiDriver::getAvailableMidiDrivers();
    170                 int i = 0;
    171                 const int midiDriver =
    172                         ConfMan.hasKey("music_driver", _domain)
    173                                 ? MidiDriver::parseMusicDriver(ConfMan.get("music_driver", _domain))
    174                                 : MD_AUTO;
    175                 while (md->name && md->id != midiDriver) {
    176                         i++;
    177                         md++;
    178                 }
    179                 _midiPopUp->setSelected(md->name ? i : 0);
     178                int midiDriver = ConfMan.hasKey("music_driver", _domain)?
     179                        MidiDriver::parseMusicDriverEx(ConfMan.get("music_driver", _domain)) : MD_AUTO;
     180
     181                _midiPopUp->setSelectedTag(midiDriver);
     182                if (_midiPopUp->getSelectedString().empty()) // midi device turned off or whatever
     183                        _midiPopUp->setSelected(0);
    180184        }
    181185
    182186        if (_outputRatePopUp) {
     
    231235                vol = ConfMan.getInt("speech_volume", _domain);
    232236                _speechVolumeSlider->setValue(vol);
    233237                _speechVolumeLabel->setValue(vol);
     238
     239                vol = ConfMan.hasKey("mididevice_volume_left", _domain) ? ConfMan.getInt("mididevice_volume_left", _domain) : 192;
     240                _mididevLeftVolumeSlider->setValue(vol);
     241                _mididevLeftVolumeLabel->setValue(vol);
     242
     243                vol = ConfMan.hasKey("mididevice_volume_right", _domain) ? ConfMan.getInt("mididevice_volume_right", _domain) : 192;
     244                _mididevRightVolumeSlider->setValue(vol);
     245                _mididevRightVolumeLabel->setValue(vol);
    234246        }
    235247
    236248        // Subtitle options
     
    291303                                ConfMan.setInt("music_volume", _musicVolumeSlider->getValue(), _domain);
    292304                                ConfMan.setInt("sfx_volume", _sfxVolumeSlider->getValue(), _domain);
    293305                                ConfMan.setInt("speech_volume", _speechVolumeSlider->getValue(), _domain);
     306
     307                                int drv = _midiPopUp->isEnabled() ? _midiPopUp->getSelectedTag() : -1;
     308                                int dev = -1;
     309                                MidiDriver::MidiDeviceFeatures ftr =  MidiDriver::kMidiFeatsNone;
     310
     311                                if (drv != -1) {
     312                                        dev = ((drv >> 8) & 0xff) - 1;
     313                                        ftr = (MidiDriver::MidiDeviceFeatures) (drv >> 16);
     314                                        drv &= 0xff;
     315                                }
     316
     317                                if (drv > 0 && dev > -1) {
     318                                        if (ftr & MidiDriver::kMidiFeatsVolumeLR) {
     319                                                ConfMan.setInt("mididevice_volume_left", _mididevLeftVolumeSlider->getValue(), _domain);
     320                                                ConfMan.setInt("mididevice_volume_right", _mididevRightVolumeSlider->getValue(), _domain);
     321                                        } else if (ftr & MidiDriver::kMidiFeatsVolume) {
     322                                                ConfMan.setInt("mididevice_volume_left", _mididevLeftVolumeSlider->getValue(), _domain);
     323                                                ConfMan.removeKey("mididevice_volume_right", _domain);
     324                                        } else {
     325                                                ConfMan.removeKey("mididevice_volume_left", _domain);
     326                                                ConfMan.removeKey("mididevice_volume_right", _domain); 
     327                                        }               
     328                                } else {
     329                                        ConfMan.removeKey("mididevice_volume_left", _domain);
     330                                        ConfMan.removeKey("mididevice_volume_right", _domain);
     331                                }
    294332                        } else {
    295333                                ConfMan.removeKey("music_volume", _domain);
    296334                                ConfMan.removeKey("sfx_volume", _domain);
    297335                                ConfMan.removeKey("speech_volume", _domain);
     336                                ConfMan.removeKey("mididevice_volume_left", _domain);
     337                                ConfMan.removeKey("mididevice_volume_right", _domain);
    298338                        }
    299339                }
    300340
     
    302342                if (_midiPopUp) {
    303343                        if (_enableAudioSettings) {
    304344                                const MidiDriverDescription *md = MidiDriver::getAvailableMidiDrivers();
    305                                 while (md->name && md->id != (int)_midiPopUp->getSelectedTag())
     345                                int drv = (int) _midiPopUp->getSelectedTag() & 0xff;
     346                                int dev = (int) ((_midiPopUp->getSelectedTag() >> 8) & 0xff) - 1;
     347                                while (md->name && md->id != drv)
    306348                                        md++;
    307                                 if (md->name)
    308                                         ConfMan.set("music_driver", md->name, _domain);
     349                               
     350                                Common::String confStr;
     351                                if (dev > -1) {
     352                                        MidiDriver *m = MidiDriver::createMidi(md->id);
     353                                        if (m) {
     354                                                confStr = m->getDeviceName(dev);
     355                                                delete m;
     356                                        }
     357                                } else {
     358                                        confStr = Common::String(md->name);
     359                                }
     360
     361                                if (!confStr.empty())
     362                                        ConfMan.set("music_driver", confStr, _domain);
    309363                                else
    310364                                        ConfMan.removeKey("music_driver", _domain);
    311365                        } else {
     
    410464                _speechVolumeLabel->setValue(_speechVolumeSlider->getValue());
    411465                _speechVolumeLabel->draw();
    412466                break;
     467        case kMidiDevLeftVolChanged:
     468                _mididevLeftVolumeLabel->setValue(_mididevLeftVolumeSlider->getValue());
     469                _mididevLeftVolumeLabel->draw();
     470                break;
     471        case kMidiDevRightVolChanged:
     472                _mididevRightVolumeLabel->setValue(_mididevRightVolumeSlider->getValue());
     473                _mididevRightVolumeLabel->draw();
     474                break;
    413475        case kSubtitleToggle:
    414476                if (_subMode < 2)
    415477                        _subMode++;
     
    484546        _speechVolumeDesc->setEnabled(enabled);
    485547        _speechVolumeSlider->setEnabled(enabled);
    486548        _speechVolumeLabel->setEnabled(enabled);
     549
     550        updateMidiDevVolumeCtrls(_midiPopUp->getSelectedTag());
    487551}
    488552
    489553void OptionsDialog::setSubtitleSettingsState(bool enabled) {
     
    539603        int labelWidth = g_gui.evaluator()->getVar("tabPopupsLabelW");
    540604
    541605        // The MIDI mode popup & a label
    542         _midiPopUp = new PopUpWidget(boss, prefix + "auMidiPopup", "Music driver:", labelWidth);
     606        _midiPopUp = new PopUpWidget(boss, prefix + "auMidiPopup", "Music driver:", labelWidth, kChooseMidiDriverCmd);
    543607
    544608        // Populate it
    545609        const MidiDriverDescription *md = MidiDriver::getAvailableMidiDrivers();
    546610        while (md->name) {
    547                 _midiPopUp->appendEntry(md->description, md->id);
     611                if (md->id > 0) {
     612                        MidiDriver *m = MidiDriver::createMidi(md->id);
     613                        if (m) {
     614                                if (m->detectDevices() != -1) {
     615                                        for (int i = 0; !m->getDeviceName(i).empty(); i++)
     616                                                _midiPopUp->appendEntry(m->getDeviceName(i),
     617                                                        (((int) m->getDeviceFeatures(i)) << 16 | (i + 1) << 8) | (md->id));
     618                                } else {
     619                                        _midiPopUp->appendEntry(md->description, md->id);
     620                                }
     621                                delete m;
     622                        }
     623                } else {
     624                        _midiPopUp->appendEntry(md->description, md->id);
     625                }
    548626                md++;
    549627        }
    550628
     
    624702        _speechVolumeSlider->setMaxValue(Audio::Mixer::kMaxMixerVolume);
    625703        _speechVolumeLabel->setFlags(WIDGET_CLEARBG);
    626704
     705        _mididevLeftVolumeDesc = new StaticTextWidget(boss, prefix + "vcMidiDevLeftText" , "Midi dev. vol. L:");
     706        _mididevLeftVolumeSlider = new SliderWidget(boss, prefix + "vcMidiDevLeftSlider", kMidiDevLeftVolChanged);
     707        _mididevLeftVolumeLabel = new StaticTextWidget(boss, prefix + "vcMidiDevLeftLabel", "100%");
     708        _mididevLeftVolumeSlider->setMinValue(0);
     709        _mididevLeftVolumeSlider->setMaxValue(Audio::Mixer::kMaxMixerVolume);
     710        _mididevLeftVolumeLabel->setFlags(WIDGET_CLEARBG);
     711
     712        _mididevRightVolumeDesc = new StaticTextWidget(boss, prefix + "vcMidiDevRightText" , "Midi dev. vol. R:");
     713        _mididevRightVolumeSlider = new SliderWidget(boss, prefix + "vcMidiDevRightSlider", kMidiDevRightVolChanged);
     714        _mididevRightVolumeLabel = new StaticTextWidget(boss, prefix + "vcMidiDevRightLabel", "100%");
     715        _mididevRightVolumeSlider->setMinValue(0);
     716        _mididevRightVolumeSlider->setMaxValue(Audio::Mixer::kMaxMixerVolume);
     717        _mididevRightVolumeLabel->setFlags(WIDGET_CLEARBG);
     718
     719        updateMidiDevVolumeCtrls(ConfMan.hasKey("music_driver", _domain) ?
     720                MidiDriver::parseMusicDriverEx(ConfMan.get("music_driver", _domain)) : -1);
    627721        _enableVolumeSettings = true;
    628722}
    629723
     724       
     725void OptionsDialog::updateMidiDevVolumeCtrls(int drvTag) {
     726        bool disableAll = false;
     727
     728        MidiDriver::MidiDeviceFeatures f = (MidiDriver::MidiDeviceFeatures) (drvTag >> 16);
     729
     730        if (_midiPopUp) {       
     731                bool volst = _musicVolumeDesc->isEnabled();
     732                if (drvTag > -1) {
     733                        if (f & MidiDriver::kMidiFeatsVolumeLR) {
     734                                _mididevLeftVolumeDesc->setLabel("Midi dev. vol. L:");
     735                                _mididevLeftVolumeDesc->setEnabled(volst);
     736                                _mididevLeftVolumeSlider->setEnabled(volst);
     737                                _mididevLeftVolumeLabel->setEnabled(volst);
     738                                _mididevRightVolumeDesc->setEnabled(volst);
     739                                _mididevRightVolumeSlider->setEnabled(volst);
     740                                _mididevRightVolumeLabel->setEnabled(volst);
     741                                _mididevLeftVolumeDesc->clearFlags(WIDGET_INVISIBLE);
     742                                _mididevLeftVolumeSlider->clearFlags(WIDGET_INVISIBLE);
     743                                _mididevLeftVolumeLabel->clearFlags(WIDGET_INVISIBLE);
     744                                _mididevRightVolumeDesc->clearFlags(WIDGET_INVISIBLE);
     745                                _mididevRightVolumeSlider->clearFlags(WIDGET_INVISIBLE);
     746                                _mididevRightVolumeLabel->clearFlags(WIDGET_INVISIBLE);
     747                        } else if (f & MidiDriver::kMidiFeatsVolume) {
     748                                _mididevLeftVolumeDesc->setLabel("Midi dev. volume:");
     749                                _mididevLeftVolumeDesc->setEnabled(volst);
     750                                _mididevLeftVolumeSlider->setEnabled(volst);
     751                                _mididevLeftVolumeLabel->setEnabled(volst);
     752                                _mididevLeftVolumeDesc->clearFlags(WIDGET_INVISIBLE);
     753                                _mididevLeftVolumeSlider->clearFlags(WIDGET_INVISIBLE);
     754                                _mididevLeftVolumeLabel->clearFlags(WIDGET_INVISIBLE);
     755                                _mididevRightVolumeDesc->setEnabled(false);
     756                                _mididevRightVolumeSlider->setEnabled(false);
     757                                _mididevRightVolumeLabel->setEnabled(false);
     758                                _mididevRightVolumeDesc->setFlags(WIDGET_INVISIBLE);
     759                                _mididevRightVolumeSlider->setFlags(WIDGET_INVISIBLE);
     760                                _mididevRightVolumeLabel->setFlags(WIDGET_INVISIBLE);
     761                        } else {
     762                                disableAll = true;
     763                        }               
     764                } else {
     765                        disableAll = true;
     766                }
     767        } else {
     768                disableAll = true;
     769        }
     770
     771        if (disableAll) {
     772                _mididevLeftVolumeDesc->setEnabled(false);
     773                _mididevLeftVolumeSlider->setEnabled(false);
     774                _mididevLeftVolumeLabel->setEnabled(false);
     775                _mididevLeftVolumeDesc->setFlags(WIDGET_INVISIBLE);
     776                _mididevLeftVolumeSlider->setFlags(WIDGET_INVISIBLE);
     777                _mididevLeftVolumeLabel->setFlags(WIDGET_INVISIBLE);
     778                _mididevRightVolumeDesc->setEnabled(false);
     779                _mididevRightVolumeSlider->setEnabled(false);
     780                _mididevRightVolumeLabel->setEnabled(false);
     781                _mididevRightVolumeDesc->setFlags(WIDGET_INVISIBLE);
     782                _mididevRightVolumeSlider->setFlags(WIDGET_INVISIBLE);
     783                _mididevRightVolumeLabel->setFlags(WIDGET_INVISIBLE);
     784        }
     785}
     786
    630787int OptionsDialog::getSubtitleMode(bool subtitles, bool speech_mute) {
    631788        if (!subtitles && !speech_mute) // Speech only
    632789                return 0;
     
    8441001                }
    8451002                break;
    8461003        }
     1004        // update midi device list when a new midi driver is selected
     1005        case kChooseMidiDriverCmd: {
     1006                updateMidiDevVolumeCtrls(_midiPopUp->getSelectedTag());
     1007                break;
     1008        }
     1009
    8471010        case kChooseSoundFontCmd: {
    8481011                BrowserDialog browser("Select SoundFont", false);
    8491012                if (browser.runModal() > 0) {
  • gui/options.h

     
    6666        ButtonWidget *_soundFontButton;
    6767        StaticTextWidget *_soundFont;
    6868        ButtonWidget *_soundFontClearButton;
     69       
     70        PopUpWidget *_midiPopUp;
    6971
     72        StaticTextWidget *_musicVolumeDesc;
     73        SliderWidget *_musicVolumeSlider;
     74        StaticTextWidget *_musicVolumeLabel;
     75       
     76        StaticTextWidget *_mididevLeftVolumeDesc;
     77        SliderWidget *_mididevLeftVolumeSlider;
     78        StaticTextWidget *_mididevLeftVolumeLabel;
     79
     80        StaticTextWidget *_mididevRightVolumeDesc;
     81        SliderWidget *_mididevRightVolumeSlider;
     82        StaticTextWidget *_mididevRightVolumeLabel;
     83
    7084        void addGraphicControls(GuiObject *boss, const String &prefix);
    7185        void addAudioControls(GuiObject *boss, const String &prefix);
    7286        void addMIDIControls(GuiObject *boss, const String &prefix);
     
    8195        void setVolumeSettingsState(bool enabled);
    8296        void setSubtitleSettingsState(bool enabled);
    8397
     98        void updateMidiDevVolumeCtrls(int drvTag);
     99
    84100private:
    85101        //
    86102        // Graphics controls
     
    95111        // Audio controls
    96112        //
    97113        bool _enableAudioSettings;
    98         PopUpWidget *_midiPopUp;
    99114        PopUpWidget *_outputRatePopUp;
    100115
    101116        //
     
    127142        //
    128143        bool _enableVolumeSettings;
    129144
    130         StaticTextWidget *_musicVolumeDesc;
    131         SliderWidget *_musicVolumeSlider;
    132         StaticTextWidget *_musicVolumeLabel;
    133 
    134145        StaticTextWidget *_sfxVolumeDesc;
    135146        SliderWidget *_sfxVolumeSlider;
    136147        StaticTextWidget *_sfxVolumeLabel;
  • gui/PopUpWidget.cpp

     
    355355// PopUpWidget
    356356//
    357357
    358 PopUpWidget::PopUpWidget(GuiObject *boss, const String &name, const String &label, uint labelWidth)
     358PopUpWidget::PopUpWidget(GuiObject *boss, const String &name, const String &label, uint labelWidth, int cmd)
    359359        : Widget(boss, name), CommandSender(boss), _label(label), _labelWidth(labelWidth) {
    360360        setFlags(WIDGET_ENABLED | WIDGET_CLEARBG | WIDGET_RETAIN_FOCUS);
    361361        setHints(THEME_HINT_SAVE_BACKGROUND);
    362362        _type = kPopUpWidget;
    363363
     364        _cmd = cmd ? cmd : kPopUpItemSelectedCmd;
     365
    364366        _selectedItem = -1;
    365367
    366368        if (!_label.empty() && _labelWidth == 0)
     
    373375                int newSel = popupDialog.runModal();
    374376                if (newSel != -1 && _selectedItem != newSel) {
    375377                        _selectedItem = newSel;
    376                         sendCommand(kPopUpItemSelectedCmd, _entries[_selectedItem].tag);
     378                        sendCommand(_cmd, _entries[_selectedItem].tag);
    377379                }
    378380                g_gui.clearDragWidget();
    379381        }
  • gui/PopUpWidget.h

     
    5757
    5858        String                  _label;
    5959        uint                    _labelWidth;
     60        int                             _cmd;
    6061
    6162        int                             _leftPadding;
    6263        int                             _rightPadding;
    6364        int                             _labelSpacing;
    6465
    6566public:
    66         PopUpWidget(GuiObject *boss, const String &name, const String &label, uint labelWidth = 0);
     67        PopUpWidget(GuiObject *boss, const String &name, const String &label, uint labelWidth = 0, int cmd = 0);
    6768
    6869        void changeLabelWidth(uint newWidth) { _labelWidth = newWidth; }
    6970
  • gui/theme-config.cpp

     
    419419"vcSpeechSlider=vcxoff opYoffset sliderWidth sliderHeight\n"
    420420"vcSpeechLabel=(vcxoff + prev.w + 10) (opYoffset + 2) 24 kLineHeight\n"
    421421"opYoffset=(opYoffset + sliderHeight + vcAudioTabSpacing)\n"
     422"vcMidiDevLeftText=vcx (opYoffset + 2) vctextw kLineHeight\n"
     423"vcMidiDevLeftText.align=kTextAlignRight\n"
     424"vcMidiDevLeftSlider=vcxoff opYoffset sliderWidth sliderHeight\n"
     425"vcMidiDevLeftLabel=(vcxoff + prev.w + 10) (opYoffset + 2) 24 kLineHeight\n"
     426"opYoffset=(opYoffset + sliderHeight + vcAudioTabSpacing)\n"
     427"vcMidiDevRightText=vcx (opYoffset + 2) vctextw kLineHeight\n"
     428"vcMidiDevRightText.align=kTextAlignRight\n"
     429"vcMidiDevRightSlider=vcxoff opYoffset sliderWidth sliderHeight\n"
     430"vcMidiDevRightLabel=(vcxoff + prev.w + 10) (opYoffset + 2) 24 kLineHeight\n"
     431"opYoffset=(opYoffset + sliderHeight + vcAudioTabSpacing)\n"
    422432"\n"
    423433"[midiControls]\n"
    424434"mcx=10\n"
  • gui/themes/classic080.ini

     
    337337vcSpeechSlider=vcxoff opYoffset sliderWidth sliderHeight
    338338vcSpeechLabel=(vcxoff + prev.w + 10) (opYoffset + 2) 24 kLineHeight
    339339opYoffset=(opYoffset + sliderHeight + vcAudioTabSpacing)
     340vcMidiDevLeftText=vcx (opYoffset + 2) vctextw kLineHeight
     341vcMidiDevLeftText.align=kTextAlignRight
     342vcMidiDevLeftSlider=vcxoff opYoffset sliderWidth sliderHeight
     343vcMidiDevLeftLabel=(vcxoff + prev.w + 10) (opYoffset + 2) 24 kLineHeight
     344opYoffset=(opYoffset + sliderHeight + vcAudioTabSpacing)
     345vcMidiDevRightText=vcx (opYoffset + 2) vctextw kLineHeight
     346vcMidiDevRightText.align=kTextAlignRight
     347vcMidiDevRightSlider=vcxoff opYoffset sliderWidth sliderHeight
     348vcMidiDevRightLabel=(vcxoff + prev.w + 10) (opYoffset + 2) 24 kLineHeight
     349opYoffset=(opYoffset + sliderHeight + vcAudioTabSpacing)
    340350
    341351[midiControls]
    342352mcx=10
  • gui/themes/modern.ini

     
    513513vcSpeechSlider=(prev.x2 + xSeparation) opYoffset sliderWidth sliderHeight
    514514vcSpeechLabel=(prev.x2 + xSeparation) (opYoffset + vcOff) 24 kLineHeight
    515515opYoffset=(opYoffset + sliderHeight + ySeparation)
     516vcMidiDevLeftText=vcx (opYoffset + vcOff) optionsLabelWidth kLineHeight
     517vcMidiDevLeftText.align=kTextAlignRight
     518vcMidiDevLeftSlider=(prev.x2 + xSeparation) opYoffset sliderWidth sliderHeight
     519vcMidiDevLeftLabel=(prev.x2 + xSeparation) (opYoffset + vcOff) 24 kLineHeight
     520opYoffset=(opYoffset + sliderHeight + ySeparation)
     521vcMidiDevRightText=vcx (opYoffset + vcOff) optionsLabelWidth kLineHeight
     522vcMidiDevRightText.align=kTextAlignRight
     523vcMidiDevRightSlider=(prev.x2 + xSeparation) opYoffset sliderWidth sliderHeight
     524vcMidiDevRightLabel=(prev.x2 + xSeparation) (opYoffset + vcOff) 24 kLineHeight
     525opYoffset=(opYoffset + sliderHeight + ySeparation)
    516526
    517527[midiControls]
    518528mcx=(opXoffset + xBorder)
     
    576586use=colors
    577587use=gradients
    578588use=extra
    579 shadow_right_width=1
    580589pix_checkbox_empty="checkbox_empty320.bmp"
    581590pix_checkbox_checked="checkbox_checked320.bmp"
    582591pix_cursor_image="cursor320.bmp"
  • sound/mididrv.cpp

     
    138138                // contained in str.
    139139                if (!scumm_strnicmp(md->name, s, len)) {
    140140                        return *md;
     141                } else if (md->id > 0) {
     142                        // If the strings don't match we also check the names
     143                        // of the devices detected through the current driver.
     144                        MidiDriver *m = MidiDriver::createMidi(md->id);
     145                        if (m) {
     146                                if (m->detectDevices() != -1) {
     147                                        for (int i = 0; !m->getDeviceName(i).empty(); i++) {
     148                                                if (str.equals(m->getDeviceName(i))) {
     149                                                        delete m;
     150                                                        return *md;
     151                                                }
     152                                        }
     153                                }
     154                                delete m;
     155                        }
    141156                }
    142157                md++;
    143158        }
     
    146161}
    147162
    148163int MidiDriver::parseMusicDriver(const Common::String &str) {
    149         return findMusicDriver(str).id;
     164        return findMusicDriver(str).id;                 
    150165}
    151166
     167int MidiDriver::parseMusicDriverEx(const Common::String &str) {
     168        int id = parseMusicDriver(str);
     169
     170        if (id > 0) {
     171                MidiDriver *m = MidiDriver::createMidi(id);
     172                if (m) {
     173                        if (m->detectDevices() != -1) {
     174                                for (int i = 0; !m->getDeviceName(i).empty(); i++) {
     175                                        if (str.equals(m->getDeviceName(i))) {
     176                                                int t = (int) m->getDeviceFeatures(i);
     177                                                delete m;
     178                                                return ((t << 16) | ((i + 1) << 8) | (id));
     179                                        }
     180                                }
     181                        }
     182                        delete m;
     183                }
     184        }
     185
     186        return id;
     187}       
     188
    152189static int getDefaultMIDIDriver() {
    153190#if defined(WIN32) && !defined(_WIN32_WCE) &&  !defined(__SYMBIAN32__)
    154191        return MD_WINDOWS;
  • sound/mididrv.h

     
    2828
    2929#include "common/scummsys.h"
    3030#include "common/timer.h"
     31#include "common/str.h"
    3132
    3233class MidiChannel;
    3334namespace Audio {
     
    131132        /** Convert a string containing a music driver name into MIDI Driver type. */
    132133        static int parseMusicDriver(const Common::String &str);
    133134
     135        /** Convert a string containing a scummvm music driver name or a external
     136        midi device name into MIDI Driver type (byte 0), device id (byte 1) and
     137        device features (byte 2). A device id of zero indicates that the scummvm
     138        music driver doesn't support external devices (so the first actual device
     139        gets an id of 1). */
     140        static int parseMusicDriverEx(const Common::String &str);
     141
    134142        /**
    135143         * Get a list of all available MidiDriver types.
    136144         * @return list of all available midi drivers, terminated by  a zero entry
     
    234242        // Channel allocation functions
    235243        virtual MidiChannel *allocateChannel() = 0;
    236244        virtual MidiChannel *getPercussionChannel() = 0;
     245
     246        // device config
     247        enum MidiDeviceFeatures {
     248                kMidiFeatsNone          = 0,
     249                kMidiFeatsVolume        = 1,
     250                kMidiFeatsVolumeLR      = 2
     251        };
     252
     253        /**     Return values:
     254         *      Success:        number of detected devices
     255         *      Failure:        -1 (no devices detected)
     256         */
     257        virtual int detectDevices() { return -1; }
     258
     259        /**     Return values:
     260         *      Success:                                                0
     261         *      Failure / invalid id:                   -1
     262         *      Failure / device already open:  1
     263         */
     264        virtual int setActiveDevice(int id) { return -1; }
     265
     266        /**     Return values:
     267         *      If a device has been set using setActiveDevice() the return value will be the id of that device.
     268         *      In all other cases the return value will be the id of the device from the current ConfMan domain.
     269         */
     270        virtual int getActiveDevice() { return 0; }
     271
     272        /**     Return values:
     273         *      kMidiFeatsNone          : no features
     274         *      kMidiFeatsVolume        : device supports volume control
     275         *      kMidiFeatsVolumeLR      : device supports separate volume control for left and right channel
     276         */
     277        virtual MidiDeviceFeatures getDeviceFeatures(int id) { return kMidiFeatsNone; }
     278
     279        /**     Return values:
     280         *      Success:        driver internal name (string) for the device
     281         *      Failure:        0
     282         */
     283        virtual Common::String getDeviceName(int id) { return Common::String(""); }
     284       
     285        /**     Return values:
     286         *      Success:        device id
     287         *      Failure:        -1 (invalid deviceName)
     288         */
     289        virtual int getDeviceId(Common::String deviceName) { return -1; }
    237290};
    238291
    239292class MidiChannel {