/******************************************************************************\

* Copyright (c) 2004-2026

*

* Author(s):

* Volker Fischer

*

* As of Jamulus 3.12.1dev (commit eb172d47): All new source code contributions must be licensed

* under AGPL 3.0 or any later version.

*

* Existing code: Code contributed before 3.12.1dev (commit eb172d47) was licensed under GPL 2.0+.

* This code will be licensed under GPL 3.0 (or any later version) from

* 3.12.1dev (commit eb172d47). When distributed as part of Jamulus, the AGPL 3.0 terms govern

* the combined work, including network use provisions.

*

******************************************************************************

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Affero 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 Affero General Public License for more details.

*

* You should have received a copy of the GNU Affero General Public License

* along with this program. If not, see <https://www.gnu.org/licenses/>.

*

* ---------------------------------------------------------------------------

*

* 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 <https://www.gnu.org/licenses/>.

*

\******************************************************************************/

#include "settings.h"

/* Implementation *************************************************************/

void CSettings::Load ( const QList<QString>& CommandLineOptions )

{

// prepare file name for loading initialization data from XML file and read

// data from file if possible

QDomDocument IniXMLDocument;

ReadFromFile ( strFileName, IniXMLDocument );

// read the settings from the given XML file

ReadSettingsFromXML ( IniXMLDocument, CommandLineOptions );

}

void CSettings::Save ( bool isAboutToQuit )

{

// create XML document for storing initialization parameters

QDomDocument IniXMLDocument;

// write the settings in the XML file

WriteSettingsToXML ( IniXMLDocument, isAboutToQuit );

// prepare file name for storing initialization data in XML file and store

// XML data in file

WriteToFile ( strFileName, IniXMLDocument );

}

void CSettings::ReadFromFile ( const QString& strCurFileName, QDomDocument& XMLDocument )

{

QFile file ( strCurFileName );

if ( file.open ( QIODevice::ReadOnly ) )

{

XMLDocument.setContent ( QTextStream ( &file ).readAll(), false );

file.close();

}

}

void CSettings::WriteToFile ( const QString& strCurFileName, const QDomDocument& XMLDocument )

{

QFile file ( strCurFileName );

if ( file.open ( QIODevice::WriteOnly ) )

{

QTextStream ( &file ) << XMLDocument.toString();

file.close();

}

}

void CSettings::SetFileName ( const QString& sNFiName, const QString& sDefaultFileName )

{

// return the file name with complete path, take care if given file name is empty

strFileName = sNFiName;

if ( strFileName.isEmpty() )

{

// we use the Qt default setting file paths for the different OSs by

// utilizing the QSettings class

const QString sConfigDir =

QFileInfo ( QSettings ( QSettings::IniFormat, QSettings::UserScope, APP_NAME, APP_NAME ).fileName() ).absolutePath();

// make sure the directory exists

if ( !QFile::exists ( sConfigDir ) )

{

QDir().mkpath ( sConfigDir );

}

// append the actual file name

strFileName = sConfigDir + "/" + sDefaultFileName;

}

}

void CSettings::SetNumericIniSet ( QDomDocument& xmlFile, const QString& strSection, const QString& strKey, const int iValue )

{

// convert input parameter which is an integer to string and store

PutIniSetting ( xmlFile, strSection, strKey, QString::number ( iValue ) );

}

bool CSettings::GetNumericIniSet ( const QDomDocument& xmlFile,

const QString& strSection,

const QString& strKey,

const int iRangeStart,

const int iRangeStop,

int& iValue )

{

// init return value

bool bReturn = false;

const QString strGetIni = GetIniSetting ( xmlFile, strSection, strKey );

// check if it is a valid parameter

if ( !strGetIni.isEmpty() )

{

// convert string from init file to integer

iValue = strGetIni.toInt();

// check range

if ( ( iValue >= iRangeStart ) && ( iValue <= iRangeStop ) )

{

bReturn = true;

}

}

return bReturn;

}

void CSettings::SetFlagIniSet ( QDomDocument& xmlFile, const QString& strSection, const QString& strKey, const bool bValue )

{

// we encode true -> "1" and false -> "0"

PutIniSetting ( xmlFile, strSection, strKey, bValue ? "1" : "0" );

}

bool CSettings::GetFlagIniSet ( const QDomDocument& xmlFile, const QString& strSection, const QString& strKey, bool& bValue )

{

// init return value

bool bReturn = false;

const QString strGetIni = GetIniSetting ( xmlFile, strSection, strKey );

if ( !strGetIni.isEmpty() )

{

bValue = ( strGetIni.toInt() != 0 );

bReturn = true;

}

return bReturn;

}

// Init-file routines using XML ***********************************************

QString CSettings::GetIniSetting ( const QDomDocument& xmlFile, const QString& sSection, const QString& sKey, const QString& sDefaultVal )

{

// init return parameter with default value

QString sResult ( sDefaultVal );

// get section

QDomElement xmlSection = xmlFile.firstChildElement ( sSection );

if ( !xmlSection.isNull() )

{

// get key

QDomElement xmlKey = xmlSection.firstChildElement ( sKey );

if ( !xmlKey.isNull() )

{

// get value

sResult = xmlKey.text();

}

}

return sResult;

}

void CSettings::PutIniSetting ( QDomDocument& xmlFile, const QString& sSection, const QString& sKey, const QString& sValue )

{

// check if section is already there, if not then create it

QDomElement xmlSection = xmlFile.firstChildElement ( sSection );

if ( xmlSection.isNull() )

{

// create new root element and add to document

xmlSection = xmlFile.createElement ( sSection );

xmlFile.appendChild ( xmlSection );

}

// check if key is already there, if not then create it

QDomElement xmlKey = xmlSection.firstChildElement ( sKey );

if ( xmlKey.isNull() )

{

xmlKey = xmlFile.createElement ( sKey );

xmlSection.appendChild ( xmlKey );

}

// add actual data to the key

QDomText currentValue = xmlFile.createTextNode ( sValue );

xmlKey.appendChild ( currentValue );

}

#ifndef SERVER_ONLY

// Parse MIDI commmand line parameters and update MIDI variables

void CClientSettings::ParseCtrlMidiCh ( const QString& strMidiMap,

int& iMidiChannel,

int& iMidiFaderOffset,

int& iMidiFaderCount,

int& iMidiPanOffset,

int& iMidiPanCount,

int& iMidiSoloOffset,

int& iMidiSoloCount,

int& iMidiMuteOffset,

int& iMidiMuteCount,

int& iMidiMuteMyself,

bool& bMidiFaderEnabled,

bool& bMidiPanEnabled,

bool& bMidiSoloEnabled,

bool& bMidiMuteEnabled,

bool& bMidiMuteMyselfEnabled,

bool& bUseMIDIController,

bool& bMIDIPickupMode,

QString* strMIDIDevice )

{

if ( strMidiMap.isEmpty() )

{

// Empty string explicitly disables MIDI, but preserves section settings

bUseMIDIController = false;

return;

}

QStringList parts = strMidiMap.split ( ';' );

if ( parts.isEmpty() )

{

bUseMIDIController = false;

return;

}

// Parse MIDI channel (first parameter) - must be a valid number

bool bIsNumber = false;

iMidiChannel = parts[0].trimmed().toInt ( &bIsNumber );

// Validate MIDI channel (0 = all channels, 1-16 = specific channel)

if ( !bIsNumber || iMidiChannel < 0 || iMidiChannel > 16 )

{

// Invalid channel disables MIDI, but preserves section settings

bUseMIDIController = false;

return;

}

// Check for legacy format: [channel];[offset]

// If second parameter is a plain number (no prefix), treat as legacy format

if ( parts.size() >= 2 )

{

bool bIsNumber = false;

QString sParm = parts[1].trimmed();

int iOffset = sParm.toInt ( &bIsNumber );

if ( bIsNumber && !sParm.isEmpty() )

{

// Legacy format: set up faders from offset to 127 or MAX_NUM_CHANNELS

iMidiFaderOffset = iOffset;

iMidiFaderCount = qMin ( MAX_NUM_CHANNELS, 128 - iOffset );

bUseMIDIController = true;

return;

}

}

// Parse named controllers (new format)

for ( int i = 1; i < parts.size(); ++i )

{

QString sParm = parts[i].trimmed();

if ( sParm.isEmpty() )

{

continue;

}

QChar cType = sParm[0];

// Handle device selection

if ( cType == 'd' )

{

if ( strMIDIDevice != nullptr )

{

*strMIDIDevice = sParm.mid ( 1 );

}

continue;

}

// Handle MIDI pickup mode (u)

if ( sParm == "u" )

{

bMIDIPickupMode = true;

continue;

}

// Parse controller specification: [type][offset]*[count]

// where [type] is f, p, s, m, or o

QStringList vals = sParm.mid ( 1 ).split ( '*' );

int iFirst = vals[0].toInt();

int iNum = ( vals.size() > 1 ) ? vals[1].toInt() : 1;

// Bounds checking

if ( iFirst < 0 || iFirst >= 128 )

{

continue;

}

iNum = qMin ( iNum, MAX_NUM_CHANNELS );

iNum = qMin ( iNum, 128 - iFirst );

if ( iNum <= 0 )

{

continue;

}

// Assign to appropriate controller type

if ( cType == 'f' )

{

iMidiFaderOffset = iFirst;

iMidiFaderCount = iNum;

bMidiFaderEnabled = true;

}

else if ( cType == 'p' )

{

iMidiPanOffset = iFirst;

iMidiPanCount = iNum;

bMidiPanEnabled = true;

}

else if ( cType == 's' )

{

iMidiSoloOffset = iFirst;

iMidiSoloCount = iNum;

bMidiSoloEnabled = true;

}

else if ( cType == 'm' )

{

iMidiMuteOffset = iFirst;

iMidiMuteCount = iNum;

bMidiMuteEnabled = true;

}

else if ( cType == 'o' )

{

iMidiMuteMyself = iFirst;

bMidiMuteMyselfEnabled = true;

}

}

bUseMIDIController = true;

}

// Client settings -------------------------------------------------------------

void CClientSettings::LoadFaderSettings ( const QString& strCurFileName )

{

// prepare file name for loading initialization data from XML file and read

// data from file if possible

QDomDocument IniXMLDocument;

ReadFromFile ( strCurFileName, IniXMLDocument );

// read the settings from the given XML file

ReadFaderSettingsFromXML ( IniXMLDocument );

}

void CClientSettings::SaveFaderSettings ( const QString& strCurFileName )

{

// create XML document for storing initialization parameters

QDomDocument IniXMLDocument;

// write the settings in the XML file

WriteFaderSettingsToXML ( IniXMLDocument );

// prepare file name for storing initialization data in XML file and store

// XML data in file

WriteToFile ( strCurFileName, IniXMLDocument );

}

void CClientSettings::ReadSettingsFromXML ( const QDomDocument& IniXMLDocument, const QList<QString>& CommandLineOptions )

{

int iIdx;

int iValue;

bool bValue;

// IP addresses

for ( iIdx = 0; iIdx < MAX_NUM_SERVER_ADDR_ITEMS; iIdx++ )

{

vstrIPAddress[iIdx] = GetIniSetting ( IniXMLDocument, "client", QString ( "ipaddress%1" ).arg ( iIdx ), "" );

}

// new client level

if ( GetNumericIniSet ( IniXMLDocument, "client", "newclientlevel", 0, 100, iValue ) )

{

iNewClientFaderLevel = iValue;

}

// input boost

if ( GetNumericIniSet ( IniXMLDocument, "client", "inputboost", 1, 10, iValue ) )

{

iInputBoost = iValue;

}

if ( GetFlagIniSet ( IniXMLDocument, "client", "enablefeedbackdetection", bValue ) )

{

bEnableFeedbackDetection = bValue;

}

// connect dialog show all musicians

if ( GetFlagIniSet ( IniXMLDocument, "client", "connectdlgshowallmusicians", bValue ) )

{

bConnectDlgShowAllMusicians = bValue;

}

// language

strLanguage =

GetIniSetting ( IniXMLDocument, "client", "language", CLocale::FindSysLangTransFileName ( CLocale::GetAvailableTranslations() ).first );

// fader channel sorting

if ( GetNumericIniSet ( IniXMLDocument, "client", "channelsort", 0, 5 /* ST_BY_SERVER_CHANNEL */, iValue ) )

{

eChannelSortType = static_cast<EChSortType> ( iValue );

}

// own fader first sorting

if ( GetFlagIniSet ( IniXMLDocument, "client", "ownfaderfirst", bValue ) )

{

bOwnFaderFirst = bValue;

}

// number of mixer panel rows

if ( GetNumericIniSet ( IniXMLDocument, "client", "numrowsmixpan", 1, 8, iValue ) )

{

iNumMixerPanelRows = iValue;

}

// audio alerts

if ( GetFlagIniSet ( IniXMLDocument, "client", "enableaudioalerts", bValue ) )

{

bEnableAudioAlerts = bValue;

}

// name

pClient->ChannelInfo.strName = FromBase64ToString (

GetIniSetting ( IniXMLDocument, "client", "name_base64", ToBase64 ( QCoreApplication::translate ( "CMusProfDlg", "No Name" ) ) ) );

// instrument

if ( GetNumericIniSet ( IniXMLDocument, "client", "instrument", 0, CInstPictures::GetNumAvailableInst() - 1, iValue ) )

{

pClient->ChannelInfo.iInstrument = iValue;

}

// country

if ( GetNumericIniSet ( IniXMLDocument, "client", "country", 0, static_cast<int> ( QLocale::LastCountry ), iValue ) )

{

pClient->ChannelInfo.eCountry = CLocale::WireFormatCountryCodeToQtCountry ( iValue );

}

else

{

// if no country is given, use the one from the operating system

pClient->ChannelInfo.eCountry = QLocale::system().country();

}

// city

pClient->ChannelInfo.strCity = FromBase64ToString ( GetIniSetting ( IniXMLDocument, "client", "city_base64" ) );

// skill level

if ( GetNumericIniSet ( IniXMLDocument, "client", "skill", 0, 3 /* SL_PROFESSIONAL */, iValue ) )

{

pClient->ChannelInfo.eSkillLevel = static_cast<ESkillLevel> ( iValue );

}

// audio fader

if ( GetNumericIniSet ( IniXMLDocument, "client", "audfad", AUD_FADER_IN_MIN, AUD_FADER_IN_MAX, iValue ) )

{

pClient->SetAudioInFader ( iValue );

}

// reverberation level

if ( GetNumericIniSet ( IniXMLDocument, "client", "revlev", 0, AUD_REVERB_MAX, iValue ) )

{

pClient->SetReverbLevel ( iValue );

}

// reverberation channel assignment

if ( GetFlagIniSet ( IniXMLDocument, "client", "reverblchan", bValue ) )

{

pClient->SetReverbOnLeftChan ( bValue );

}

// sound card selection

const QString strError = pClient->SetSndCrdDev ( FromBase64ToString ( GetIniSetting ( IniXMLDocument, "client", "auddev_base64", "" ) ) );

if ( !strError.isEmpty() )

{

# ifndef HEADLESS

// special case: when settings are loaded no GUI is yet created, therefore

// we have to create a warning message box here directly

QMessageBox::warning ( nullptr, APP_NAME, strError );

# endif

}

// sound card channel mapping settings: make sure these settings are

// set AFTER the sound card device is set, otherwise the settings are

// overwritten by the defaults

//

// sound card left input channel mapping

if ( GetNumericIniSet ( IniXMLDocument, "client", "sndcrdinlch", 0, MAX_NUM_IN_OUT_CHANNELS - 1, iValue ) )

{

pClient->SetSndCrdLeftInputChannel ( iValue );

}

// sound card right input channel mapping

if ( GetNumericIniSet ( IniXMLDocument, "client", "sndcrdinrch", 0, MAX_NUM_IN_OUT_CHANNELS - 1, iValue ) )

{

pClient->SetSndCrdRightInputChannel ( iValue );

}

// sound card left output channel mapping

if ( GetNumericIniSet ( IniXMLDocument, "client", "sndcrdoutlch", 0, MAX_NUM_IN_OUT_CHANNELS - 1, iValue ) )

{

pClient->SetSndCrdLeftOutputChannel ( iValue );

}

// sound card right output channel mapping

if ( GetNumericIniSet ( IniXMLDocument, "client", "sndcrdoutrch", 0, MAX_NUM_IN_OUT_CHANNELS - 1, iValue ) )

{

pClient->SetSndCrdRightOutputChannel ( iValue );

}

// sound card preferred buffer size index

if ( GetNumericIniSet ( IniXMLDocument, "client", "prefsndcrdbufidx", FRAME_SIZE_FACTOR_PREFERRED, FRAME_SIZE_FACTOR_SAFE, iValue ) )

{

// additional check required since only a subset of factors are

// defined

if ( ( iValue == FRAME_SIZE_FACTOR_PREFERRED ) || ( iValue == FRAME_SIZE_FACTOR_DEFAULT ) || ( iValue == FRAME_SIZE_FACTOR_SAFE ) )

{

pClient->SetSndCrdPrefFrameSizeFactor ( iValue );

}

}

// automatic network jitter buffer size setting

if ( GetFlagIniSet ( IniXMLDocument, "client", "autojitbuf", bValue ) )

{

pClient->SetDoAutoSockBufSize ( bValue );

}

// network jitter buffer size

if ( GetNumericIniSet ( IniXMLDocument, "client", "jitbuf", MIN_NET_BUF_SIZE_NUM_BL, MAX_NET_BUF_SIZE_NUM_BL, iValue ) )

{

pClient->SetSockBufNumFrames ( iValue );

}

// network jitter buffer size for server

if ( GetNumericIniSet ( IniXMLDocument, "client", "jitbufserver", MIN_NET_BUF_SIZE_NUM_BL, MAX_NET_BUF_SIZE_NUM_BL, iValue ) )

{

pClient->SetServerSockBufNumFrames ( iValue );

}

// enable OPUS64 setting

if ( GetFlagIniSet ( IniXMLDocument, "client", "enableopussmall", bValue ) )

{

pClient->SetEnableOPUS64 ( bValue );

}

// GUI design

if ( GetNumericIniSet ( IniXMLDocument, "client", "guidesign", 0, 2 /* GD_SLIMFADER */, iValue ) )

{

pClient->SetGUIDesign ( static_cast<EGUIDesign> ( iValue ) );

}

// MeterStyle

if ( GetNumericIniSet ( IniXMLDocument, "client", "meterstyle", 0, 4 /* MT_LED_ROUND_BIG */, iValue ) )

{

pClient->SetMeterStyle ( static_cast<EMeterStyle> ( iValue ) );

}

else

{

// if MeterStyle is not found in the ini, set it based on the GUI design

if ( GetNumericIniSet ( IniXMLDocument, "client", "guidesign", 0, 2 /* GD_SLIMFADER */, iValue ) )

{

switch ( iValue )

{

case GD_STANDARD:

pClient->SetMeterStyle ( MT_BAR_WIDE );

break;

case GD_ORIGINAL:

pClient->SetMeterStyle ( MT_LED_STRIPE );

break;

case GD_SLIMFADER:

pClient->SetMeterStyle ( MT_BAR_NARROW );

break;

default:

pClient->SetMeterStyle ( MT_LED_STRIPE );

break;

}

}

}

// audio channels

if ( GetNumericIniSet ( IniXMLDocument, "client", "audiochannels", 0, 2 /* CC_STEREO */, iValue ) )

{

pClient->SetAudioChannels ( static_cast<EAudChanConf> ( iValue ) );

}

// audio quality

if ( GetNumericIniSet ( IniXMLDocument, "client", "audioquality", 0, 3 /* AQ_RAW */, iValue ) )

{

pClient->SetAudioQuality ( static_cast<EAudioQuality> ( iValue ) );

}

// MIDI settings: Always read from XML first to preserve values

if ( GetNumericIniSet ( IniXMLDocument, "client", "midichannel", 0, 16, iValue ) )

iMidiChannel = iValue;

struct MidiSettingEntry

{

const char* key;

int* variable;

};

MidiSettingEntry midiSettings[] = { { "midifaderoffset", &iMidiFaderOffset },

{ "midifadercount", &iMidiFaderCount },

{ "midipanoffset", &iMidiPanOffset },

{ "midipancount", &iMidiPanCount },

{ "midisolooffset", &iMidiSoloOffset },

{ "midisolocount", &iMidiSoloCount },

{ "midimuteoffset", &iMidiMuteOffset },

{ "midimutecount", &iMidiMuteCount },

{ "midimutemyself", &iMidiMuteMyself } };

for ( const auto& entry : midiSettings )

{

if ( GetNumericIniSet ( IniXMLDocument, "client", entry.key, 0, 127, iValue ) )

*( entry.variable ) = iValue;

}

if ( GetFlagIniSet ( IniXMLDocument, "client", "usemidicontroller", bValue ) )

bUseMIDIController = bValue;

if ( GetFlagIniSet ( IniXMLDocument, "client", "midipickupmode", bValue ) )

bMIDIPickupMode = bValue;

// Read enable flags

if ( GetFlagIniSet ( IniXMLDocument, "client", "midifaderenabled", bValue ) )

bMidiFaderEnabled = bValue;

if ( GetFlagIniSet ( IniXMLDocument, "client", "midipanenabled", bValue ) )

bMidiPanEnabled = bValue;

if ( GetFlagIniSet ( IniXMLDocument, "client", "midisoloenabled", bValue ) )

bMidiSoloEnabled = bValue;

if ( GetFlagIniSet ( IniXMLDocument, "client", "midimuteenabled", bValue ) )

bMidiMuteEnabled = bValue;

if ( GetFlagIniSet ( IniXMLDocument, "client", "midimutemyselfenabled", bValue ) )

bMidiMuteMyselfEnabled = bValue;

// Read MIDI device name from settings

strMidiDevice = GetIniSetting ( IniXMLDocument, "client", "mididevice_base64", "" );

if ( !strMidiDevice.isEmpty() )

{

strMidiDevice = FromBase64ToString ( strMidiDevice );

}

// Command line overrides: disable all controls, then re-enable only those specified

for ( const QString& option : CommandLineOptions )

{

if ( option.startsWith ( "--ctrlmidich=" ) )

{

QString strMidiMap = option.section ( '=', 1 );

// Check if channel is valid before disabling section flags

bool bValidChannel = false;

QStringList parts = strMidiMap.split ( ';' );

if ( !parts.isEmpty() && !strMidiMap.isEmpty() )

{

bool bIsNumber = false;

int iChannel = parts[0].trimmed().toInt ( &bIsNumber );

if ( bIsNumber && iChannel >= 0 && iChannel <= 16 )

{

bValidChannel = true;

}

}

// Only disable section flags if channel is valid - this allows command line

// to specify which sections to enable. If channel is invalid/empty, preserve

// ini file section settings but disable MIDI.

if ( bValidChannel )

{

bMidiFaderEnabled = false;

bMidiPanEnabled = false;

bMidiSoloEnabled = false;

bMidiMuteEnabled = false;

bMidiMuteMyselfEnabled = false;

bMIDIPickupMode = false;

}

// Parse command line - this will update channel, enable/disable MIDI,

// and re-enable any specified sections

CClientSettings::ParseCtrlMidiCh ( strMidiMap,

iMidiChannel,

iMidiFaderOffset,

iMidiFaderCount,

iMidiPanOffset,

iMidiPanCount,

iMidiSoloOffset,

iMidiSoloCount,

iMidiMuteOffset,

iMidiMuteCount,

iMidiMuteMyself,

bMidiFaderEnabled,

bMidiPanEnabled,

bMidiSoloEnabled,

bMidiMuteEnabled,

bMidiMuteMyselfEnabled,

bUseMIDIController,

bMIDIPickupMode,

&strMidiDevice );

break;

}

}

// custom directories

//### TODO: BEGIN ###//

// compatibility to old version (< 3.6.1)

QString strDirectoryAddress = GetIniSetting ( IniXMLDocument, "client", "centralservaddr", "" );

//### TODO: END ###//

for ( iIdx = 0; iIdx < MAX_NUM_SERVER_ADDR_ITEMS; iIdx++ )

{

//### TODO: BEGIN ###//

// compatibility to old version (< 3.8.2)

strDirectoryAddress = GetIniSetting ( IniXMLDocument, "client", QString ( "centralservaddr%1" ).arg ( iIdx ), strDirectoryAddress );

//### TODO: END ###//

vstrDirectoryAddress[iIdx] = GetIniSetting ( IniXMLDocument, "client", QString ( "directoryaddress%1" ).arg ( iIdx ), strDirectoryAddress );

strDirectoryAddress = "";

}

// directory type

//### TODO: BEGIN ###//

// compatibility to old version (<3.4.7)

// only the case that "centralservaddr" was set in old ini must be considered

if ( !vstrDirectoryAddress[0].isEmpty() && GetFlagIniSet ( IniXMLDocument, "client", "defcentservaddr", bValue ) && !bValue )

{

eDirectoryType = AT_CUSTOM;

}

// compatibility to old version (< 3.8.2)

else if ( GetNumericIniSet ( IniXMLDocument, "client", "centservaddrtype", 0, static_cast<int> ( AT_CUSTOM ), iValue ) )

{

eDirectoryType = static_cast<EDirectoryType> ( iValue );

}

//### TODO: END ###//

else if ( GetNumericIniSet ( IniXMLDocument, "client", "directorytype", 0, static_cast<int> ( AT_CUSTOM ), iValue ) )

{

eDirectoryType = static_cast<EDirectoryType> ( iValue );

}

else

{

// if no address type is given, choose one from the operating system locale

eDirectoryType = AT_DEFAULT;

}

// custom directory index

if ( ( eDirectoryType == AT_CUSTOM ) &&

GetNumericIniSet ( IniXMLDocument, "client", "customdirectoryindex", 0, MAX_NUM_SERVER_ADDR_ITEMS, iValue ) )

{

iCustomDirectoryIndex = iValue;

}

else

{

// if directory is not set to custom, or if no custom directory index is found in the settings .ini file, then initialize to zero

iCustomDirectoryIndex = 0;

}

// window position of the main window

vecWindowPosMain = FromBase64ToByteArray ( GetIniSetting ( IniXMLDocument, "client", "winposmain_base64" ) );

// window position of the settings window

vecWindowPosSettings = FromBase64ToByteArray ( GetIniSetting ( IniXMLDocument, "client", "winposset_base64" ) );

// window position of the chat window

vecWindowPosChat = FromBase64ToByteArray ( GetIniSetting ( IniXMLDocument, "client", "winposchat_base64" ) );

// window position of the connect window

vecWindowPosConnect = FromBase64ToByteArray ( GetIniSetting ( IniXMLDocument, "client", "winposcon_base64" ) );

// visibility state of the settings window

if ( GetFlagIniSet ( IniXMLDocument, "client", "winvisset", bValue ) )

{

bWindowWasShownSettings = bValue;

}

// visibility state of the chat window

if ( GetFlagIniSet ( IniXMLDocument, "client", "winvischat", bValue ) )

{

bWindowWasShownChat = bValue;

}

// visibility state of the connect window

if ( GetFlagIniSet ( IniXMLDocument, "client", "winviscon", bValue ) )

{

bWindowWasShownConnect = bValue;

}

// selected Settings Tab

if ( GetNumericIniSet ( IniXMLDocument, "client", "settingstab", 0, 3, iValue ) )

{

iSettingsTab = iValue;

}

// fader settings

ReadFaderSettingsFromXML ( IniXMLDocument );

}

void CClientSettings::ReadFaderSettingsFromXML ( const QDomDocument& IniXMLDocument )

{

int iIdx;

int iValue;

bool bValue;

for ( iIdx = 0; iIdx < MAX_NUM_STORED_FADER_SETTINGS; iIdx++ )

{

// stored fader tags

QString strFaderTag =

FromBase64ToString ( GetIniSetting ( IniXMLDocument, "client", QString ( "storedfadertag%1_base64" ).arg ( iIdx ), "" ) );

if ( strFaderTag.isEmpty() )

{

// duplicate from clean up code

continue;

}

vecStoredFaderTags[iIdx] = strFaderTag;

// stored fader levels

if ( GetNumericIniSet ( IniXMLDocument, "client", QString ( "storedfaderlevel%1" ).arg ( iIdx ), 0, AUD_MIX_FADER_MAX, iValue ) )

{

vecStoredFaderLevels[iIdx] = iValue;

}

// stored pan values

if ( GetNumericIniSet ( IniXMLDocument, "client", QString ( "storedpanvalue%1" ).arg ( iIdx ), 0, AUD_MIX_PAN_MAX, iValue ) )

{

vecStoredPanValues[iIdx] = iValue;

}

// stored fader solo state

if ( GetFlagIniSet ( IniXMLDocument, "client", QString ( "storedfaderissolo%1" ).arg ( iIdx ), bValue ) )

{

vecStoredFaderIsSolo[iIdx] = bValue;

}

// stored fader muted state

if ( GetFlagIniSet ( IniXMLDocument, "client", QString ( "storedfaderismute%1" ).arg ( iIdx ), bValue ) )

{

vecStoredFaderIsMute[iIdx] = bValue;

}

// stored fader group ID

if ( GetNumericIniSet ( IniXMLDocument,

"client",

QString ( "storedgroupid%1" ).arg ( iIdx ),

INVALID_INDEX,

MAX_NUM_FADER_GROUPS - 1,

iValue ) )

{

vecStoredFaderGroupID[iIdx] = iValue;

}

}

}

void CClientSettings::WriteSettingsToXML ( QDomDocument& IniXMLDocument, bool isAboutToQuit )

{

Q_UNUSED ( isAboutToQuit )

int iIdx;

// IP addresses

for ( iIdx = 0; iIdx < MAX_NUM_SERVER_ADDR_ITEMS; iIdx++ )

{

PutIniSetting ( IniXMLDocument, "client", QString ( "ipaddress%1" ).arg ( iIdx ), vstrIPAddress[iIdx] );

}

// new client level

SetNumericIniSet ( IniXMLDocument, "client", "newclientlevel", iNewClientFaderLevel );

// input boost

SetNumericIniSet ( IniXMLDocument, "client", "inputboost", iInputBoost );

// feedback detection

SetFlagIniSet ( IniXMLDocument, "client", "enablefeedbackdetection", bEnableFeedbackDetection );

// connect dialog show all musicians

SetFlagIniSet ( IniXMLDocument, "client", "connectdlgshowallmusicians", bConnectDlgShowAllMusicians );

// language

PutIniSetting ( IniXMLDocument, "client", "language", strLanguage );

// fader channel sorting

SetNumericIniSet ( IniXMLDocument, "client", "channelsort", static_cast<int> ( eChannelSortType ) );

// own fader first sorting

SetFlagIniSet ( IniXMLDocument, "client", "ownfaderfirst", bOwnFaderFirst );

// number of mixer panel rows

SetNumericIniSet ( IniXMLDocument, "client", "numrowsmixpan", iNumMixerPanelRows );

// audio alerts

SetFlagIniSet ( IniXMLDocument, "client", "enableaudioalerts", bEnableAudioAlerts );

// name

PutIniSetting ( IniXMLDocument, "client", "name_base64", ToBase64 ( pClient->ChannelInfo.strName ) );

// instrument

SetNumericIniSet ( IniXMLDocument, "client", "instrument", pClient->ChannelInfo.iInstrument );

// country

SetNumericIniSet ( IniXMLDocument, "client", "country", CLocale::QtCountryToWireFormatCountryCode ( pClient->ChannelInfo.eCountry ) );

// city

PutIniSetting ( IniXMLDocument, "client", "city_base64", ToBase64 ( pClient->ChannelInfo.strCity ) );

// skill level

SetNumericIniSet ( IniXMLDocument, "client", "skill", static_cast<int> ( pClient->ChannelInfo.eSkillLevel ) );

// audio fader

SetNumericIniSet ( IniXMLDocument, "client", "audfad", pClient->GetAudioInFader() );

// reverberation level

SetNumericIniSet ( IniXMLDocument, "client", "revlev", pClient->GetReverbLevel() );

// reverberation channel assignment

SetFlagIniSet ( IniXMLDocument, "client", "reverblchan", pClient->IsReverbOnLeftChan() );

// sound card selection

PutIniSetting ( IniXMLDocument, "client", "auddev_base64", ToBase64 ( pClient->GetSndCrdDev() ) );

// sound card left input channel mapping

SetNumericIniSet ( IniXMLDocument, "client", "sndcrdinlch", pClient->GetSndCrdLeftInputChannel() );

// sound card right input channel mapping

SetNumericIniSet ( IniXMLDocument, "client", "sndcrdinrch", pClient->GetSndCrdRightInputChannel() );

// sound card left output channel mapping

SetNumericIniSet ( IniXMLDocument, "client", "sndcrdoutlch", pClient->GetSndCrdLeftOutputChannel() );

// sound card right output channel mapping

SetNumericIniSet ( IniXMLDocument, "client", "sndcrdoutrch", pClient->GetSndCrdRightOutputChannel() );

// sound card preferred buffer size index

SetNumericIniSet ( IniXMLDocument, "client", "prefsndcrdbufidx", pClient->GetSndCrdPrefFrameSizeFactor() );

// automatic network jitter buffer size setting

SetFlagIniSet ( IniXMLDocument, "client", "autojitbuf", pClient->GetDoAutoSockBufSize() );

// network jitter buffer size

SetNumericIniSet ( IniXMLDocument, "client", "jitbuf", pClient->GetSockBufNumFrames() );

// network jitter buffer size for server

SetNumericIniSet ( IniXMLDocument, "client", "jitbufserver", pClient->GetServerSockBufNumFrames() );

// enable OPUS64 setting

SetFlagIniSet ( IniXMLDocument, "client", "enableopussmall", pClient->GetEnableOPUS64() );

// GUI design

SetNumericIniSet ( IniXMLDocument, "client", "guidesign", static_cast<int> ( pClient->GetGUIDesign() ) );

// MeterStyle

SetNumericIniSet ( IniXMLDocument, "client", "meterstyle", static_cast<int> ( pClient->GetMeterStyle() ) );

// audio channels

SetNumericIniSet ( IniXMLDocument, "client", "audiochannels", static_cast<int> ( pClient->GetAudioChannels() ) );

// audio quality

SetNumericIniSet ( IniXMLDocument, "client", "audioquality", static_cast<int> ( pClient->GetAudioQuality() ) );

// custom directories

for ( iIdx = 0; iIdx < MAX_NUM_SERVER_ADDR_ITEMS; iIdx++ )

{

PutIniSetting ( IniXMLDocument, "client", QString ( "directoryaddress%1" ).arg ( iIdx ), vstrDirectoryAddress[iIdx] );

}