1 files changed, 1 insertions, 1 deletions

diff --git a/noncore/settings/networksettings/ppp/pppdata.cpp b/noncore/settings/networksettings/ppp/pppdata.cpp
index 8f066ff..8f45e54 100644
--- a/noncore/settings/networksettings/ppp/pppdata.cpp
+++ b/noncore/settings/networksettings/ppp/pppdata.cpp
@@ -295,385 +295,385 @@ void PPPData::set_show_log_window(bool set) {
 bool PPPData::automatic_redial() {
   return (bool) readNumConfig(GENERAL_GRP, AUTOREDIAL_KEY, FALSE);
 }
 
 
 void PPPData::set_automatic_redial(bool set) {
   writeConfig(GENERAL_GRP, AUTOREDIAL_KEY, (int) set);
 }
 
 
 // bool PPPData::get_iconify_on_connect() {
 //   return (bool) readNumConfig(GENERAL_GRP, ICONIFY_ON_CONNECT_KEY, TRUE);
 // }
 
 
 // void PPPData::set_iconify_on_connect(bool set) {
 //   writeConfig(GENERAL_GRP, ICONIFY_ON_CONNECT_KEY, (int) set);
 // }
 
 
 // bool PPPData::get_dock_into_panel() {
 //   return (bool) readNumConfig(GENERAL_GRP, DOCKING_KEY, false);
 // }
 
 
 // void PPPData::set_dock_into_panel(bool set) {
 //   writeConfig(GENERAL_GRP, DOCKING_KEY, (int) set);
 // }
 
 
 QString PPPData::pppdVersion() {
   return QString("%1.%2.%3").arg(pppdVer).arg(pppdMod).arg(pppdPatch);
 }
 
 bool PPPData::pppdVersionMin(int ver, int mod, int patch) {
   // check if pppd version fulfills minimum requirement
   return (pppdVer > ver
           || (pppdVer == ver && pppdMod > mod)
           || (pppdVer == ver && pppdMod == mod && pppdPatch >= patch));
 }
 
 int PPPData::pppdTimeout() {
   return readNumConfig(GENERAL_GRP, PPPDTIMEOUT_KEY, PPPD_TIMEOUT);
 }
 
 
 void PPPData::setpppdTimeout(int n) {
   writeConfig(GENERAL_GRP, PPPDTIMEOUT_KEY, n);
 }
 
 
 const QString PPPData::modemDevice() {
   return readConfig (modemGroup(), MODEMDEV_KEY, devices[DEV_DEFAULT]);
 }
 
 
 bool PPPData::setModemDevice(const QString &n) {
     qDebug("Setting modem dev to >%s<", n.latin1());
     bool ret = false;
     for (int i = 0; devices[i]; i++)
         if (devices[i] == n){
             modemDeviceGroup = i;
             writeConfig(modemGroup(), MODEMDEV_KEY, n);
             ret = true;
         }
     qDebug(ret?"SUCCESS":"FAILURE");
     return ret;
 }
 
 
 const QString PPPData::flowcontrol() {
   return readConfig(modemGroup(), FLOWCONTROL_KEY, "CRTSCTS");
 }
 
 
 void PPPData::setFlowcontrol(const QString &n) {
   writeConfig(modemGroup(), FLOWCONTROL_KEY, n);
 }
 
 
 const QString PPPData::speed() {
   QString s = readConfig(modemGroup(), SPEED_KEY, "57600");
   // undo the damage of a bug in former versions. It left an empty Speed=
   // entry in kppprc. kppp did set the serial port to 57600 as default but
   // pppd wouldn't receive the speed via the command line.
   if(s.toUInt() == 0)
     s = "57600";
   return s;
 }
 
 
 void PPPData::setSpeed(const QString &n) {
   writeConfig(modemGroup(), SPEED_KEY, n);
 }
 
 
 #if 0
 void PPPData::setUseCDLine(const int n) {
   writeConfig(modemGroup(),USECDLINE_KEY,n);
 }
 
 
 int PPPData::UseCDLine() {
   return  readNumConfig(modemGroup(),USECDLINE_KEY,0);
 }
 #endif
 
 const QString  PPPData::modemEscapeStr() {
   return readConfig(modemGroup(),ESCAPESTR_KEY,"+++");
 }
 
 
 void PPPData::setModemEscapeStr(const QString &n) {
   writeConfig(modemGroup(),ESCAPESTR_KEY,n);
 }
 
 
 const QString  PPPData::modemEscapeResp() {
   return readConfig(modemGroup(),ESCAPERESP_KEY,"OK");
 }
 
 
 void PPPData::setModemEscapeResp(const QString &n) {
   writeConfig(modemGroup(),ESCAPERESP_KEY,n);
 }
 
 
 int  PPPData::modemEscapeGuardTime() {
   return readNumConfig(modemGroup(),ESCAPEGUARDTIME_KEY,50);
 }
 
 
 void PPPData::setModemEscapeGuardTime(int n) {
   writeConfig(modemGroup(),ESCAPEGUARDTIME_KEY,n);
 }
 
 
 bool PPPData::modemLockFile() {
   return readNumConfig(modemGroup(), LOCKFILE_KEY, 1);
 }
 
 
 void PPPData::setModemLockFile(bool set) {
   writeConfig(modemGroup(), LOCKFILE_KEY, set);
 }
 
 
 int PPPData::modemTimeout() {
   return readNumConfig(modemGroup(), TIMEOUT_KEY, MODEM_TIMEOUT);
 }
 
 
 void PPPData::setModemTimeout(int n) {
   writeConfig(modemGroup(), TIMEOUT_KEY, n);
 }
 
 
 int PPPData::modemToneDuration() {
   return readNumConfig(modemGroup(), TONEDURATION_KEY,MODEM_TONEDURATION);
 }
 
 
 void PPPData::setModemToneDuration(int n) {
   writeConfig(modemGroup(), TONEDURATION_KEY, n);
 }
 
 
 int PPPData::busyWait() {
   return readNumConfig(modemGroup(), BUSYWAIT_KEY, BUSY_WAIT);
 }
 
 
 void PPPData::setbusyWait(int n) {
   writeConfig(modemGroup(), BUSYWAIT_KEY, n);
 }
 
 
 //
 //Advanced "Modem" dialog
 //
 // defaults: InitString=ATZ, InitString1="" etc.
 const QString PPPData::modemInitStr(int i) {
   assert(i >= 0 && i < NumInitStrings);
   if(i == 0)
     return readConfig(modemGroup(), INITSTR_KEY, "ATZ");
   else
     return readConfig(modemGroup(), INITSTR_KEY + QString::number(i), "");
 }
 
 
 void PPPData::setModemInitStr(int i, const QString &n) {
   assert(i >= 0 && i < NumInitStrings);
-  QString k = INITSTR_KEY + (i > 0 ? QString::number(i) : "");
+  QString k = INITSTR_KEY + (i > 0 ? QString::number(i) : QString(""));
   writeConfig(modemGroup(), k, n);
 }
 
 
 const QString PPPData::modemInitResp() {
   return readConfig(modemGroup(), INITRESP_KEY, "OK");
 }
 
 
 void PPPData::setModemInitResp(const QString &n) {
   writeConfig(modemGroup(), INITRESP_KEY, n);
 }
 
 
 int PPPData::modemPreInitDelay() {
   return readNumConfig(modemGroup(), PREINITDELAY_KEY, 50);
 }
 
 
 void PPPData::setModemPreInitDelay(int n) {
   writeConfig(modemGroup(), PREINITDELAY_KEY, n);
 }
 
 
 int PPPData::modemInitDelay() {
   return readNumConfig(modemGroup(), INITDELAY_KEY, 50);
 }
 
 
 void PPPData::setModemInitDelay(int n) {
   writeConfig(modemGroup(), INITDELAY_KEY, n);
 }
 
 QString PPPData::modemNoDialToneDetectionStr() {
   return readConfig(modemGroup(), NODTDETECT_KEY, "ATX3");
 }
 
 void PPPData::setModemNoDialToneDetectionStr(const QString &n) {
   writeConfig(modemGroup(), NODTDETECT_KEY, n);
 }
 
 const QString PPPData::modemDialStr() {
   return readConfig(modemGroup(), DIALSTR_KEY, "ATDT");
 }
 
 
 void PPPData::setModemDialStr(const QString &n) {
   writeConfig(modemGroup(), DIALSTR_KEY, n);
 }
 
 
 const QString PPPData::modemConnectResp() {
   return readConfig(modemGroup(), CONNECTRESP_KEY, "CONNECT");
 }
 
 
 void PPPData::setModemConnectResp(const QString &n) {
   writeConfig(modemGroup(), CONNECTRESP_KEY, n);
 }
 
 
 const QString PPPData::modemBusyResp() {
   return readConfig(modemGroup(), BUSYRESP_KEY, "BUSY");
 }
 
 
 void PPPData::setModemBusyResp(const QString &n) {
   writeConfig(modemGroup(), BUSYRESP_KEY, n);
 }
 
 
 const QString PPPData::modemNoCarrierResp() {
   return readConfig(modemGroup(), NOCARRIERRESP_KEY, "NO CARRIER");
 }
 
 
 void PPPData::setModemNoCarrierResp(const QString &n) {
   writeConfig(modemGroup(), NOCARRIERRESP_KEY, n);
 }
 
 
 const QString PPPData::modemNoDialtoneResp() {
   return readConfig(modemGroup(), NODIALTONERESP_KEY, "NO DIALTONE");
 }
 
 
 void PPPData::setModemNoDialtoneResp(const QString &n) {
   writeConfig(modemGroup(), NODIALTONERESP_KEY, n);
 }
 
 
 const QString PPPData::modemHangupStr() {
   return readConfig(modemGroup(), HANGUPSTR_KEY, "+++ATH");
 }
 
 void PPPData::setModemHangupStr(const QString &n) {
   writeConfig(modemGroup(), HANGUPSTR_KEY, n);
 }
 
 
 const QString PPPData::modemHangupResp() {
   return readConfig(modemGroup(), HANGUPRESP_KEY, "OK");
 }
 
 void PPPData::setModemHangupResp(const QString &n) {
   writeConfig(modemGroup(), HANGUPRESP_KEY, n);
 }
 
 
 const QString PPPData::modemAnswerStr() {
   return readConfig(modemGroup(), ANSWERSTR_KEY, "ATA");
 }
 
 
 QString PPPData::volumeOff() {
   return readConfig(modemGroup(), VOLUME_OFF, "M0L0");
 }
 
 
 void PPPData::setVolumeOff(const QString &s) {
   writeConfig(modemGroup(), VOLUME_OFF, s);
 }
 
 
 QString PPPData::volumeMedium() {
  return readConfig(modemGroup(), VOLUME_MEDIUM, "M1L1");
 }
 
 
 void PPPData::setVolumeMedium(const QString &s) {
   writeConfig(modemGroup(), VOLUME_MEDIUM, s);
 }
 
 
 QString PPPData::volumeHigh() {
   QString tmp = readConfig(modemGroup(), VOLUME_HIGH, "M1L3");
   if(tmp == "M1L4")
     tmp = "M1L3";
   return tmp;
 }
 
 
 void PPPData::setVolumeHigh(const QString &s) {
  writeConfig(modemGroup(), VOLUME_HIGH, s);
 }
 
 
 QString PPPData::volumeInitString() {
   QString s;
 
   switch(volume()) {
   case 0:
     s = volumeOff();
     break;
   case 1:
     s = volumeMedium();
     break;
   case 2:
     s = volumeHigh();
     break;
   default:
     s = volumeMedium();
   }
 
   return s;
 }
 
 
 int PPPData::volume() {
   return readNumConfig(modemGroup(), VOLUME_KEY, 1);
 }
 
 
 void PPPData::setVolume(int i) {
   writeConfig(modemGroup(), VOLUME_KEY, i);
 }
 
 int PPPData::waitForDialTone() {
   return readNumConfig(modemGroup(), DIALTONEWAIT_KEY, 1);
 }
 
 void PPPData::setWaitForDialTone(int i) {
   writeConfig(modemGroup(), DIALTONEWAIT_KEY, i);
 }
 
 void PPPData::setModemAnswerStr(const QString &n) {
   writeConfig(modemGroup(), ANSWERSTR_KEY, n);
 }
 
 
 const QString PPPData::modemRingResp() {
   return readConfig(modemGroup(), RINGRESP_KEY, "RING");