diff --git a/src/audiomixerboard.cpp b/src/audiomixerboard.cpp
index 4e28eef4..215c2fe1 100644
--- a/src/audiomixerboard.cpp
+++ b/src/audiomixerboard.cpp
@@ -174,18 +174,17 @@ CChannelFader::CChannelFader ( QWidget*     pNW,
 
 
     // Connections -------------------------------------------------------------
-    QObject::connect ( pFader, SIGNAL ( valueChanged ( int ) ),
-        this, SLOT ( OnLevelValueChanged ( int ) ) );
+    QObject::connect ( pFader, &QSlider::valueChanged,
+        this, &CChannelFader::OnLevelValueChanged );
 
-    QObject::connect ( pPan, SIGNAL ( valueChanged ( int ) ),
-        this, SLOT ( OnPanValueChanged ( int ) ) );
+    QObject::connect ( pPan, &QDial::valueChanged,
+        this, &CChannelFader::OnPanValueChanged );
 
-    QObject::connect ( pcbMute, SIGNAL ( stateChanged ( int ) ),
-        this, SLOT ( OnMuteStateChanged ( int ) ) );
+    QObject::connect ( pcbMute, &QCheckBox::stateChanged,
+        this, &CChannelFader::OnMuteStateChanged );
 
-    QObject::connect ( pcbSolo,
-        SIGNAL ( stateChanged ( int ) ),
-        SIGNAL ( soloStateChanged ( int ) ) );
+    QObject::connect ( pcbSolo, &QCheckBox::stateChanged,
+        this, &CChannelFader::soloStateChanged );
 }
 
 void CChannelFader::SetGUIDesign ( const EGUIDesign eNewDesign )
diff --git a/src/channel.cpp b/src/channel.cpp
index 4e6aa136..b1b38241 100755
--- a/src/channel.cpp
+++ b/src/channel.cpp
@@ -60,70 +60,56 @@ CChannel::CChannel ( const bool bNIsServer ) :
 qRegisterMetaType<CVector<uint8_t> > ( "CVector<uint8_t>" );
 qRegisterMetaType<CHostAddress> ( "CHostAddress" );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( MessReadyForSending ( CVector<uint8_t> ) ),
-        this, SLOT ( OnSendProtMessage ( CVector<uint8_t> ) ) );
+    QObject::connect ( &Protocol, &CProtocol::MessReadyForSending,
+        this, &CChannel::OnSendProtMessage );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ChangeJittBufSize ( int ) ),
-        this, SLOT ( OnJittBufSizeChange ( int ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ChangeJittBufSize,
+        this, &CChannel::OnJittBufSizeChange );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ReqJittBufSize() ),
-        SIGNAL ( ReqJittBufSize() ) );
+    QObject::connect ( &Protocol, &CProtocol::ReqJittBufSize,
+        this, &CChannel::ReqJittBufSize );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ReqChanInfo() ),
-        SIGNAL ( ReqChanInfo() ) );
+    QObject::connect ( &Protocol, &CProtocol::ReqChanInfo,
+        this, &CChannel::ReqChanInfo );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ReqConnClientsList() ),
-        SIGNAL ( ReqConnClientsList() ) );
+    QObject::connect ( &Protocol, &CProtocol::ReqConnClientsList,
+        this, &CChannel::ReqConnClientsList );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ConClientListMesReceived ( CVector<CChannelInfo> ) ),
-        SIGNAL ( ConClientListMesReceived ( CVector<CChannelInfo> ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ConClientListMesReceived,
+        this, &CChannel::ConClientListMesReceived );
 
-    QObject::connect ( &Protocol, SIGNAL ( ChangeChanGain ( int, double ) ),
-        this, SLOT ( OnChangeChanGain ( int, double ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ChangeChanGain,
+        this, &CChannel::OnChangeChanGain );
 
-    QObject::connect ( &Protocol, SIGNAL ( ChangeChanPan ( int, double ) ),
-        this, SLOT ( OnChangeChanPan ( int, double ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ChangeChanPan,
+        this, &CChannel::OnChangeChanPan );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ClientIDReceived ( int ) ),
-        SIGNAL ( ClientIDReceived ( int ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ClientIDReceived,
+        this, &CChannel::ClientIDReceived );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( MuteStateHasChangedReceived ( int, bool ) ),
-        SIGNAL ( MuteStateHasChangedReceived ( int, bool ) ) );
+    QObject::connect ( &Protocol, &CProtocol::MuteStateHasChangedReceived,
+        this, &CChannel::MuteStateHasChangedReceived );
 
-    QObject::connect ( &Protocol, SIGNAL ( ChangeChanInfo ( CChannelCoreInfo ) ),
-        this, SLOT ( OnChangeChanInfo ( CChannelCoreInfo ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ChangeChanInfo,
+        this, &CChannel::OnChangeChanInfo );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ChatTextReceived ( QString ) ),
-        SIGNAL ( ChatTextReceived ( QString ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ChatTextReceived,
+        this, &CChannel::ChatTextReceived );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( NetTranspPropsReceived ( CNetworkTransportProps ) ),
-        this, SLOT ( OnNetTranspPropsReceived ( CNetworkTransportProps ) ) );
+    QObject::connect ( &Protocol, &CProtocol::NetTranspPropsReceived,
+        this, &CChannel::OnNetTranspPropsReceived );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ReqNetTranspProps() ),
-        this, SLOT ( OnReqNetTranspProps() ) );
+    QObject::connect ( &Protocol, &CProtocol::ReqNetTranspProps,
+        this, &CChannel::OnReqNetTranspProps );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( LicenceRequired ( ELicenceType ) ),
-        SIGNAL ( LicenceRequired ( ELicenceType ) ) );
+    QObject::connect ( &Protocol, &CProtocol::LicenceRequired,
+        this, &CChannel::LicenceRequired );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( VersionAndOSReceived ( COSUtil::EOpSystemType, QString ) ),
-        SIGNAL ( VersionAndOSReceived ( COSUtil::EOpSystemType, QString ) ) );
+    QObject::connect ( &Protocol, &CProtocol::VersionAndOSReceived,
+        this, &CChannel::VersionAndOSReceived );
 
-    QObject::connect ( &Protocol,
-        SIGNAL ( ReqChannelLevelList ( bool ) ),
-        this, SLOT ( OnReqChannelLevelList ( bool ) ) );
+    QObject::connect ( &Protocol, &CProtocol::ReqChannelLevelList,
+        this, &CChannel::OnReqChannelLevelList );
 }
 
 bool CChannel::ProtocolIsEnabled()
diff --git a/src/chatdlg.cpp b/src/chatdlg.cpp
index 0a1554f3..754c2ed9 100755
--- a/src/chatdlg.cpp
+++ b/src/chatdlg.cpp
@@ -54,15 +54,14 @@ CChatDlg::CChatDlg ( QWidget* parent, Qt::WindowFlags f ) :
 
 
     // Connections -------------------------------------------------------------
-    QObject::connect ( edtLocalInputText,
-        SIGNAL ( textChanged ( const QString& ) ),
-        this, SLOT ( OnLocalInputTextTextChanged ( const QString& ) ) );
+    QObject::connect ( edtLocalInputText, &QLineEdit::textChanged,
+        this, &CChatDlg::OnLocalInputTextTextChanged );
 
-    QObject::connect ( edtLocalInputText, SIGNAL ( returnPressed() ),
-        this, SLOT ( OnLocalInputTextReturnPressed() ) );
+    QObject::connect ( edtLocalInputText, &QLineEdit::returnPressed,
+        this, &CChatDlg::OnLocalInputTextReturnPressed );
 
-    QObject::connect ( butClear, SIGNAL ( pressed() ),
-        this, SLOT ( OnClearPressed() ) );
+    QObject::connect ( butClear, &QPushButton::pressed,
+        this, &CChatDlg::OnClearPressed );
 }
 
 void CChatDlg::OnLocalInputTextTextChanged ( const QString& strNewText )
diff --git a/src/client.cpp b/src/client.cpp
index e1b3c419..d0e3c58a 100755
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -126,102 +126,83 @@ CClient::CClient ( const quint16  iPortNumber,
 
     // Connections -------------------------------------------------------------
     // connections for the protocol mechanism
-    QObject::connect ( &Channel,
-        SIGNAL ( MessReadyForSending ( CVector<uint8_t> ) ),
-        this, SLOT ( OnSendProtMessage ( CVector<uint8_t> ) ) );
+    QObject::connect ( &Channel, &CChannel::MessReadyForSending,
+        this, &CClient::OnSendProtMessage );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( DetectedCLMessage ( CVector<uint8_t>, int, CHostAddress ) ),
-        this, SLOT ( OnDetectedCLMessage ( CVector<uint8_t>, int, CHostAddress ) ) );
+    QObject::connect ( &Channel, &CChannel::DetectedCLMessage,
+        this, &CClient::OnDetectedCLMessage );
 
-    QObject::connect ( &Channel, SIGNAL ( ReqJittBufSize() ),
-        this, SLOT ( OnReqJittBufSize() ) );
+    QObject::connect ( &Channel, &CChannel::ReqJittBufSize,
+        this, &CClient::OnReqJittBufSize );
 
-    QObject::connect ( &Channel, SIGNAL ( JittBufSizeChanged ( int ) ),
-        this, SLOT ( OnJittBufSizeChanged ( int ) ) );
+    QObject::connect ( &Channel, &CChannel::JittBufSizeChanged,
+        this, &CClient::OnJittBufSizeChanged );
 
-    QObject::connect ( &Channel, SIGNAL ( ReqChanInfo() ),
-        this, SLOT ( OnReqChanInfo() ) );
+    QObject::connect ( &Channel, &CChannel::ReqChanInfo,
+        this, &CClient::OnReqChanInfo );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( ConClientListMesReceived ( CVector<CChannelInfo> ) ),
-        SIGNAL ( ConClientListMesReceived ( CVector<CChannelInfo> ) ) );
+    QObject::connect ( &Channel, &CChannel::ConClientListMesReceived,
+        this, &CClient::ConClientListMesReceived );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( Disconnected() ),
-        SIGNAL ( Disconnected() ) );
+    QObject::connect ( &Channel, &CChannel::Disconnected,
+        this, &CClient::Disconnected );
 
-    QObject::connect ( &Channel, SIGNAL ( NewConnection() ),
-        this, SLOT ( OnNewConnection() ) );
+    QObject::connect ( &Channel, &CChannel::NewConnection,
+        this, &CClient::OnNewConnection );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( ChatTextReceived ( QString ) ),
-        SIGNAL ( ChatTextReceived ( QString ) ) );
+    QObject::connect ( &Channel, &CChannel::ChatTextReceived,
+        this, &CClient::ChatTextReceived );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( ClientIDReceived ( int ) ),
-        SIGNAL ( ClientIDReceived ( int ) ) );
+    QObject::connect ( &Channel, &CChannel::ClientIDReceived,
+        this, &CClient::ClientIDReceived );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( MuteStateHasChangedReceived ( int, bool ) ),
-        SIGNAL ( MuteStateHasChangedReceived ( int, bool ) ) );
+    QObject::connect ( &Channel, &CChannel::MuteStateHasChangedReceived,
+        this, &CClient::MuteStateHasChangedReceived );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( LicenceRequired ( ELicenceType ) ),
-        SIGNAL ( LicenceRequired ( ELicenceType ) ) );
+    QObject::connect ( &Channel, &CChannel::LicenceRequired,
+        this, &CClient::LicenceRequired );
 
-    QObject::connect ( &Channel,
-        SIGNAL ( VersionAndOSReceived ( COSUtil::EOpSystemType, QString ) ),
-        SIGNAL ( VersionAndOSReceived ( COSUtil::EOpSystemType, QString ) ) );
+    QObject::connect ( &Channel, &CChannel::VersionAndOSReceived,
+        this, &CClient::VersionAndOSReceived );
 
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLMessReadyForSending ( CHostAddress, CVector<uint8_t> ) ),
-        this, SLOT ( OnSendCLProtMessage ( CHostAddress, CVector<uint8_t> ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLMessReadyForSending,
+        this, &CClient::OnSendCLProtMessage );
 
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLServerListReceived ( CHostAddress, CVector<CServerInfo> ) ),
-        SIGNAL ( CLServerListReceived ( CHostAddress, CVector<CServerInfo> ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLServerListReceived,
+        this, &CClient::CLServerListReceived );
 
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLConnClientsListMesReceived ( CHostAddress, CVector<CChannelInfo> ) ),
-        SIGNAL ( CLConnClientsListMesReceived ( CHostAddress, CVector<CChannelInfo> ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLConnClientsListMesReceived,
+        this, &CClient::CLConnClientsListMesReceived );
 
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLPingReceived ( CHostAddress, int ) ),
-        this, SLOT ( OnCLPingReceived ( CHostAddress, int ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLPingReceived,
+        this, &CClient::OnCLPingReceived );
 
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLPingWithNumClientsReceived ( CHostAddress, int, int ) ),
-        this, SLOT ( OnCLPingWithNumClientsReceived ( CHostAddress, int, int ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLPingWithNumClientsReceived,
+        this, &CClient::OnCLPingWithNumClientsReceived );
 
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLDisconnection ( CHostAddress ) ),
-        this, SLOT ( OnCLDisconnection ( CHostAddress ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLDisconnection ,
+        this, &CClient::OnCLDisconnection );
 
 #ifdef ENABLE_CLIENT_VERSION_AND_OS_DEBUGGING
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLVersionAndOSReceived ( CHostAddress, COSUtil::EOpSystemType, QString ) ),
-        SIGNAL ( CLVersionAndOSReceived ( CHostAddress, COSUtil::EOpSystemType, QString ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLVersionAndOSReceived,
+        this, &CClient::CLVersionAndOSReceived );
 #endif
 
-    QObject::connect ( &ConnLessProtocol,
-        SIGNAL ( CLChannelLevelListReceived ( CHostAddress, CVector<uint16_t> ) ),
-        SIGNAL ( CLChannelLevelListReceived ( CHostAddress, CVector<uint16_t> ) ) );
+    QObject::connect ( &ConnLessProtocol, &CProtocol::CLChannelLevelListReceived,
+        this, &CClient::CLChannelLevelListReceived );
 
     // other
-    QObject::connect ( &Sound, SIGNAL ( ReinitRequest ( int ) ),
-        this, SLOT ( OnSndCrdReinitRequest ( int ) ) );
+    QObject::connect ( &Sound, &CSound::ReinitRequest,
+        this, &CClient::OnSndCrdReinitRequest );
 
-    QObject::connect ( &Sound,
-        SIGNAL ( ControllerInFaderLevel ( int, int ) ),
-        SIGNAL ( ControllerInFaderLevel ( int, int ) ) );
+    QObject::connect ( &Sound, &CSound::ControllerInFaderLevel,
+        this, &CClient::ControllerInFaderLevel );
 
-    QObject::connect ( &Socket, SIGNAL ( InvalidPacketReceived ( CHostAddress ) ),
-        this, SLOT ( OnInvalidPacketReceived ( CHostAddress ) ) );
+    QObject::connect ( &Socket, &CHighPrioSocket::InvalidPacketReceived,
+        this, &CClient::OnInvalidPacketReceived );
 
-    QObject::connect ( pSignalHandler,
-        SIGNAL ( HandledSignal ( int ) ),
-        this, SLOT ( OnHandledSignal ( int ) ) );
+    QObject::connect ( pSignalHandler, &CSignalHandler::HandledSignal,
+        this, &CClient::OnHandledSignal );
 
 
     // start the socket (it is important to start the socket after all
diff --git a/src/clientdlg.cpp b/src/clientdlg.cpp
index 159e5ab1..0aa4059f 100755
--- a/src/clientdlg.cpp
+++ b/src/clientdlg.cpp
@@ -402,158 +402,143 @@ CClientDlg::CClientDlg ( CClient*        pNCliP,
 
     // Connections -------------------------------------------------------------
     // push buttons
-    QObject::connect ( butConnect, SIGNAL ( clicked() ),
-        this, SLOT ( OnConnectDisconBut() ) );
+    QObject::connect ( butConnect, &QPushButton::clicked,
+        this, &CClientDlg::OnConnectDisconBut );
 
     // check boxes
-    QObject::connect ( chbSettings, SIGNAL ( stateChanged ( int ) ),
-        this, SLOT ( OnSettingsStateChanged ( int ) ) );
+    QObject::connect ( chbSettings, &QCheckBox::stateChanged,
+        this, &CClientDlg::OnSettingsStateChanged );
 
-    QObject::connect ( chbChat, SIGNAL ( stateChanged ( int ) ),
-        this, SLOT ( OnChatStateChanged ( int ) ) );
+    QObject::connect ( chbChat, &QCheckBox::stateChanged,
+        this, &CClientDlg::OnChatStateChanged );
 
-    QObject::connect ( chbLocalMute, SIGNAL ( stateChanged ( int ) ),
-        this, SLOT ( OnLocalMuteStateChanged ( int ) ) );
+    QObject::connect ( chbLocalMute, &QCheckBox::stateChanged,
+        this, &CClientDlg::OnLocalMuteStateChanged );
 
     // timers
-    QObject::connect ( &TimerSigMet, SIGNAL ( timeout() ),
-        this, SLOT ( OnTimerSigMet() ) );
+    QObject::connect ( &TimerSigMet, &QTimer::timeout,
+        this, &CClientDlg::OnTimerSigMet );
 
-    QObject::connect ( &TimerBuffersLED, SIGNAL ( timeout() ),
-        this, SLOT ( OnTimerBuffersLED() ) );
+    QObject::connect ( &TimerBuffersLED, &QTimer::timeout,
+        this, &CClientDlg::OnTimerBuffersLED );
 
-    QObject::connect ( &TimerStatus, SIGNAL ( timeout() ),
-        this, SLOT ( OnTimerStatus() ) );
+    QObject::connect ( &TimerStatus, &QTimer::timeout,
+        this, &CClientDlg::OnTimerStatus );
 
-    QObject::connect ( &TimerPing, SIGNAL ( timeout() ),
-        this, SLOT ( OnTimerPing() ) );
+    QObject::connect ( &TimerPing, &QTimer::timeout,
+        this, &CClientDlg::OnTimerPing );
 
     // sliders
-    QObject::connect ( sldAudioPan, SIGNAL ( valueChanged ( int ) ),
-        this, SLOT ( OnAudioPanValueChanged ( int ) ) );
+    QObject::connect ( sldAudioPan, &QSlider::valueChanged,
+        this, &CClientDlg::OnAudioPanValueChanged );
 
-    QObject::connect ( sldAudioReverb, SIGNAL ( valueChanged ( int ) ),
-        this, SLOT ( OnAudioReverbValueChanged ( int ) ) );
+    QObject::connect ( sldAudioReverb, &QSlider::valueChanged,
+        this, &CClientDlg::OnAudioReverbValueChanged );
 
     // radio buttons
-    QObject::connect ( rbtReverbSelL, SIGNAL ( clicked() ),
-        this, SLOT ( OnReverbSelLClicked() ) );
+    QObject::connect ( rbtReverbSelL, &QRadioButton::clicked,
+        this, &CClientDlg::OnReverbSelLClicked );
 
-    QObject::connect ( rbtReverbSelR, SIGNAL ( clicked() ),
-        this, SLOT ( OnReverbSelRClicked() ) );
+    QObject::connect ( rbtReverbSelR, &QRadioButton::clicked,
+        this, &CClientDlg::OnReverbSelRClicked );
 
     // other
-    QObject::connect ( pClient,
-        SIGNAL ( ConClientListMesReceived ( CVector<CChannelInfo> ) ),
-        this, SLOT ( OnConClientListMesReceived ( CVector<CChannelInfo> ) ) );
+    QObject::connect ( pClient, &CClient::ConClientListMesReceived,
+        this, &CClientDlg::OnConClientListMesReceived );
 
-    QObject::connect ( pClient,
-        SIGNAL ( Disconnected() ),
-        this, SLOT ( OnDisconnected() ) );
+    QObject::connect ( pClient, &CClient::Disconnected,
+        this, &CClientDlg::OnDisconnected );
 
-    QObject::connect ( pClient,
-        SIGNAL ( CentralServerAddressTypeChanged() ),
-        this, SLOT ( OnCentralServerAddressTypeChanged() ) );
+    QObject::connect ( pClient, &CClient::CentralServerAddressTypeChanged,
+        this, &CClientDlg::OnCentralServerAddressTypeChanged );
 
-    QObject::connect ( pClient,
-        SIGNAL ( ChatTextReceived ( QString ) ),
-        this, SLOT ( OnChatTextReceived ( QString ) ) );
+    QObject::connect ( pClient, &CClient::ChatTextReceived,
+        this, &CClientDlg::OnChatTextReceived );
 
-    QObject::connect ( pClient,
-        SIGNAL ( ClientIDReceived ( int ) ),
-        this, SLOT ( OnClientIDReceived ( int ) ) );
+    QObject::connect ( pClient, &CClient::ClientIDReceived,
+        this, &CClientDlg::OnClientIDReceived );
 
-    QObject::connect ( pClient,
-        SIGNAL ( MuteStateHasChangedReceived ( int, bool ) ),
-        this, SLOT ( OnMuteStateHasChangedReceived ( int, bool ) ) );
+    QObject::connect ( pClient, &CClient::MuteStateHasChangedReceived,
+        this, &CClientDlg::OnMuteStateHasChangedReceived );
 
     // This connection is a special case. On receiving a licence required message via the
     // protocol, a modal licence dialog is opened. Since this blocks the thread, we need
     // a queued connection to make sure the core protocol mechanism is not blocked, too.
     qRegisterMetaType<ELicenceType> ( "ELicenceType" );
-    QObject::connect ( pClient,
-        SIGNAL ( LicenceRequired ( ELicenceType ) ),
-        this, SLOT ( OnLicenceRequired ( ELicenceType ) ), Qt::QueuedConnection );
+    QObject::connect ( pClient, &CClient::LicenceRequired,
+        this, &CClientDlg::OnLicenceRequired, Qt::QueuedConnection );
 
-    QObject::connect ( pClient,
-        SIGNAL ( PingTimeReceived ( int ) ),
-        this, SLOT ( OnPingTimeResult ( int ) ) );
+    QObject::connect ( pClient, &CClient::PingTimeReceived,
+        this, &CClientDlg::OnPingTimeResult );
 
-    QObject::connect ( pClient,
-        SIGNAL ( CLServerListReceived ( CHostAddress, CVector<CServerInfo> ) ),
-        this, SLOT ( OnCLServerListReceived ( CHostAddress, CVector<CServerInfo> ) ) );
+    QObject::connect ( pClient, &CClient::CLServerListReceived,
+        this, &CClientDlg::OnCLServerListReceived );
 
-    QObject::connect ( pClient,
-        SIGNAL ( CLConnClientsListMesReceived ( CHostAddress, CVector<CChannelInfo> ) ),
-        this, SLOT ( OnCLConnClientsListMesReceived ( CHostAddress, CVector<CChannelInfo> ) ) );
+    QObject::connect ( pClient, &CClient::CLConnClientsListMesReceived,
+        this, &CClientDlg::OnCLConnClientsListMesReceived );
 
-    QObject::connect ( pClient,
-        SIGNAL ( CLPingTimeWithNumClientsReceived ( CHostAddress, int, int ) ),
-        this, SLOT ( OnCLPingTimeWithNumClientsReceived ( CHostAddress, int, int ) ) );
+    QObject::connect ( pClient, &CClient::CLPingTimeWithNumClientsReceived,
+        this, &CClientDlg::OnCLPingTimeWithNumClientsReceived );
 
-    QObject::connect ( pClient,
-        SIGNAL ( ControllerInFaderLevel ( int, int ) ),
-        this, SLOT ( OnControllerInFaderLevel ( int, int ) ) );
+    QObject::connect ( pClient, &CClient::ControllerInFaderLevel,
+        this, &CClientDlg::OnControllerInFaderLevel );
 
-    QObject::connect ( pClient,
-        SIGNAL ( CLChannelLevelListReceived ( CHostAddress, CVector<uint16_t> ) ),
-        this, SLOT ( OnCLChannelLevelListReceived ( CHostAddress, CVector<uint16_t> ) ) );
+    QObject::connect ( pClient, &CClient::CLChannelLevelListReceived,
+        this, &CClientDlg::OnCLChannelLevelListReceived );
 
-    QObject::connect ( pClient,
-        SIGNAL ( VersionAndOSReceived ( COSUtil::EOpSystemType, QString ) ),
-        this, SLOT ( OnVersionAndOSReceived ( COSUtil::EOpSystemType, QString ) ) );
+    QObject::connect ( pClient, &CClient::VersionAndOSReceived,
+        this, &CClientDlg::OnVersionAndOSReceived );
 
 #ifdef ENABLE_CLIENT_VERSION_AND_OS_DEBUGGING
-    QObject::connect ( pClient,
-        SIGNAL ( CLVersionAndOSReceived ( CHostAddress, COSUtil::EOpSystemType, QString ) ),
-        this, SLOT ( OnCLVersionAndOSReceived ( CHostAddress, COSUtil::EOpSystemType, QString ) ) );
+    QObject::connect ( pClient, &CClient::CLVersionAndOSReceived,
+        this, &CClientDlg::OnCLVersionAndOSReceived );
 #endif
 
-    QObject::connect ( QCoreApplication::instance(), SIGNAL ( aboutToQuit() ),
-        this, SLOT ( OnAboutToQuit() ) );
+    QObject::connect ( QCoreApplication::instance(), &QCoreApplication::aboutToQuit,
+        this, &CClientDlg::OnAboutToQuit );
 
-    QObject::connect ( &ClientSettingsDlg, SIGNAL ( GUIDesignChanged() ),
-        this, SLOT ( OnGUIDesignChanged() ) );
+    QObject::connect ( &ClientSettingsDlg, &CClientSettingsDlg::GUIDesignChanged,
+        this, &CClientDlg::OnGUIDesignChanged );
 
-    QObject::connect ( &ClientSettingsDlg, SIGNAL ( DisplayChannelLevelsChanged() ),
-        this, SLOT ( OnDisplayChannelLevelsChanged() ) );
+    QObject::connect ( &ClientSettingsDlg, &CClientSettingsDlg::DisplayChannelLevelsChanged,
+        this, &CClientDlg::OnDisplayChannelLevelsChanged );
 
-    QObject::connect ( &ClientSettingsDlg, SIGNAL ( AudioChannelsChanged() ),
-        this, SLOT ( OnAudioChannelsChanged() ) );
+    QObject::connect ( &ClientSettingsDlg, &CClientSettingsDlg::AudioChannelsChanged,
+        this, &CClientDlg::OnAudioChannelsChanged );
 
-    QObject::connect ( &ClientSettingsDlg, SIGNAL ( NewClientLevelChanged() ),
-        this, SLOT ( OnNewClientLevelChanged() ) );
+    QObject::connect ( &ClientSettingsDlg, &CClientSettingsDlg::NewClientLevelChanged,
+        this, &CClientDlg::OnNewClientLevelChanged );
 
-    QObject::connect ( MainMixerBoard, SIGNAL ( ChangeChanGain ( int, double, bool ) ),
-        this, SLOT ( OnChangeChanGain ( int, double, bool ) ) );
+    QObject::connect ( MainMixerBoard, &CAudioMixerBoard::ChangeChanGain,
+        this, &CClientDlg::OnChangeChanGain );
 
-    QObject::connect ( MainMixerBoard, SIGNAL ( ChangeChanPan ( int, double ) ),
-        this, SLOT ( OnChangeChanPan ( int, double ) ) );
+    QObject::connect ( MainMixerBoard, &CAudioMixerBoard::ChangeChanPan,
+        this, &CClientDlg::OnChangeChanPan );
 
-    QObject::connect ( MainMixerBoard, SIGNAL ( NumClientsChanged ( int ) ),
-        this, SLOT ( OnNumClientsChanged ( int ) ) );
+    QObject::connect ( MainMixerBoard, &CAudioMixerBoard::NumClientsChanged,
+        this, &CClientDlg::OnNumClientsChanged );
 
-    QObject::connect ( &ChatDlg, SIGNAL ( NewLocalInputText ( QString ) ),
-        this, SLOT ( OnNewLocalInputText ( QString ) ) );
+    QObject::connect ( &ChatDlg, &CChatDlg::NewLocalInputText,
+        this, &CClientDlg::OnNewLocalInputText );
 
-    QObject::connect ( &ConnectDlg, SIGNAL ( ReqServerListQuery ( CHostAddress ) ),
-        this, SLOT ( OnReqServerListQuery ( CHostAddress ) ) );
+    QObject::connect ( &ConnectDlg, &CConnectDlg::ReqServerListQuery,
+        this, &CClientDlg::OnReqServerListQuery );
 
     // note that this connection must be a queued connection, otherwise the server list ping
     // times are not accurate and the client list may not be retrieved for all servers listed
     // (it seems the sendto() function needs to be called from different threads to fire the
     // packet immediately and do not collect packets before transmitting)
-    QObject::connect ( &ConnectDlg, SIGNAL ( CreateCLServerListPingMes ( CHostAddress ) ),
-        this, SLOT ( OnCreateCLServerListPingMes ( CHostAddress ) ), Qt::QueuedConnection );
+    QObject::connect ( &ConnectDlg, &CConnectDlg::CreateCLServerListPingMes,
+        this, &CClientDlg::OnCreateCLServerListPingMes, Qt::QueuedConnection );
 
-    QObject::connect ( &ConnectDlg, SIGNAL ( CreateCLServerListReqVerAndOSMes ( CHostAddress ) ),
-        this, SLOT ( OnCreateCLServerListReqVerAndOSMes ( CHostAddress ) ) );
+    QObject::connect ( &ConnectDlg, &CConnectDlg::CreateCLServerListReqVerAndOSMes,
+        this, &CClientDlg::OnCreateCLServerListReqVerAndOSMes );
 
-    QObject::connect ( &ConnectDlg, SIGNAL ( CreateCLServerListReqConnClientsListMes ( CHostAddress ) ),
-        this, SLOT ( OnCreateCLServerListReqConnClientsListMes ( CHostAddress ) ) );
+    QObject::connect ( &ConnectDlg, &CConnectDlg::CreateCLServerListReqConnClientsListMes,
+        this, &CClientDlg::OnCreateCLServerListReqConnClientsListMes );
 
-    QObject::connect ( &ConnectDlg, SIGNAL ( accepted() ),
-        this, SLOT ( OnConnectDlgAccepted() ) );
+    QObject::connect ( &ConnectDlg, &CConnectDlg::accepted,
+        this, &CClientDlg::OnConnectDlgAccepted );
 
 
     // Initializations which have to be done after the signals are connected ---