- first attempt to remove QT

- this compiles but does not provide the same functionality
- hookplugin compiles
- other plugins do not

19 files changed, 920 insertions, 1104 deletions

diff --git a/AudioManagerDaemon/AudioManagerCore.cpp b/AudioManagerDaemon/AudioManagerCore.cpp
index 9133006..2db4b60 100644
--- a/AudioManagerDaemon/AudioManagerCore.cpp
+++ b/AudioManagerDaemon/AudioManagerCore.cpp
@@ -44,18 +44,21 @@ TaskAsyncConnect::~TaskAsyncConnect() {
 }
 
 void TaskAsyncConnect::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
-	QObject::connect((const QObject*) m_core->returnReceiver(),
-			SIGNAL(signal_ackConnect(genHandle_t, genError_t)),
-			(const QObject*) this,
-			SLOT(slot_connect_finished(genHandle_t, genError_t)));
-	m_timer = new QTimer();
-	m_timer->setSingleShot(true);
-	QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
-			SLOT(slot_timeout()));
-	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Connect"));
-	m_timer->start(CONNECT_TIMEOUT);
+	/**
+	 * \todo remove signals and slots, change to non QT timers
+	 */
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) m_core->returnReceiver(),
+//			SIGNAL(signal_ackConnect(genHandle_t, genError_t)),
+//			(const QObject*) this,
+//			SLOT(slot_connect_finished(genHandle_t, genError_t)));
+//	m_timer = new QTimer();
+//	m_timer->setSingleShot(true);
+//	QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
+//			SLOT(slot_timeout()));
+//	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Connect"));
+//	m_timer->start(CONNECT_TIMEOUT);
 	m_core->connect(m_ParamSource, m_ParamSink, &m_handle);
 }
 
@@ -77,15 +80,15 @@ source_t TaskAsyncConnect::getSource() {
 
 void TaskAsyncConnect::slot_connect_finished(genHandle_t handle,
 		genError_t error) {
-	if (handle == m_handle && error == GEN_OK) {
-		m_timer->stop();
-		delete m_timer;
-		m_timer = NULL;
-		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect returned"));
-		emit signal_nextTask();
-	} else {
-		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Somethings wrong with the connection"));
-	}
+//	if (handle == m_handle && error == GEN_OK) {
+//		m_timer->stop();
+//		delete m_timer;
+//		m_timer = NULL;
+//		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Connect returned"));
+//		emit signal_nextTask();
+//	} else {
+//		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Somethings wrong with the connection"));
+//	}
 }
 
 /**
@@ -103,11 +106,11 @@ TaskConnect::~TaskConnect() {
 }
 
 void TaskConnect::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
-	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Syncronous Connect"));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
+//	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Syncronous Connect"));
 	m_core->connect(m_ParamSource, m_ParamSink);
-	emit signal_nextTask();
+	//emit signal_nextTask();
 }
 
 TaskDisconnect::TaskDisconnect(AudioManagerCore* core, connection_t ID) :
@@ -118,10 +121,10 @@ TaskDisconnect::~TaskDisconnect() {
 }
 
 void TaskDisconnect::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->disconnect(m_ParamConnectionID);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskInterruptWait::TaskInterruptWait(AudioManagerCore* core,
@@ -134,16 +137,16 @@ TaskInterruptWait::~TaskInterruptWait() {
 }
 
 void TaskInterruptWait::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
-	QObject::connect((const QObject*) m_core->returnCommandInterface(),
-			SIGNAL(signal_interruptResume(genInt_t)), (const QObject*) this,
-			SLOT(slot_interrupt_ready(genInt_t)));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) m_core->returnCommandInterface(),
+//			SIGNAL(signal_interruptResume(genInt_t)), (const QObject*) this,
+//			SLOT(slot_interrupt_ready(genInt_t)));
 }
 
 void TaskInterruptWait::slot_interrupt_ready(genInt_t ID) {
 	if (ID == m_interruptID) {
-		emit signal_nextTask();
+		//emit signal_nextTask();
 	}
 }
 
@@ -173,11 +176,11 @@ sink_t TaskSetVolume::getSink() {
 }
 
 void TaskSetVolume::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
-	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Changed Volume"));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
+//	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Changed Volume"));
 	m_core->setVolume(m_sink, m_volume);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskSetSourceVolume::TaskSetSourceVolume(AudioManagerCore* core,
@@ -206,11 +209,11 @@ source_t TaskSetSourceVolume::getSource() {
 }
 
 void TaskSetSourceVolume::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started Changed Source Volume"));
 	m_core->setSourceVolume(m_source, m_volume);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskWait::TaskWait(AudioManagerCore* core, int mseconds) :
@@ -229,20 +232,20 @@ int TaskWait::getTime() {
 }
 
 void TaskWait::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
-	m_timer = new QTimer();
-	m_timer->setSingleShot(true);
-	QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
-			SLOT(slot_timeIsup()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
+//	m_timer = new QTimer();
+//	m_timer->setSingleShot(true);
+//	QObject::connect(m_timer, SIGNAL(timeout()), (const QObject*) this,
+//			SLOT(slot_timeIsup()));
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Start Sleep "));
-	m_timer->start(m_ParamMSeconds);
+//	m_timer->start(m_ParamMSeconds);
 }
 
 void TaskWait::slot_timeIsup() {
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Stop Sleep "));
-	m_timer->stop();
-	emit signal_nextTask();
+//	m_timer->stop();
+//	emit signal_nextTask();
 }
 
 TaskEnterUserConnect::TaskEnterUserConnect(AudioManagerCore* core,
@@ -263,11 +266,11 @@ genRoute_t TaskEnterUserConnect::returnConnection() {
 }
 
 void TaskEnterUserConnect::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->returnDatabaseHandler()->updateMainConnection(m_connectionID,
 			m_route);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskRemoveUserConnect::TaskRemoveUserConnect(AudioManagerCore* core,
@@ -288,14 +291,14 @@ connection_t TaskRemoveUserConnect::returnConnectionID() {
 }
 
 void TaskRemoveUserConnect::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->returnDatabaseHandler()->removeMainConnection(m_connectionID);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskEnterInterrupt::TaskEnterInterrupt(AudioManagerCore* core, genInt_t ID,
-		bool mixed, connection_t connID, QList<source_t> listInterruptedSources) :
+		bool mixed, connection_t connID, std::list<source_t> listInterruptedSources) :
 	Task(core), m_intID(ID), m_mixed(mixed), m_connectionID(connID),
 			m_interruptedSourcesList(listInterruptedSources) {
 }
@@ -304,11 +307,11 @@ TaskEnterInterrupt::~TaskEnterInterrupt() {
 }
 
 void TaskEnterInterrupt::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->returnDatabaseHandler()->updateInterrupt(m_intID, m_connectionID,
 			m_mixed, m_interruptedSourcesList);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskRemoveInterrupt::TaskRemoveInterrupt(AudioManagerCore* core, genInt_t ID) :
@@ -319,10 +322,10 @@ TaskRemoveInterrupt::~TaskRemoveInterrupt() {
 }
 
 void TaskRemoveInterrupt::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->returnDatabaseHandler()->removeInterrupt(m_intID);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskSetSourceMute::TaskSetSourceMute(AudioManagerCore* core, source_t source) :
@@ -333,10 +336,10 @@ TaskSetSourceMute::~TaskSetSourceMute() {
 }
 
 void TaskSetSourceMute::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->setSourceMute(m_source);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskSetSourceUnmute::TaskSetSourceUnmute(AudioManagerCore* core,
@@ -348,10 +351,10 @@ TaskSetSourceUnmute::~TaskSetSourceUnmute() {
 }
 
 void TaskSetSourceUnmute::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->setSourceUnMute(m_source);
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
 TaskEmitSignalConnect::TaskEmitSignalConnect(AudioManagerCore* core) :
@@ -362,28 +365,28 @@ TaskEmitSignalConnect::~TaskEmitSignalConnect() {
 }
 
 void TaskEmitSignalConnect::executeTask(Queue* queue) {
-	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
-			(const QObject*) queue, SLOT(slot_nextTask()));
+//	QObject::connect((const QObject*) this, SIGNAL(signal_nextTask()),
+//			(const QObject*) queue, SLOT(slot_nextTask()));
 	m_core->emitSignalConnect();
-	emit signal_nextTask();
+//	emit signal_nextTask();
 }
 
-Queue::Queue(AudioManagerCore* core, QString name) :
-	m_core(core), m_currentIndex(0), m_name(name), m_taskList(QList<Task*> ()) {
+Queue::Queue(AudioManagerCore* core, std::string name) :
+	m_core(core), m_currentIndex(0), m_name(name), m_taskList(std::list<Task*> ()) {
 	m_core->addQueue(this);
 }
 
 Queue::~Queue() {
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("shoot all tasks"));
-	foreach (Task* task, m_taskList) {
-		delete task;
-	}
+//	foreach (Task* task, m_taskList) {
+//		delete task;
+//	}
 	m_core->removeQueue(this);
 }
 
 void Queue::run() {
-	if (m_taskList.isEmpty() == false) {
-		Task* task = m_taskList.first();
+	if (m_taskList.empty() == false) {
+		Task* task = m_taskList.front();
 		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Started to execute Task"));
 		task->executeTask(this);
 	} else {
@@ -394,44 +397,44 @@ void Queue::run() {
 
 void Queue::slot_nextTask() {
 	m_currentIndex++;
-	if (m_currentIndex < m_taskList.length()) {
-		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Task "),DLT_INT(m_currentIndex),DLT_STRING(" out of ") ,DLT_INT(m_taskList.length()));
-		m_taskList.at(m_currentIndex)->executeTask(this);
-	} else {
-		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Finished all Tasks"));
-		this->~Queue();
-	}
+//	if (m_currentIndex < m_taskList.size()) {
+//		//m_currentIndex->executeTask(*this);
+//	} else {
+//		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Finished all Tasks"));
+//		this->~Queue();
+//	}
 }
 
 void Queue::addTask(Task* task) {
-	m_taskList.append(task);
+	m_taskList.push_back(task);
 }
 
 genError_t Queue::removeTask(Task* task) {
-	if (m_taskList.removeAll(task) > 0) {
-		return GEN_OK;
-	}
+//	if (m_taskList.remove(task) > 0) {
+//		return GEN_OK;
+//	}
 	return GEN_OUTOFRANGE;
 	void addQueue(Queue* queue);
 
 }
 
-QList<Task*> Queue::getTaskList() {
+std::list<Task*> Queue::getTaskList() {
 	return m_taskList;
 }
 
-QString Queue::returnName() {
+std::string Queue::returnName() {
 	return m_name;
 }
 
 AudioManagerCore::AudioManagerCore() :
-	m_queueList(QList<Queue*> ()) {
+	m_queueList(std::list<Queue*> ()) {
 }
 
 AudioManagerCore::~AudioManagerCore() {
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("delete all running queues"));
-	foreach (Queue* queue, m_queueList) {
-		delete queue;
+	std::list<Queue*>::iterator qIterator;
+	for(qIterator=m_queueList.begin();qIterator!=m_queueList.end();qIterator++) {
+		delete *qIterator;
 	}
 }
 
@@ -496,24 +499,24 @@ genError_t AudioManagerCore::UserSetVolume(sink_t sink, volume_t volume) {
 	return GEN_OK;
 }
 
-QList<ConnectionType> AudioManagerCore::getListConnections() {
+std::list<ConnectionType> AudioManagerCore::getListConnections() {
 	return m_databaseHandler->getListAllMainConnections();
 }
 
-QList<SinkType> AudioManagerCore::getListSinks() {
-	QList<SinkType> sinkList;
+std::list<SinkType> AudioManagerCore::getListSinks() {
+	std::list<SinkType> sinkList;
 	m_databaseHandler->getListofSinks(&sinkList);
 	return sinkList;
 }
 
-QList<SourceType> AudioManagerCore::getListSources() {
-	QList<SourceType> sourceList;
+std::list<SourceType> AudioManagerCore::getListSources() {
+	std::list<SourceType> sourceList;
 	m_databaseHandler->getListofSources(&sourceList);
 	return sourceList;
 }
 
 void AudioManagerCore::emitSignalConnect() {
-	emit signal_connectionChanged();
+//	emit signal_connecionChanged();
 }
 
 genError_t AudioManagerCore::connect(source_t source, sink_t sink,
@@ -593,7 +596,7 @@ genError_t AudioManagerCore::setSourceUnMute(source_t source) {
 }
 
 genError_t AudioManagerCore::getRoute(const bool onlyfree,
-		const source_t source, const sink_t sink, QList<genRoute_t>* ReturnList) {
+		const source_t source, const sink_t sink, std::list<genRoute_t>* ReturnList) {
 	m_hookHandler->fireHookRoutingRequest(onlyfree, source, sink, ReturnList);
 	return GEN_OK;
 }
@@ -604,22 +607,22 @@ connection_t AudioManagerCore::returnConnectionIDforSinkSource(sink_t sink,
 }
 
 genError_t AudioManagerCore::removeQueue(Queue* queue) {
-	if (m_queueList.removeAll(queue)) {
-		return GEN_OK;
-	} else {
-		return GEN_OUTOFRANGE;
-	}
+//	if (m_queueList.remove(*queue)) {
+//		return GEN_OK;
+//	} else {
+//		return GEN_OUTOFRANGE;
+//	}
 }
 
-source_t AudioManagerCore::returnSourceIDfromName(const QString name) {
+source_t AudioManagerCore::returnSourceIDfromName(const std::string name) {
 	return m_databaseHandler->get_Source_ID_from_Name(name);
 }
 
-sink_t AudioManagerCore::returnSinkIDfromName(const QString name) {
+sink_t AudioManagerCore::returnSinkIDfromName(const std::string name) {
 	return m_databaseHandler->get_Sink_ID_from_Name(name);
 }
 
 void AudioManagerCore::addQueue(Queue* queue) {
-	m_queueList.append(queue);
+	m_queueList.push_back(queue);
 }
 
diff --git a/AudioManagerDaemon/AudioManagerCore.h b/AudioManagerDaemon/AudioManagerCore.h
index 1f9be8d..9342ef2 100644
--- a/AudioManagerDaemon/AudioManagerCore.h
+++ b/AudioManagerDaemon/AudioManagerCore.h
@@ -26,7 +26,6 @@
 #ifndef AUDIOMANAGERCORE_H_
 #define AUDIOMANAGERCORE_H_
 
-#include <QtCore/QObject>
 
 #include "audioManagerIncludes.h"
 
@@ -57,15 +56,13 @@ class DBusCommandInterface;
  * \fn void Task::signal_nextTask()
  * \brief by emitting this signal, the next task in the queue is triggered
  */
-class Task: public QObject {
-Q_OBJECT
+class Task {
 public:
 	Task();
 	Task(AudioManagerCore* core);
 	virtual ~Task();
 	virtual void executeTask(Queue* queue)=0;
 
-signals:
 	void signal_nextTask();
 protected:
 	AudioManagerCore* m_core; //!< pointer to the core
@@ -102,7 +99,7 @@ protected:
  * \brief used to handle the timeout
  */
 class TaskAsyncConnect: public Task {
-Q_OBJECT
+
 public:
 	TaskAsyncConnect(AudioManagerCore* core, sink_t sink, source_t source);
 	virtual ~TaskAsyncConnect();
@@ -112,14 +109,16 @@ public:
 	source_t getSource();
 	void executeTask(Queue* queue);
 
-public slots:
 	void slot_connect_finished(genHandle_t handle, genError_t error);
 	void slot_timeout();
 private:
 	sink_t m_ParamSink; //!< the sink to be connected
 	source_t m_ParamSource; //!< the source to be connected
 	genHandle_t m_handle; //!< the handle (ConnectionID)
-	QTimer* m_timer; //!< pointer to a timer used for timeout tracking
+	//QTimer* m_timer; //!< pointer to a timer used for timeout tracking
+	/**
+	 * \todo implement non QT Timer
+	 */
 };
 
 /**
@@ -134,7 +133,7 @@ private:
  *
  */
 class TaskConnect: public Task {
-Q_OBJECT
+
 public:
 	TaskConnect(AudioManagerCore* core, sink_t sink, source_t source);
 	virtual ~TaskConnect();
@@ -156,7 +155,7 @@ private:
  *
  */
 class TaskDisconnect: public Task {
-Q_OBJECT
+
 public:
 	TaskDisconnect(AudioManagerCore* core, connection_t ID);
 	virtual ~TaskDisconnect();
@@ -179,12 +178,12 @@ private:
  * \param ID the interrupt ID of the interrupt that resumed
  */
 class TaskInterruptWait: public Task {
-Q_OBJECT
+
 public:
 	TaskInterruptWait(AudioManagerCore* core, genInt_t connectionID);
 	virtual ~TaskInterruptWait();
 	void executeTask(Queue* queue);
-public slots:
+
 	void slot_interrupt_ready(genInt_t ID);
 private:
 	genInt_t m_interruptID; //!< the interrupt ID that should be waited for
@@ -213,7 +212,7 @@ private:
  * \brief returns the volume
  */
 class TaskSetVolume: public Task {
-Q_OBJECT
+
 public:
 	TaskSetVolume(AudioManagerCore* core, volume_t newVolume=0, sink_t sink=0);
 	virtual ~TaskSetVolume();
@@ -250,7 +249,7 @@ private:
  * \brief returns the volume
  */
 class TaskSetSourceVolume: public Task {
-Q_OBJECT
+
 public:
 	TaskSetSourceVolume(AudioManagerCore* core, volume_t newVolume=0, source_t source=0);
 	virtual ~TaskSetSourceVolume();
@@ -286,19 +285,20 @@ private:
  * \brief slot called when the time is up
  */
 class TaskWait: public Task {
-Q_OBJECT
+
 public:
 	TaskWait(AudioManagerCore* core, int mseconds);
 	virtual ~TaskWait();
 	void setTime(int mseconds);
 	int getTime();
 	void executeTask(Queue* queue);
-
-public slots:
 	void slot_timeIsup();
 private:
 	int m_ParamMSeconds;//!< time to be delayed in milli seconds
-	QTimer* m_timer; //!< pointer to timer
+//	QTimer* m_timer; //!< pointer to timer
+	/**
+	 *\todo replace Qtimer
+	 */
 };
 
 /**
@@ -310,7 +310,7 @@ private:
  * \brief enters a user connect into the database
  */
 class TaskEnterUserConnect: public Task {
-Q_OBJECT
+
 public:
 	TaskEnterUserConnect(AudioManagerCore* core, genRoute_t route, connection_t connID=0);
 	virtual ~TaskEnterUserConnect();
@@ -330,7 +330,7 @@ private:
  * \brief constructor
  */
 class TaskRemoveUserConnect : public Task {
-Q_OBJECT
+
 public:
 	TaskRemoveUserConnect(AudioManagerCore* core, connection_t connID);
 	virtual ~TaskRemoveUserConnect();
@@ -346,16 +346,16 @@ private:
  * \brief enters an interrupt into the database
  */
 class TaskEnterInterrupt: public Task {
-Q_OBJECT
+
 public:
-	TaskEnterInterrupt(AudioManagerCore* core, genInt_t ID,bool mixed, connection_t connID,	QList<source_t> listInterruptedSources);
+	TaskEnterInterrupt(AudioManagerCore* core, genInt_t ID,bool mixed, connection_t connID,	std::list<source_t> listInterruptedSources);
 	virtual ~TaskEnterInterrupt();
 	void executeTask(Queue* queue);
 private:
 	genInt_t m_intID; //!< the interrupt ID
 	bool m_mixed; //!< true if mixed
 	connection_t m_connectionID; //!< the connection ID
-	QList<source_t> m_interruptedSourcesList; //!< the list of interrupted sources
+	std::list<source_t> m_interruptedSourcesList; //!< the list of interrupted sources
 };
 
 /**
@@ -363,7 +363,7 @@ private:
  * \brief removes an interrupt
  */
 class TaskRemoveInterrupt: public Task {
-Q_OBJECT
+
 public:
 	TaskRemoveInterrupt(AudioManagerCore* core, genInt_t ID);
 	virtual ~TaskRemoveInterrupt();
@@ -377,7 +377,7 @@ private:
  * \brief mutes a source
  */
 class TaskSetSourceMute: public Task {
-Q_OBJECT
+
 public:
 	TaskSetSourceMute(AudioManagerCore* core, source_t source);
 	virtual ~TaskSetSourceMute();
@@ -391,7 +391,7 @@ private:
  * \brief unmutes a source
  */
 class TaskSetSourceUnmute: public Task {
-Q_OBJECT
+
 public:
 	TaskSetSourceUnmute(AudioManagerCore* core, source_t source);
 	virtual ~TaskSetSourceUnmute();
@@ -405,7 +405,6 @@ private:
  * \brief emits the signal connect
  */
 class TaskEmitSignalConnect: public Task {
-Q_OBJECT
 public:
 	TaskEmitSignalConnect(AudioManagerCore* core);
 	virtual ~TaskEmitSignalConnect();
@@ -420,7 +419,7 @@ public:
  * \todo sorting of tasks
  * \todo add some function to attach parameters to the Queue so that organizing and handling is possible
  *
- * \fn Queue::Queue(AudioManagerCore* core,QString name="")
+ * \fn Queue::Queue(AudioManagerCore* core,std::string name="")
  * \brief constructor
  * \param name give the queue a name
  * \param core pointer to AudioManagerCore
@@ -437,38 +436,38 @@ public:
  * \param task pointer to the task
  * \return GEN_OK on success
  *
- * \fn 	QList<Task*> Queue::getTaskList()
+ * \fn 	std::list<Task*> Queue::getTaskList()
  * \brief returns the actual task list
  * \return list with pointers to the tasks
  *
- * \fn QString Queue::returnName()
+ * \fn std::string Queue::returnName()
  * \brief returns the name of the Queue
- * \return the name in QString format
+ * \return the name in std::string format
  *
  * \fn void Queue::slot_nextTask()
  * \brief is called when a task is finished and the next task can be called
  */
-class Queue: public QObject {
-Q_OBJECT
+class Queue{
+
 public:
-	Queue(AudioManagerCore* core,QString name="");
+	Queue(AudioManagerCore* core,std::string name="");
 	virtual ~Queue();
 	void run();
 	void addTask(Task* task);
 	genError_t removeTask(Task* task);
-	QList<Task*> getTaskList();
-	QString returnName();
+	std::list<Task*> getTaskList();
+	std::string returnName();
 
-public slots:
 	void slot_nextTask();
 private:
 	AudioManagerCore* m_core; //!< pointer to AudioManagerCore
-	int m_currentIndex; //!< the index of the list wich is currently worked on
-	QString m_name; //!< name of the Queue
-	QList<Task*> m_taskList; //!< the list with pointers to the tasks
+	std::list<Task*>::iterator m_currentIndex; //!< the index of the list wich is currently worked on
+	std::string m_name; //!< name of the Queue
+	std::list<Task*> m_taskList; //!< the list with pointers to the tasks
 };
 
-/**
+/**:3: error: ISO C++ forbids declaration of ‘type name’ with no type
+ *
  * \class AudioManagerCore
  * \brief The central Managing Class of the AudioManager
  *
@@ -502,25 +501,25 @@ private:
  * \fn genError_t AudioManagerCore::setSourceUnMute (source_t source)
  * \brief unmutes a source
  *
- * \fn genError_t AudioManagerCore::getRoute(const bool onlyfree, const source_t source, const sink_t sink, QList<genRoute_t>* ReturnList)
+ * \fn genError_t AudioManagerCore::getRoute(const bool onlyfree, const source_t source, const sink_t sink, std::list<genRoute_t>* ReturnList)
  * \brief returns a route
  *
  * \fn connection_t AudioManagerCore::returnConnectionIDforSinkSource (sink_t sink, source_t source)
  * \brief returns the connection ID for a sink source combination
  *
- * \fn source_t AudioManagerCore::returnSourceIDfromName(const QString name)
+ * \fn source_t AudioManagerCore::returnSourceIDfromName(const std::string name)
  * \brief returns the source ID for a name
  *
- * \fn sink_t AudioManagerCore::returnSinkIDfromName(const QString name)
+ * \fn sink_t AudioManagerCore::returnSinkIDfromName(const std::string name)
  * \brief returns the sink ID for a given name
  *
- * \fn QList<ConnectionType> AudioManagerCore::getListConnections()
+ * \fn std::list<ConnectionType> AudioManagerCore::getListConnections()
  * \brief returns the list of connections
  *
- * \fn QList<SinkType> AudioManagerCore::getListSinks()
+ * \fn std::list<SinkType> AudioManagerCore::getListSinks()
  * \brief returns a list of all sinks
  *
- * \fn QList<SourceType> AudioManagerCore::getListSources()
+ * \fn std::list<SourceType> AudioManagerCore::getListSources()
  * \brief returns a list of all sources
  *
  * \fn void AudioManagerCore::emitSignalConnect()
@@ -564,8 +563,8 @@ private:
  *
  *
  */
-class AudioManagerCore :public QObject {
-Q_OBJECT
+class AudioManagerCore {
+
 public:
 	AudioManagerCore();
 	virtual ~AudioManagerCore();
@@ -581,14 +580,14 @@ public:
 	genError_t setSourceMute (source_t source);
 	genError_t setSourceUnMute (source_t source);
 
-	genError_t getRoute(const bool onlyfree, const source_t source, const sink_t sink, QList<genRoute_t>* ReturnList);
+	genError_t getRoute(const bool onlyfree, const source_t source, const sink_t sink, std::list<genRoute_t>* ReturnList);
 	connection_t returnConnectionIDforSinkSource (sink_t sink, source_t source);
-	source_t returnSourceIDfromName(const QString name);
-	sink_t returnSinkIDfromName(const QString name);
+	source_t returnSourceIDfromName(const std::string name);
+	sink_t returnSinkIDfromName(const std::string name);
 
-	QList<ConnectionType> getListConnections();
-	QList<SinkType> getListSinks();
-	QList<SourceType> getListSources();
+	std::list<ConnectionType> getListConnections();
+	std::list<SinkType> getListSinks();
+	std::list<SourceType> getListSources();
 
 	void emitSignalConnect();
 
@@ -607,7 +606,6 @@ public:
 	void addQueue(Queue* queue);
 	genError_t removeQueue(Queue* queue);
 
-signals:
 	void signal_connectionChanged();
 	void signal_numberOfSinksChanged();
 	void signal_numberOfSourcesChanged();
@@ -620,7 +618,7 @@ private:
 	RoutingReceiver* m_receiver; //!< pointer to the Routing receiver Class
 	DBusCommandInterface* m_command; //!< pointer to the command Interface Class
 
-	QList<Queue*> m_queueList; //!< List of pointers to all running queues
+	std::list<Queue*> m_queueList; //!< List of pointers to all running queues
 };
 
 #endif /* AUDIOMANAGERCORE_H_ */
diff --git a/AudioManagerDaemon/CMakeLists.txt b/AudioManagerDaemon/CMakeLists.txt
index aa1460e..eb96741 100644
--- a/AudioManagerDaemon/CMakeLists.txt
+++ b/AudioManagerDaemon/CMakeLists.txt
@@ -26,21 +26,13 @@ cmake_policy(SET CMP0015 NEW)
 
 file(MAKE_DIRECTORY ${DOC_OUTPUT_PATH})
 
-FIND_PACKAGE(Qt4 REQUIRED)
 FIND_PACKAGE(PkgConfig)
+pkg_check_modules(SQLITE REQUIRED sqlite3)
 pkg_check_modules(DLT REQUIRED automotive-dlt)
 pkg_check_modules(JACK REQUIRED jack)
 
 INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR} ${STD_INCLUDE_DIRS})
 
-# add Qt modules here, the include will setup QT_LIBRARIES
-SET(QT_USE_QTSQL TRUE)
-#SET(QT_USE_QTXML TRUE)
-SET(QT_USE_QTDBUS TRUE)
-SET(QT_USE_QTNETWORK TRUE)
-
-INCLUDE(${QT_USE_FILE})
-
 #all source files go here
 SET(AUDIOMAN_SRCS_CXX
 	AudioManagerCore.cpp
@@ -48,60 +40,33 @@ SET(AUDIOMAN_SRCS_CXX
     Router.cpp 
     DataBaseHandler.cpp
     main.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/DBusCommand.cpp
     DBusCommandInterface.cpp
     HookEngine.cpp
-    ${DBUS_FOLDER}/DBusTypes.cpp
+    PluginHandler.cpp
 )
 
 INCLUDE_DIRECTORIES(
 	include
 	${CMAKE_SOURCE_DIR} 
 	${STD_INCLUDE_DIRS}
-	${GLIB_INCLUDE_DIRS}
-	${PULSE_INCLUDE_DIRS}
 	${JACK_INCLUDE_DIRS}
 	${CMAKE_CURRENT_BINARY_DIR}
 	${DBUS_FOLDER}
-	${QT_INCLUDE_DIR} 
 	${DLT_INCLUDE_DIRS}
 )
 
-#every header that contains QT stuff like Q_OBJECT .... and must be mocced
-SET(AUDIOMAN_MOC_SRCS
-	Router.h 
-	DataBaseHandler.h
-	DBusCommandInterface.h
-	AudioManagerCore.h
-	RoutingReceive.h
-	${CMAKE_CURRENT_BINARY_DIR}/DBusCommand.h
-
-)
-
 LINK_DIRECTORIES(
 	${LINK_DIRECTORIES}
-	${GLIB_LIBRARY_DIRS}
 	${PULSE_LIBRARY_DIRS}
 	${JACK_LIBRARY_DIRS}
 	${DBUS_FOLDER}
 	${PROJECT_BINARY_DIR}/../plugins
 )
 
-#now take the headers, moc them and append the resulting moc files to the sources
-QT4_WRAP_CPP(AUDIOMAN_SRCS_CXX ${AUDIOMAN_MOC_SRCS})
-
 ADD_EXECUTABLE(AudioManager ${AUDIOMAN_SRCS_CXX})
 
-
-ADD_DEFINITIONS(${QT_DEFINITIONS})
-
 TARGET_LINK_LIBRARIES(AudioManager 
-	${QT_LIBRARIES}
-	RoutingPlugin
-	RoutingJackPlugin
-	TestPlugin
-	${PULSE_LIBRARIES}
-	${JACK_LIBRARIES}
+	${SQLITE_LIBRARIES}
 	${DLT_LIBRARIES}
 )
 
diff --git a/AudioManagerDaemon/DBusCommandInterface.cpp b/AudioManagerDaemon/DBusCommandInterface.cpp
index 775d5d6..3773536 100644
--- a/AudioManagerDaemon/DBusCommandInterface.cpp
+++ b/AudioManagerDaemon/DBusCommandInterface.cpp
@@ -24,29 +24,28 @@
  */
 
 #include "DBusCommandInterface.h"
-#include "DBusCommand.h"
 
-DBusCommandInterface::DBusCommandInterface(QObject* parent) {
-	(void) parent;
-REGISTER_METATYPES}
+DBusCommandInterface::DBusCommandInterface() {
+}
 
 void DBusCommandInterface::startupInterface() {
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Startup of DBUS Command interface"));
 
-	new DBusCommand(this);
-	QDBusConnection connection = QDBusConnection::sessionBus();
-	connection.registerService(QString(SERVICEINTERFACE));
-	if (connection.isConnected()) {
-		if (connection.registerObject(
-				"/Control",
-				this,
-				(QDBusConnection::ExportAdaptors
-						| QDBusConnection::ExportAllSignals))) {
-			DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Registered DBUS Command interface succsessfully"));
-		} else {
-			DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Failed to register DBUS Command interface succsessfully"));
-		}
-	}
+//	new DBusCommand(this);
+//	QDBusConnection connection = QDBusConnection::sessionBus();
+//	connection.registerService(QString(SERVICEINTERFACE));
+//	if (connection.isConnected()) {
+//		if (connection.registerObject(
+//				"/Control",
+//				this,
+//				(QDBusConnection::ExportAdaptors
+//						| QDBusConnection::ExportAllSignals))) {
+//			DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Registered DBUS Command interface succsessfully"));
+//		} else {
+//			DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Failed to register DBUS Command interface succsessfully"));
+//		}
+//	}
+//
 }
 
 int DBusCommandInterface::connect(int Source_ID, int Sink_ID) {
@@ -66,8 +65,8 @@ int DBusCommandInterface::disconnect(int Source_ID, int Sink_ID) {
 	}
 }
 
-int DBusCommandInterface::interruptRequest(const QString &SourceName,
-		const QString &SinkName) {
+int DBusCommandInterface::interruptRequest(const std::string &SourceName,
+		const std::string &SinkName) {
 	source_t sourceID = m_core->returnSourceIDfromName(SourceName);
 	sink_t sinkID = m_core->returnSinkIDfromName(SinkName);
 	genInt_t intID = -1;
@@ -76,31 +75,31 @@ int DBusCommandInterface::interruptRequest(const QString &SourceName,
 }
 
 int DBusCommandInterface::interruptResume(int InterruptID) {
-	emit signal_interruptResume(InterruptID);
+//	emit signal_interruptResume(InterruptID);
 	return 1;
 }
 
 void DBusCommandInterface::registerAudioManagerCore(AudioManagerCore* core) {
 	m_core = core;
-	QObject::connect((const QObject*) m_core,
-			SIGNAL(signal_connectionChanged()), (const QObject*) this,
-			SLOT(slot_connectionChanged()));
-	QObject::connect((const QObject*) m_core,
-			SIGNAL(signal_numberOfSinksChanged()), (const QObject*) this,
-			SLOT(slot_numberOfSinksChanged()));
-	QObject::connect((const QObject*) m_core,
-			SIGNAL(signal_numberOfSourcesChanged()), (const QObject*) this,
-			SLOT(slot_numberOfSourcesChanged()));
+//	QObject::connect((const QObject*) m_core,
+//			SIGNAL(signal_connectionChanged()), (const QObject*) this,
+//			SLOT(slot_connectionChanged()));
+//	QObject::connect((const QObject*) m_core,
+//			SIGNAL(signal_numberOfSinksChanged()), (const QObject*) this,
+//			SLOT(slot_numberOfSinksChanged()));
+//	QObject::connect((const QObject*) m_core,
+//			SIGNAL(signal_numberOfSourcesChanged()), (const QObject*) this,
+//			SLOT(slot_numberOfSourcesChanged()));
 }
 
 void DBusCommandInterface::slot_connectionChanged() {
-	emit signal_connectionChanged();
+//	emit signal_connectionChanged();
 }
 void DBusCommandInterface::slot_numberOfSinksChanged() {
-	emit signal_numberOfSinksChanged();
+//	emit signal_numberOfSinksChanged();
 }
 void DBusCommandInterface::slot_numberOfSourcesChanged() {
-	emit signal_numberOfSourcesChanged();
+//	emit signal_numberOfSourcesChanged();
 }
 
 int DBusCommandInterface::setVolume(int SinkID, int Volume) {
@@ -110,14 +109,14 @@ int DBusCommandInterface::setVolume(int SinkID, int Volume) {
 	return -1;
 }
 
-QList<SourceType> DBusCommandInterface::getListSources() {
+std::list<SourceType> DBusCommandInterface::getListSources() {
 	return m_core->getListSources();
 }
 
-QList<SinkType> DBusCommandInterface::getListSinks() {
+std::list<SinkType> DBusCommandInterface::getListSinks() {
 	return m_core->getListSinks();
 }
 
-QList<ConnectionType> DBusCommandInterface::getListConnections() {
+std::list<ConnectionType> DBusCommandInterface::getListConnections() {
 	return m_core->getListConnections();
 }
diff --git a/AudioManagerDaemon/DBusCommandInterface.h b/AudioManagerDaemon/DBusCommandInterface.h
index 8eaa51f..0534e18 100644
--- a/AudioManagerDaemon/DBusCommandInterface.h
+++ b/AudioManagerDaemon/DBusCommandInterface.h
@@ -27,7 +27,7 @@
 #define DBUSCOMMANDINTERFACE_H_
 
 #include "audioManagerIncludes.h"
-#include "DBusTypes.h"
+
 
 #define SERVICEINTERFACE "org.Genivi.ControllerInterface"
 
@@ -38,30 +38,27 @@ class AudioManagerCore;
  * It also implements some Application logic that needs to be triggered to execute the actions demanded by the HMI.
  * TODO: make a clear seperation between HMI Interface and Application Logic
  */
-class DBusCommandInterface: public QObject {
-Q_OBJECT
+class DBusCommandInterface  {
+
 public:
-	DBusCommandInterface(QObject *parent = 0);
+	DBusCommandInterface();
 	void registerAudioManagerCore(AudioManagerCore* core);
 	void startupInterface();
 
-public slots:
 	void slot_connectionChanged();
 	void slot_numberOfSinksChanged();
 	void slot_numberOfSourcesChanged();
 
-public Q_SLOTS:
 	// METHODS
 	int connect(int Source_ID, int Sink_ID);
 	int disconnect(int Source_ID, int Sink_ID);
-	QList<ConnectionType> getListConnections();
-	QList<SinkType> getListSinks();
-	QList<SourceType> getListSources();
-	int interruptRequest(const QString &SourceName, const QString &SinkName);
+	std::list<ConnectionType> getListConnections();
+	std::list<SinkType> getListSinks();
+	std::list<SourceType> getListSources();
+	int interruptRequest(const std::string &SourceName, const std::string &SinkName);
 	int interruptResume(int InterruptID);
 	int setVolume(int SinkID, int Volume);
 
-Q_SIGNALS: // SIGNALS
 	void signal_connectionChanged();
 	void signal_numberOfSinksChanged();
 	void signal_numberOfSourcesChanged();
@@ -69,7 +66,7 @@ Q_SIGNALS: // SIGNALS
 	void signal_interruptResume(genInt_t interruptID);
 
 private:
-	QList<int> getSourceIDsForSinkID(int SinkID);
+	std::list<int> getSourceIDsForSinkID(int SinkID);
 	AudioManagerCore* m_core;
 };
 
diff --git a/AudioManagerDaemon/DataBaseHandler.cpp b/AudioManagerDaemon/DataBaseHandler.cpp
index e16b1c5..ee9c1d0 100644
--- a/AudioManagerDaemon/DataBaseHandler.cpp
+++ b/AudioManagerDaemon/DataBaseHandler.cpp
@@ -4,7 +4,9 @@
  * AudioManangerDeamon
  *
  * \file DataBaseHandler.cpp
- *
+ *	if (query.exec(command) != true) {
+
+	}
  * \date 20.05.2011
  * \author Christian Müller (christian.ei.mueller@bmw.de)
  *
@@ -24,21 +26,29 @@
  */
 
 #include "DataBaseHandler.h"
+#include <cstdlib>
+#include <fstream>
+#include <stdio.h>
+#include <cstring>
+#include <sstream>
+#include <sqlite3.h>
 
 DataBaseHandler::DataBaseHandler() {
 
 	//knock down database
-	QString path = (QDir::home().path());
+	m_path = "/home/blacky";
 
-	path.append(QDir::separator()).append(AUDIO_DATABASE);
-	path = QDir::toNativeSeparators(path);
+	m_path.append("/");
+	m_path.append(AUDIO_DATABASE);
 
-	QFile db_file(path);
-	if (db_file.exists()) {
-		db_file.remove();
+	std::ifstream infile(m_path.c_str());
+
+	if (infile) {
+		remove(m_path.c_str());
+		DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("Knocked down database"));
 	}
 	if (!this->open_database()) {
-		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Problems with opening the database"));
+		DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("Problems with opening the database"));
 	}
 }
 
@@ -46,156 +56,107 @@ DataBaseHandler::~DataBaseHandler() {
 	this->close_database();
 }
 
-bool DataBaseHandler::open_database() {
-	m_database = QSqlDatabase::addDatabase("QSQLITE");
-	QString path = (QDir::home().path());
+bool DataBaseHandler::pQuery(std::string command) {
+	sqlite3_stmt* query;
+	if (sqlite3_exec(m_database,command.c_str(),NULL,&query,NULL)!= SQLITE_OK) {
+		DLT_LOG( AudioManager, DLT_LOG_ERROR, DLT_STRING("SQL Query failed:"), DLT_STRING(command.c_str()));
+		return false;
+	}
+	return true;
+}
+
+std::string DataBaseHandler::int2string(int i) {
+	std::stringstream out;
+	out << i;
+	return out.str();
+}
 
-	path.append(QDir::separator()).append(AUDIO_DATABASE);
-	path = QDir::toNativeSeparators(path);
-	m_database.setDatabaseName(path);
-	return m_database.open();
+bool DataBaseHandler::open_database() {
+	if (sqlite3_open_v2(m_path.c_str(), &m_database,SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL) == SQLITE_OK) {
+		return true;
+	} else {
+		return false;
+	}
 }
 
 void DataBaseHandler::close_database() {
-	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Closed Database"));
-	m_database.close();
+	DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("Closed Database"));
+	sqlite3_close(m_database);
 }
 
-bool DataBaseHandler::delete_data(QString table) {
-	QSqlQuery query;
-	QString comand = "DELETE FROM " + table;
-	return query.exec(comand);
+bool DataBaseHandler::delete_data(std::string table) {
+	std::string command = "DELETE FROM" + table;
+	if (!this->pQuery(command)) return false;
+	return true;
 }
 
 bool DataBaseHandler::create_tables() {
+	std::string command;
+	command="CREATE TABLE " + std::string(DOMAIN_TABLE) + " (ID INTEGER NOT NULL, DomainName VARCHAR(50), BusName VARCHAR(50), NodeName VARCHAR(50), EarlyMode BOOL, PRIMARY KEY(ID));";
+	if (!this->pQuery(command)) return false;
 
-	QSqlQuery query;
-	QString
-			command =
-					"CREATE TABLE " + QString(DOMAIN_TABLE)
-							+ " (ID INTEGER NOT NULL, DomainName VARCHAR(50), BusName VARCHAR(50), NodeName VARCHAR(50), EarlyMode BOOL, PRIMARY KEY(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(DOMAIN_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(SOURCE_CLASS_TABLE) + " (ID INTEGER NOT NULL, ClassName VARCHAR(50), VolumeOffset INTEGER, IsInterrupt BOOL, IsMixed BOOL, PRIMARY KEY(ID));";
+	if (!this->pQuery(command)) return false;
 
-	command
-			= "CREATE TABLE " + QString(SOURCE_CLASS_TABLE)
-					+ " (ID INTEGER NOT NULL, ClassName VARCHAR(50), VolumeOffset INTEGER, IsInterrupt BOOL, IsMixed BOOL, PRIMARY KEY(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(SOURCE_CLASS_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(SINK_CLASS_TABLE) + " (ID INTEGER NOT NULL, ClassName VARCHAR(50), PRIMARY KEY(ID));";
+	if (!this->pQuery(command)) return false;
 
-	command = "CREATE TABLE " + QString(SINK_CLASS_TABLE)
-			+ " (ID INTEGER NOT NULL, ClassName VARCHAR(50), PRIMARY KEY(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(SINK_CLASS_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(SOURCE_TABLE) + " (ID INTEGER NOT NULL, Name VARCHAR(50), Class_ID INTEGER, Domain_ID INTEGER, IsGateway BOOL, PRIMARY KEY(ID), FOREIGN KEY (Domain_ID) REFERENCES " + DOMAIN_TABLE + "(ID), FOREIGN KEY (Class_ID) REFERENCES " + SOURCE_CLASS_TABLE + "(ID));";
+	if (!this->pQuery(command)) return false;
 
-	command
-			= "CREATE TABLE " + QString(SOURCE_TABLE)
-					+ " (ID INTEGER NOT NULL, Name VARCHAR(50), Class_ID INTEGER, Domain_ID INTEGER, IsGateway BOOL, PRIMARY KEY(ID), FOREIGN KEY (Domain_ID) REFERENCES "
-					+ DOMAIN_TABLE + "(ID), FOREIGN KEY (Class_ID) REFERENCES "
-					+ SOURCE_CLASS_TABLE + "(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(SOURCE_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(SINK_TABLE) + " (ID INTEGER NOT NULL, Name VARCHAR(50), Class_ID INTEGER, Domain_ID INTEGER, IsGateway BOOL, PRIMARY KEY(ID), FOREIGN KEY (DOMAIN_ID) REFERENCES " + DOMAIN_TABLE + "(ID), FOREIGN KEY (Class_ID) REFERENCES " + SOURCE_CLASS_TABLE + "(ID));";
+	if (!this->pQuery(command)) return false;
 
-	command
-			= "CREATE TABLE " + QString(SINK_TABLE)
-					+ " (ID INTEGER NOT NULL, Name VARCHAR(50), Class_ID INTEGER, Domain_ID INTEGER, IsGateway BOOL, PRIMARY KEY(ID), FOREIGN KEY (DOMAIN_ID) REFERENCES "
-					+ DOMAIN_TABLE + "(ID), FOREIGN KEY (Class_ID) REFERENCES "
-					+ SOURCE_CLASS_TABLE + "(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(SOURCE_CLASS_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(GATEWAY_TABLE) + " (ID INTEGER NOT NULL, Name VARCHAR(50), Sink_ID INTEGER, Source_ID INTEGER, DomainSource_ID INTEGER, DomainSink_ID INTEGER, ControlDomain_ID Integer, IsBlocked BOOL, PRIMARY KEY(ID), FOREIGN KEY (Sink_ID) REFERENCES " + SINK_TABLE + "(ID), FOREIGN KEY (Source_ID) REFERENCES " + SOURCE_TABLE + "(ID),FOREIGN KEY (DomainSource_ID) REFERENCES " + DOMAIN_TABLE + "(ID),FOREIGN KEY (DomainSink_ID) REFERENCES " + DOMAIN_TABLE + "(ID));";
+	if (!this->pQuery(command)) return false;
 
-	command
-			= "CREATE TABLE " + QString(GATEWAY_TABLE)
-					+ " (ID INTEGER NOT NULL, Name VARCHAR(50), Sink_ID INTEGER, Source_ID INTEGER, DomainSource_ID INTEGER, DomainSink_ID INTEGER, ControlDomain_ID Integer, IsBlocked BOOL, PRIMARY KEY(ID), FOREIGN KEY (Sink_ID) REFERENCES "
-					+ SINK_TABLE + "(ID), FOREIGN KEY (Source_ID) REFERENCES "
-					+ SOURCE_TABLE
-					+ "(ID),FOREIGN KEY (DomainSource_ID) REFERENCES "
-					+ DOMAIN_TABLE
-					+ "(ID),FOREIGN KEY (DomainSink_ID) REFERENCES "
-					+ DOMAIN_TABLE + "(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(GATEWAY_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(CONNECTION_TABLE) + " (ID INTEGER NOT NULL, Source_ID INTEGER, Sink_ID INTEGER, PRIMARY KEY(ID));";
+	if (!this->pQuery(command)) return false;
 
-	command
-			= "CREATE TABLE " + QString(CONNECTION_TABLE)
-					+ " (ID INTEGER NOT NULL, Source_ID INTEGER, Sink_ID INTEGER, PRIMARY KEY(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(CONNECTION_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(INTERRUPT_TABLE) + " (ID INTEGER NOT NULL, Source_ID INTEGER, Sink_ID INTEGER, Connection_ID INTEGER, mixed BOOL, listInterruptedSources INTEGER, PRIMARY KEY(ID));";
+	if (!this->pQuery(command)) return false;
 
-	command
-			= "CREATE TABLE " + QString(INTERRUPT_TABLE)
-					+ " (ID INTEGER NOT NULL, Source_ID INTEGER, Sink_ID INTEGER, Connection_ID INTEGER, mixed BOOL, listInterruptedSources INTEGER, PRIMARY KEY(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(INTERRUPT_TABLE));
-		return false;
-	}
-
-	command
-			= "CREATE TABLE " + QString(MAIN_TABLE)
-					+ " (ID INTEGER NOT NULL, Source_ID INTEGER, Sink_ID INTEGER, route INTEGER, PRIMARY KEY(ID));";
-	if (query.exec(command) != true) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Databasehandler: Could not create table"), DLT_STRING(MAIN_TABLE));
-		return false;
-	}
+	command = "CREATE TABLE " + std::string(MAIN_TABLE) + " (ID INTEGER NOT NULL, Source_ID INTEGER, Sink_ID INTEGER, route INTEGER, PRIMARY KEY(ID));";
+	if (!this->pQuery(command)) return false;
 
 	return true;
-
 }
 
-domain_t DataBaseHandler::insert_into_Domains_table(QString DomainName,
-		QString BusName, QString NodeName, bool EarlyMode) {
-	QSqlQuery query;
-	QString _EarlyMode = "false";
+domain_t DataBaseHandler::insert_into_Domains_table(std::string DomainName, std::string BusName, std::string NodeName, bool EarlyMode) {
+	sqlite3_stmt* query;
+	std::string _EarlyMode = "false";
 	if (EarlyMode) {
 		_EarlyMode = "true";
 	}
 
-	QString command = "SELECT BusName,ID FROM " + QString(DOMAIN_TABLE)
-			+ " WHERE DomainName=\"" + DomainName + "\";";
+	std::string command = "SELECT BusName,ID FROM " + std::string(DOMAIN_TABLE) + " WHERE DomainName='" + DomainName + "'";
 
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			if (!query.value(0).toString().isEmpty()) {
-				return query.value(1).toInt();
+	if (sqlite3_exec(m_database,command.c_str(),NULL,&query,NULL)!= SQLITE_OK) {
+		if (sqlite3_step(query)==SQLITE_ROW) {
+			std::string name((const char*) sqlite3_column_text(query,0));
+			if (!name.empty()) {
+				return sqlite3_column_int(query,1);
 			} else {
-				command = "UPDATE " + QString(DOMAIN_TABLE) + "SET Busname="
-						+ BusName + " Nodename=" + NodeName + " EarlyMode="
-						+ _EarlyMode + " WHERE DomainName=" + DomainName;
+				command = "UPDATE " + std::string(DOMAIN_TABLE) + "SET Busname=" + BusName + " Nodename=" + NodeName + " EarlyMode=" + _EarlyMode + " WHERE DomainName=" + DomainName;
 			}
 		} else {
-			command = "INSERT INTO " + QString(DOMAIN_TABLE)
-					+ " (DomainName, BusName, NodeName, EarlyMode) VALUES (\""
-					+ DomainName + "\",\"" + BusName + "\",\"" + NodeName
-					+ "\",\"" + _EarlyMode + "\")";
+			command = "INSERT INTO " + std::string(DOMAIN_TABLE) + " (DomainName, BusName, NodeName, EarlyMode) VALUES ('" + DomainName + "','" + BusName + "'','" + NodeName + "','" + _EarlyMode + "')";
 		}
 	}
 
-	if (query.exec(command) != true) {
+	sqlite3_finalize(query);
+
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
 		return get_Domain_ID_from_Name(DomainName);
 	}
 }
-sourceClass_t DataBaseHandler::insert_into_Source_Class_table(
-		QString ClassName, volume_t VolumeOffset, bool IsInterrupt,
-		bool IsMixed) {
-	QSqlQuery query;
-	QString _IsInterrupt = "false";
-	QString _IsMixed = "false";
+
+sourceClass_t DataBaseHandler::insert_into_Source_Class_table(std::string ClassName, volume_t VolumeOffset, bool IsInterrupt, bool IsMixed) {
+	sqlite3_stmt* query;
+	std::string _IsInterrupt = "false";
+	std::string _IsMixed = "false";
 
 	if (IsInterrupt) {
 		_IsInterrupt = "true";
@@ -204,200 +165,166 @@ sourceClass_t DataBaseHandler::insert_into_Source_Class_table(
 		_IsMixed = "true";
 	}
 
-	QString command = "SELECT ID FROM " + QString(SOURCE_CLASS_TABLE)
-			+ " WHERE ClassName=\"" + ClassName + "\";";
+	std::string command = "SELECT ID FROM " + std::string(SOURCE_CLASS_TABLE) + " WHERE ClassName='" + ClassName + "';";
 
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			return query.value(0).toInt();
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			return sqlite3_column_int(query,0);
 		}
 	}
 
-	command = "INSERT INTO " + QString(SOURCE_CLASS_TABLE)
-			+ " (ClassName, VolumeOffset, IsInterrupt, IsMixed) VALUES (\""
-			+ ClassName + "\"," + QString::number(VolumeOffset) + ",\""
-			+ _IsInterrupt + "\",\"" + _IsMixed + "\")";
+	command = "INSERT INTO " + std::string(SOURCE_CLASS_TABLE) + " (ClassName, VolumeOffset, IsInterrupt, IsMixed) VALUES ('" + ClassName + "'," + int2string(VolumeOffset) + ",'" + _IsInterrupt + "','" + _IsMixed + "')";
 
-	if (query.exec(command) != true) {
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
-sink_t DataBaseHandler::insert_into_Sink_Class_table(QString ClassName) {
-	QSqlQuery query;
+sink_t DataBaseHandler::insert_into_Sink_Class_table(std::string ClassName) {
+	sqlite3_stmt* query;
 
-	QString command = "SELECT ID FROM " + QString(SINK_CLASS_TABLE)
-			+ " WHERE ClassName=\"" + ClassName + "\";";
+	std::string command = "SELECT ID FROM " + std::string(SINK_CLASS_TABLE) + " WHERE ClassName='" + ClassName + "';";
 
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			return query.value(0).toInt();
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			return sqlite3_column_int(query,0);
 		}
 	}
 
-	command = "INSERT INTO " + QString(SINK_CLASS_TABLE)
-			+ " (ClassName) VALUES (\"" + ClassName + "\")";
+	command = "INSERT INTO " + std::string(SINK_CLASS_TABLE) + " (ClassName) VALUES ('" + ClassName + "')";
 
-	if (query.exec(command) != true) {
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
-source_t DataBaseHandler::insert_into_Source_table(QString Name,
-		sourceClass_t Class_ID, domain_t Domain_ID, bool IsGateway) {
-	QSqlQuery query;
-	QString _IsGateway = "false";
+source_t DataBaseHandler::insert_into_Source_table(std::string Name, sourceClass_t Class_ID, domain_t Domain_ID, bool IsGateway) {
+	sqlite3_stmt* query;
+	std::string _IsGateway = "false";
 
 	if (IsGateway) {
 		_IsGateway = "true";
 	}
 
-	QString command = "SELECT ID FROM " + QString(SOURCE_TABLE)
-			+ " WHERE Name=\"" + Name + "\";";
+	std::string command = "SELECT ID FROM " + std::string(SOURCE_TABLE) + " WHERE Name='" + Name + "';";
 
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			return query.value(0).toInt();
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			return sqlite3_column_int(query,0);
 		}
 	}
 
-	command = "INSERT INTO " + QString(SOURCE_TABLE)
-			+ " (Name, Class_ID, Domain_ID, IsGateway) VALUES (\"" + Name
-			+ "\"," + QString::number(Class_ID) + ",\"" + QString::number(
-			Domain_ID) + "\",\"" + _IsGateway + "\")";
+	command = "INSERT INTO " + std::string(SOURCE_TABLE) + " (Name, Class_ID, Domain_ID, IsGateway) VALUES ('" + Name + "'," + int2string(Class_ID) + ",'" + int2string(Domain_ID) + "','" + _IsGateway + "')";
 
-	if (query.exec(command) != true) {
+	if (sqlite3_step(query)) {
 		return -1;
 	} else {
-		emit signal_numberOfSourcesChanged();
-		return query.lastInsertId().toInt();
+		//emit signal_numberOfSourcesChanged();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
-sink_t DataBaseHandler::insert_into_Sink_table(QString Name,
-		sinkClass_t Class_ID, domain_t Domain_ID, bool IsGateway) {
-	QSqlQuery query;
-	QString _IsGateway = "false";
+sink_t DataBaseHandler::insert_into_Sink_table(std::string Name, sinkClass_t Class_ID, domain_t Domain_ID, bool IsGateway) {
+	sqlite3_stmt* query;
+	std::string _IsGateway = "false";
 
 	if (IsGateway) {
 		_IsGateway = "true";
 	}
 
-	QString command = "SELECT ID FROM " + QString(SINK_TABLE)
-			+ " WHERE Name=\"" + Name + "\";";
+	std::string command = "SELECT ID FROM " + std::string(SINK_TABLE) + " WHERE Name='" + Name + "';";
 
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			return query.value(0).toInt();
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			return sqlite3_column_int(query,0);
 		}
 	}
 
-	command = "INSERT INTO " + QString(SINK_TABLE)
-			+ " (Name, Class_ID, Domain_ID, IsGateway) VALUES (\"" + Name
-			+ "\"," + QString::number(Class_ID) + ",\"" + QString::number(
-			Domain_ID) + "\",\"" + _IsGateway + "\")";
+	command = "INSERT INTO " + std::string(SINK_TABLE) + " (Name, Class_ID, Domain_ID, IsGateway) VALUES ('" + Name + "'," + int2string(Class_ID) + ",'" + int2string(Domain_ID) + "','" + _IsGateway + "')";
 
-	if (query.exec(command) != true) {
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		emit signal_numberOfSinksChanged();
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
-gateway_t DataBaseHandler::insert_into_Gatway_table(QString Name,
-		sink_t Sink_ID, source_t Source_ID, domain_t DomainSource_ID,
-		domain_t DomainSink_ID, domain_t ControlDomain_ID) {
-	QSqlQuery query;
-	QString command = "SELECT ID FROM " + QString(GATEWAY_TABLE)
-			+ " WHERE Name=\"" + Name + "\";";
+gateway_t DataBaseHandler::insert_into_Gatway_table(std::string Name, sink_t Sink_ID, source_t Source_ID, domain_t DomainSource_ID, domain_t DomainSink_ID, domain_t ControlDomain_ID) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT ID FROM " + std::string(GATEWAY_TABLE) + " WHERE Name='" + Name + "';";
 
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			return query.value(0).toInt();
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			return sqlite3_column_int(query,0);
 		}
 	}
 
-	command
-			= "INSERT INTO " + QString(GATEWAY_TABLE)
-					+ " (Name, Sink_ID, Source_ID, DomainSource_ID, DomainSink_ID, ControlDomain_ID, IsBlocked) VALUES (\""
-					+ Name + "\"," + QString::number(Sink_ID) + ","
-					+ QString::number(Source_ID) + "," + QString::number(
-					DomainSource_ID) + "," + QString::number(DomainSink_ID)
-					+ "," + QString::number(ControlDomain_ID) + ",\"false\")";
-	if (query.exec(command) != true) {
+	command = "INSERT INTO " + std::string(GATEWAY_TABLE) + " (Name, Sink_ID, Source_ID, DomainSource_ID, DomainSink_ID, ControlDomain_ID, IsBlocked) VALUES ('" + Name + "'," + int2string(Sink_ID) + "," + int2string(Source_ID) + "," + int2string(DomainSource_ID) + "," + int2string(DomainSink_ID) + "," + int2string(ControlDomain_ID) + ",'false')";
+
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
 genInt_t DataBaseHandler::reserveInterrupt(sink_t Sink_ID, source_t Source_ID) {
-	QSqlQuery query;
-	query.prepare(
-			"INSERT INTO " + QString(INTERRUPT_TABLE) + "(Source_ID, Sink_ID)"
-				" VALUES(:Source_ID, :Sink_ID)");
-	query.bindValue(":Source_ID", Source_ID);
-	query.bindValue(":Sink_ID", Sink_ID);
-	if (query.exec() != true) {
+	sqlite3_stmt* query;
+	std::string command= "INSERT INTO " + std::string(INTERRUPT_TABLE) + "(Source_ID, Sink_ID) VALUES(:Source_ID, :Sink_ID)";
+	sqlite3_prepare_v2(m_database,command.c_str(),NULL,&query,NULL);
+	sqlite3_bind_int(query,0, Source_ID);
+	sqlite3_bind_int(query,1, Sink_ID);
+
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
-genError_t DataBaseHandler::updateInterrupt(const genInt_t intID,
-		connection_t connID, bool mixed,
-		QList<source_t> listInterruptedSources) {
-	QSqlQuery query;
-	QString _mixed = "false";
+genError_t DataBaseHandler::updateInterrupt(const genInt_t intID, connection_t connID, bool mixed, std::list<source_t> listInterruptedSources) {
+	sqlite3_stmt* query;
+	std::string _mixed = "false";
 
 	if (mixed) {
 		_mixed = "true";
 	}
 
 	//This information is not handy to be stored directly in the database. So we put it on the heap and store the pointer to it.
-	QList<source_t>* pointer = new QList<source_t> (listInterruptedSources);
-
-	query.prepare(
-			"UPDATE " + QString(INTERRUPT_TABLE)
-					+ " SET Connection_ID=:Connection_ID, mixed=:mixed ,listInterruptedSources=:listInterruptedSources WHERE ID=:id");
-	query.bindValue(":Connection_ID", connID);
-	query.bindValue(":mixed", _mixed);
-	query.bindValue(":listInterruptedSources", int(pointer));
-	query.bindValue(":id", intID);
-	if (query.exec() != true) {
+	std::list<source_t>* pointer = new std::list<source_t>;
+	pointer=&listInterruptedSources;
+
+	std::string command="UPDATE " + std::string(INTERRUPT_TABLE) + " SET Connection_ID=:Connection_ID, mixed=:mixed ,listInterruptedSources=:listInterruptedSources WHERE ID=:id";
+	sqlite3_prepare_v2(m_database,command.c_str(),NULL,&query,NULL);
+	sqlite3_bind_int(query,0,connID);
+	sqlite3_bind_text(query,1,_mixed.c_str(),_mixed.size(),NULL);
+	sqlite3_bind_int(query,2,int(pointer));
+	sqlite3_bind_int(query,3,intID);
+
+	if (!this->pQuery(command)) {
 		return GEN_DATABASE_ERROR;
 	} else {
 		return GEN_OK;
 	}
 }
 
-genError_t DataBaseHandler::getInterruptDatafromID(const genInt_t intID,
-		connection_t* return_connID, sink_t* return_Sink_ID,
-		source_t* return_Source_ID, bool* return_mixed,
-		QList<source_t>** return_listInterruptedSources) {
-	QSqlQuery query;
-	QString
-			command =
-					"SELECT Connection_ID, Sink_ID, Source_ID, mixed, listInterruptedSources FROM "
-							+ QString(INTERRUPT_TABLE) + " WHERE ID="
-							+ QString::number(intID) + ";";
+genError_t DataBaseHandler::getInterruptDatafromID(const genInt_t intID, connection_t* return_connID, sink_t* return_Sink_ID, source_t* return_Source_ID, bool* return_mixed, std::list<source_t>** return_listInterruptedSources) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT Connection_ID, Sink_ID, Source_ID, mixed, listInterruptedSources FROM " + std::string(INTERRUPT_TABLE) + " WHERE ID=" + int2string(intID) + ";";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)!=true) {
 		return GEN_DATABASE_ERROR;
 	} else {
-		if (query.next()) {
-			*return_connID = query.value(0).toInt();
-			*return_Sink_ID = query.value(1).toInt();
-			*return_Source_ID = query.value(2).toInt();
-			*return_mixed = query.value(3).toBool();
-			*return_listInterruptedSources
-					= reinterpret_cast<QList<source_t>*> (query.value(4).toInt());
+		if (sqlite3_step(query)) {
+			*return_connID = sqlite3_column_int(query,0);
+			*return_Sink_ID = sqlite3_column_int(query,1);
+			*return_Source_ID = sqlite3_column_int(query,2);
+			*return_mixed = sqlite3_column_int(query,3);
+			*return_listInterruptedSources = reinterpret_cast<std::list<source_t>*>(sqlite3_column_int(query,4));
 			return GEN_OK;
 		} else {
 			return GEN_UNKNOWN;
@@ -406,17 +333,15 @@ genError_t DataBaseHandler::getInterruptDatafromID(const genInt_t intID,
 }
 
 genError_t DataBaseHandler::removeInterrupt(const genInt_t intID) {
-	QSqlQuery query;
-	QString command = "SELECT listInterruptedSources FROM " + QString(
-			INTERRUPT_TABLE) + " WHERE ID=" + QString::number(intID) + ";";
-	if (query.exec(command) != true) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT listInterruptedSources FROM " + std::string(INTERRUPT_TABLE) + " WHERE ID=" + int2string(intID) + ";";
+	if (SQexecute(command) != true) {
 		return GEN_DATABASE_ERROR;
 	} else {
-		if (query.next()) {
-			delete reinterpret_cast<QList<source_t>*> (query.value(0).toInt());
-			command = "DELETE FROM " + QString(INTERRUPT_TABLE)
-					+ " WHERE ID=\"" + QString::number(intID) + "\";";
-			if (query.exec(command) != true) {
+		if (sqlite3_step(query)) {
+			delete reinterpret_cast<std::list<source_t>*>(sqlite3_column_int(query,0));
+			command = "DELETE FROM " + std::string(INTERRUPT_TABLE) + " WHERE ID='" + int2string(intID) + "';";
+			if (!this->pQuery(command)) {
 				return GEN_DATABASE_ERROR;
 			} else {
 				return GEN_OK;
@@ -426,132 +351,109 @@ genError_t DataBaseHandler::removeInterrupt(const genInt_t intID) {
 	return GEN_UNKNOWN;
 }
 
-domain_t DataBaseHandler::peek_Domain_ID(QString DomainName) {
-	QSqlQuery query;
+domain_t DataBaseHandler::peek_Domain_ID(std::string DomainName) {
+	sqlite3_stmt* query;
 
-	QString command = "SELECT ID FROM " + QString(DOMAIN_TABLE)
-			+ " WHERE DomainName=\"" + DomainName + "\";";
+	std::string command = "SELECT ID FROM " + std::string(DOMAIN_TABLE) + " WHERE DomainName='" + DomainName + "';";
 
-	if (query.next()) {
-		return query.value(0).toInt();
-	} else {
-		command = "INSERT INTO " + QString(DOMAIN_TABLE)
-				+ " (DomainName) VALUES (\"" + DomainName + "\")";
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			return sqlite3_column_int(query,0);
+		} else {
+			command = "INSERT INTO " + std::string(DOMAIN_TABLE) + " (DomainName) VALUES ('" + DomainName + "')";
+		}
 	}
 
-	if (query.exec(command) != true) {
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
 domain_t DataBaseHandler::get_Domain_ID_from_Source_ID(source_t Source_ID) {
-	QSqlQuery query;
-	QString command = "SELECT Domain_ID FROM " + QString(SOURCE_TABLE)
-			+ " WHERE ID=" + QString::number(Source_ID) + ";";
+	sqlite3_stmt* query;
+	std::string command = "SELECT Domain_ID FROM " + std::string(SOURCE_TABLE) + " WHERE ID=" + int2string(Source_ID) + ";";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		query.next();
-		return query.value(0).toInt();
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
 domain_t DataBaseHandler::get_Domain_ID_from_Sink_ID(sink_t Sink_ID) {
-	QSqlQuery query;
-	QString command = "SELECT Domain_ID FROM " + QString(SINK_TABLE)
-			+ " WHERE ID=" + QString::number(Sink_ID) + ";";
+	sqlite3_stmt* query;
+	std::string command = "SELECT Domain_ID FROM " + std::string(SINK_TABLE) + " WHERE ID=" + int2string(Sink_ID) + ";";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		query.next();
-		return query.value(0).toInt();
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
-source_t DataBaseHandler::get_Source_ID_from_Name(QString name) {
-	QSqlQuery query;
-	QString command = "SELECT ID FROM " + QString(SOURCE_TABLE)
-			+ " WHERE Name=\"" + name + "\";";
+source_t DataBaseHandler::get_Source_ID_from_Name(std::string name) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT ID FROM " + std::string(SOURCE_TABLE) + " WHERE Name='" + name + "';";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		if (query.next()) {
-			return query.value(0).toInt();
-		} else {
-			return 0;
-		}
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
-sourceClass_t DataBaseHandler::get_Source_Class_ID_from_Name(QString name) {
-	QSqlQuery query;
-	QString command = "SELECT ID FROM " + QString(SOURCE_CLASS_TABLE)
-			+ " WHERE ClassName=\"" + name + "\";";
-	if (query.exec(command) != true) {
+sourceClass_t DataBaseHandler::get_Source_Class_ID_from_Name(std::string name) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT ID FROM " + std::string(SOURCE_CLASS_TABLE) + " WHERE ClassName='" + name + "';";
+
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		if (query.next()) {
-			return query.value(0).toInt();
-		} else {
-			return 0;
-		}
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
-domain_t DataBaseHandler::get_Domain_ID_from_Name(QString name) {
-	QSqlQuery query;
-	QString command = "SELECT ID FROM " + QString(DOMAIN_TABLE)
-			+ " WHERE DomainName=\"" + name + "\";";
+domain_t DataBaseHandler::get_Domain_ID_from_Name(std::string name) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT ID FROM " + std::string(DOMAIN_TABLE) + " WHERE DomainName='" + name + "';";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		if (query.next()) {
-			return query.value(0).toInt();
-		} else {
-			return 0;
-		}
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
-gateway_t DataBaseHandler::get_Gateway_ID_with_Domain_ID(
-		domain_t startDomain_ID, domain_t targetDomain_ID) {
-	QSqlQuery query;
-	QString command = "SELECT ID FROM " + QString(GATEWAY_TABLE)
-			+ " WHERE DomainSource_ID=" + QString::number(startDomain_ID)
-			+ " AND DomainSink_ID=" + QString::number(targetDomain_ID) + ";";
+gateway_t DataBaseHandler::get_Gateway_ID_with_Domain_ID(domain_t startDomain_ID, domain_t targetDomain_ID) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT ID FROM " + std::string(GATEWAY_TABLE) + " WHERE DomainSource_ID=" + int2string(startDomain_ID) + " AND DomainSink_ID=" + int2string(targetDomain_ID) + ";";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		if (query.next()) {
-			return query.value(0).toInt();
-		} else {
-			return 0;
-		}
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
-genError_t DataBaseHandler::get_Gateway_Source_Sink_Domain_ID_from_ID(
-		gateway_t Gateway_ID, source_t* return_Source_ID,
-		sink_t* return_Sink_ID, domain_t* return_ControlDomain_ID) {
-	QSqlQuery query;
-	QString command = "SELECT Source_ID, Sink_ID, ControlDomain_ID FROM "
-			+ QString(GATEWAY_TABLE) + " WHERE ID=" + QString::number(
-			Gateway_ID) + ";";
+genError_t DataBaseHandler::get_Gateway_Source_Sink_Domain_ID_from_ID(gateway_t Gateway_ID, source_t* return_Source_ID, sink_t* return_Sink_ID, domain_t* return_ControlDomain_ID) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT Source_ID, Sink_ID, ControlDomain_ID FROM " + std::string(GATEWAY_TABLE) + " WHERE ID=" + int2string(Gateway_ID) + ";";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return GEN_DATABASE_ERROR;
 	} else {
-		if (query.next()) {
-			*return_Source_ID = query.value(0).toInt();
-			*return_Sink_ID = query.value(1).toInt();
-			*return_ControlDomain_ID = query.value(2).toInt();
+		if (sqlite3_step(query)) {
+			*return_Source_ID = sqlite3_column_int(query,0);
+			*return_Sink_ID = sqlite3_column_int(query,1);
+			*return_ControlDomain_ID = sqlite3_column_int(query,2);
 			return GEN_OK;
 		} else {
 			return GEN_UNKNOWN;
@@ -559,135 +461,120 @@ genError_t DataBaseHandler::get_Gateway_Source_Sink_Domain_ID_from_ID(
 	}
 }
 
-void DataBaseHandler::get_Domain_ID_Tree(bool onlyfree, RoutingTree* Tree,
-		QList<RoutingTreeItem*>* allItems) {
-	QSqlQuery query;
+void DataBaseHandler::get_Domain_ID_Tree(bool onlyfree, RoutingTree* Tree, std::list<RoutingTreeItem*>* allItems) {
+	sqlite3_stmt* query;
 	int RootID = Tree->returnRootDomainID();
 	RoutingTreeItem *parent = Tree->returnRootItem();
-	QString _onlyfree = "false";
-	int i = 0;
+	std::string _onlyfree = "false";
+	unsigned int i = 0;
 
 	if (onlyfree) {
 		_onlyfree = "true";
 	}
 
-	query.prepare(
-			"SELECT ID,DomainSource_ID FROM " + QString(GATEWAY_TABLE)
-					+ " WHERE DomainSink_ID=:id AND IsBlocked=:flag;");
+	std::string command="SELECT ID,DomainSource_ID FROM " + std::string(GATEWAY_TABLE) + " WHERE DomainSink_ID=:id AND IsBlocked=:flag;";
 
+	sqlite3_prepare_v2(m_database,command.c_str(),NULL,&query,NULL);
 	do {
-		query.bindValue(":id", RootID);
-		query.bindValue(":flag", _onlyfree);
-		query.exec();
-		while (query.next()) {
-			allItems->append(
-					Tree->insertItem(query.value(1).toInt(),
-							query.value(0).toInt(), parent));
+		sqlite3_bind_int(query,0,RootID);
+		sqlite3_bind_text(query,1,_onlyfree.c_str(),_onlyfree.size(),NULL);
+		while (sqlite3_step(query)) {
+			allItems->push_back(Tree->insertItem(sqlite3_column_int(query,1), sqlite3_column_int(query,0), parent));
 		}
-		parent = allItems->value(i);
-		RootID = parent->returnDomainID();
+		std::list<RoutingTreeItem*>::iterator it=allItems->begin();
+		std::advance(it,i);
+		RootID = (*it)->returnDomainID();
 		i++;
-	} while (allItems->length() > i);
+	} while (allItems->size() > i);
 }
 
-QString DataBaseHandler::get_Bus_from_Domain_ID(domain_t Domain_ID) {
-	QSqlQuery query;
-	QString command = "SELECT BusName FROM " + QString(DOMAIN_TABLE)
-			+ " WHERE ID=" + QString::number(Domain_ID) + ";";
+std::string DataBaseHandler::get_Bus_from_Domain_ID(domain_t Domain_ID) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT BusName FROM " + std::string(DOMAIN_TABLE) + " WHERE ID=" + int2string(Domain_ID) + ";";
 
-	if (query.exec(command) != true) {
-		return NULL;
+	if (SQexecute(command)) {
+		return std::string("");
 	} else {
-		query.next();
-		return query.value(0).toString();
+		sqlite3_step(query);
+		return std::string((const char*)sqlite3_column_text(query,0));
 	}
 }
 
 domain_t DataBaseHandler::get_Domain_ID_from_Connection_ID(connection_t ID) {
-	QSqlQuery query;
-	QString command = "SELECT Source_ID FROM " + QString(CONNECTION_TABLE)
-			+ " WHERE ID=" + QString::number(ID) + ";";
+	sqlite3_stmt* query;
+	std::string command = "SELECT Source_ID FROM " + std::string(CONNECTION_TABLE) + " WHERE ID=" + int2string(ID) + ";";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return -1;
 	}
-	query.next();
-	int SourceID = query.value(0).toInt();
-	command = "SELECT Domain_ID FROM " + QString(SOURCE_TABLE) + " WHERE ID="
-			+ QString::number(SourceID) + ";";
-	if (query.exec(command) != true) {
+
+	sqlite3_step(query);
+	int SourceID = sqlite3_column_int(query,0);
+	command = "SELECT Domain_ID FROM " + std::string(SOURCE_TABLE) + " WHERE ID=" + int2string(SourceID) + ";";
+
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		query.next();
-		return query.value(0).toInt();
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
-void DataBaseHandler::getListofSources(QList<SourceType>* SourceList) {
-	QSqlQuery query;
+void DataBaseHandler::getListofSources(std::list<SourceType>* SourceList) {
+	sqlite3_stmt* query;
 	SourceType sType;
-	QString command = "SELECT ID,NAME FROM " + QString(SOURCE_TABLE)
-			+ " WHERE isGateway=\"false\";";
-	if (query.exec(command) != true) {
-
-	} else {
-		while (query.next()) {
-			sType.ID = query.value(0).toInt();
-			sType.name = query.value(1).toString();
-			SourceList->append(sType);
+	std::string command = "SELECT ID,NAME FROM " + std::string(SOURCE_TABLE) + " WHERE isGateway='false';";
+	if (SQexecute(command)) {
+		while (sqlite3_step(query)) {
+			sType.ID = sqlite3_column_int(query,0);
+			sType.name = std::string((const char*)sqlite3_column_text(query,1));
+			SourceList->push_back(sType);
 		}
 	}
 }
 
-void DataBaseHandler::getListofSinks(QList<SinkType>* SinkList) {
-	QSqlQuery query;
+void DataBaseHandler::getListofSinks(std::list<SinkType>* SinkList) {
+	sqlite3_stmt* query;
 	SinkType sType;
-	QString command = "SELECT ID,NAME FROM " + QString(SINK_TABLE) + ";";
-	if (query.exec(command) != true) {
-
-	} else {
-		while (query.next()) {
-			sType.ID = query.value(0).toInt();
-			sType.name = query.value(1).toString();
-			SinkList->append(sType);
+	std::string command = "SELECT ID,NAME FROM " + std::string(SINK_TABLE) + ";";
+	if (SQexecute(command)) {
+		while (sqlite3_step(query)) {
+			sType.ID = sqlite3_column_int(query,0);
+			sType.name =  std::string((const char*)sqlite3_column_text(query,1));
+			SinkList->push_back(sType);
 		}
 	}
 }
 
-void DataBaseHandler::getListofConnections(
-		QList<ConnectionType>* ConnectionList) {
-	QSqlQuery query;
-	ConnectionType sType;
-	QString command = "SELECT Source_ID,Sink_ID FROM " + QString(
-			CONNECTION_TABLE) + ";";
-	if (query.exec(command) != true) {
-
-	} else {
-		while (query.next()) {
-			sType.Source_ID = query.value(0).toInt();
-			sType.Sink_ID = query.value(1).toInt();
-			ConnectionList->append(sType);
+void DataBaseHandler::getListofConnections(std::list<ConnectionType>* ConnectionList) {
+	sqlite3_stmt* query;
+	ConnectionType cType;
+	std::string command = "SELECT Source_ID,Sink_ID FROM " + std::string(CONNECTION_TABLE) + ";";
+	if (SQexecute(command)) {
+		while (sqlite3_step(query)) {
+			cType.Source_ID = sqlite3_column_int(query,0);
+			cType.Sink_ID =  sqlite3_column_int(query,1);
+			ConnectionList->push_back(cType);
 		}
 	}
 }
 
 bool DataBaseHandler::is_source_Mixed(source_t source) {
-	QSqlQuery query;
+	sqlite3_stmt* query;
 	int classID = 0;
 
-	QString command = "SELECT Class_ID FROM " + QString(SOURCE_TABLE)
-			+ " WHERE ID=\"" + QString::number(source) + "\";";
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			classID = query.value(0).toInt();
+	std::string command = "SELECT Class_ID FROM " + std::string(SOURCE_TABLE) + " WHERE ID='" + int2string(source) + "';";
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			classID = sqlite3_column_int(query,0);
 		}
 	}
-	command = "SELECT isMixed FROM " + QString(SOURCE_CLASS_TABLE)
-			+ " WHERE ID=\"" + QString::number(classID) + "\";";
+	command = "SELECT isMixed FROM " + std::string(SOURCE_CLASS_TABLE) + " WHERE ID='" + int2string(classID) + "';";
 
-	if (query.exec(command) == true) {
-		if (query.next()) {
-			if (query.value(0).toString().compare("true") == 0) {
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			char* answer=(char*)sqlite3_column_text(query,0);
+			if (strcmp(answer,"true") == 0) {
 				return true;
 			}
 		}
@@ -695,111 +582,93 @@ bool DataBaseHandler::is_source_Mixed(source_t source) {
 	return false;
 }
 
-sink_t DataBaseHandler::get_Sink_ID_from_Name(QString name) {
-	QSqlQuery query;
-	QString command = "SELECT ID FROM " + QString(SINK_TABLE)
-			+ " WHERE Name=\"" + name + "\";";
+sink_t DataBaseHandler::get_Sink_ID_from_Name(std::string name) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT ID FROM " + std::string(SINK_TABLE) + " WHERE Name='" + name + "';";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		if (query.next()) {
-			return query.value(0).toInt();
-		} else {
-			return 0;
-		}
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
 connection_t DataBaseHandler::getConnectionID(source_t SourceID, sink_t SinkID) {
-	QSqlQuery query;
-	query.prepare(
-			"SELECT ID FROM " + QString(MAIN_TABLE)
-					+ " WHERE Source_ID=:sourceID AND Sink_ID=:sinkID");
-	query.bindValue(":sourceID", SourceID);
-	query.bindValue(":sinkID", SinkID);
-	if (query.exec() != true) {
+	sqlite3_stmt* query;
+	std::string command="SELECT ID FROM " + std::string(MAIN_TABLE) + " WHERE Source_ID=:sourceID AND Sink_ID=:sinkID";
+	sqlite3_prepare_v2(m_database,command.c_str(),NULL,&query,NULL);
+	sqlite3_bind_int(query,0,SourceID);
+	sqlite3_bind_int(query,1,SinkID);
+
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		if (query.next()) {
-			return query.value(0).toInt();
-		} else {
-			return -1;
-		}
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
 }
 
 connection_t DataBaseHandler::insertConnection(source_t SourceID, sink_t SinkID) {
-	QSqlQuery query;
-	QString command = "INSERT INTO " + QString(CONNECTION_TABLE)
-			+ " (Source_ID, Sink_ID) VALUES (" + QString::number(SourceID)
-			+ "," + QString::number(SinkID) + ");";
-	if (query.exec(command) != true) {
+	std::string command = "INSERT INTO " + std::string(CONNECTION_TABLE) + " (Source_ID, Sink_ID) VALUES (" + int2string(SourceID) + "," + int2string(SinkID) + ");";
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
 genError_t DataBaseHandler::removeConnection(connection_t ConnectionID) {
-	QSqlQuery query;
-	QString command = "DELETE FROM " + QString(CONNECTION_TABLE)
-			+ " WHERE ID=\"" + QString::number(ConnectionID) + "\";";
-	if (query.exec(command) != true) {
+	std::string command = "DELETE FROM " + std::string(CONNECTION_TABLE) + " WHERE ID='" + int2string(ConnectionID) + "';";
+	if (!this->pQuery(command)) {
 		return GEN_DATABASE_ERROR;
 	} else {
 		return GEN_OK;
 	}
 }
 
-connection_t DataBaseHandler::reserveMainConnection(source_t source,
-		sink_t sink) {
-	QSqlQuery query;
-	query.prepare("INSERT INTO " + QString(MAIN_TABLE) + "(Source_ID, Sink_ID)"
-		" VALUES(:Source_ID, :Sink_ID)");
-	query.bindValue(":Source_ID", source);
-	query.bindValue(":Sink_ID", sink);
-	if (query.exec() != true) {
+connection_t DataBaseHandler::reserveMainConnection(source_t source, sink_t sink) {
+	sqlite3_stmt* query;
+	std::string command = "INSERT INTO " + std::string(MAIN_TABLE) + "(Source_ID, Sink_ID) VALUES(:Source_ID, :Sink_ID)";
+	sqlite3_prepare_v2(m_database,command.c_str(),NULL,&query,NULL);
+	sqlite3_bind_int(query,0,source);
+	sqlite3_bind_int(query,1,sink);
+	if (!this->pQuery(command)) {
 		return -1;
 	} else {
-		return query.lastInsertId().toInt();
+		return sqlite3_last_insert_rowid(m_database);
 	}
 }
 
-genError_t DataBaseHandler::updateMainConnection(connection_t connID,
-		genRoute_t route) {
-	QSqlQuery query;
+genError_t DataBaseHandler::updateMainConnection(connection_t connID, genRoute_t route) {
+	sqlite3_stmt* query;
 
 	//This information is not handy to be stored directly in the database. So we put it on the heap and store the pointer to it.
 	genRoute_t* routeheap = new genRoute_t(route);
 
-	query.prepare(
-			"UPDATE " + QString(MAIN_TABLE)
-					+ " SET route=:route WHERE ID=:connID");
-	query.bindValue(":connID", connID);
-	query.bindValue(":route", int(routeheap));
-	if (query.exec() != true) {
+	std::string command = "UPDATE " + std::string(MAIN_TABLE) + " SET route=:route WHERE ID=:connID";
+	sqlite3_prepare_v2(m_database,command.c_str(),NULL,&query,NULL);
+	sqlite3_bind_int(query,0,connID);
+	sqlite3_bind_int(query,1,int(routeheap));
+
+	if (!this->pQuery(command)) {
 		return GEN_DATABASE_ERROR;
 	} else {
 		return GEN_OK;
 	}
 }
 
-genError_t DataBaseHandler::getMainConnectionDatafromID(
-		const connection_t connID, sink_t* return_sinkID,
-		source_t* return_sourceID, genRoute_t** return_route) {
-	QSqlQuery query;
-	QString command = "SELECT Sink_ID, Source_ID, route FROM " + QString(
-			MAIN_TABLE) + " WHERE ID=" + QString::number(connID) + ";";
+genError_t DataBaseHandler::getMainConnectionDatafromID(const connection_t connID, sink_t* return_sinkID, source_t* return_sourceID, genRoute_t** return_route) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT Sink_ID, Source_ID, route FROM " + std::string(MAIN_TABLE) + " WHERE ID=" + int2string(connID) + ";";
 
-	if (query.exec(command) != true) {
+	if (SQexecute(command)) {
 		return GEN_DATABASE_ERROR;
 	} else {
-		if (query.next()) {
-			*return_sinkID = query.value(0).toInt();
-			*return_sourceID = query.value(1).toInt();
-			*return_route
-					= reinterpret_cast<genRoute_t*> (query.value(2).toInt());
+		if (sqlite3_step(query)) {
+			*return_sinkID = sqlite3_column_int(query,0);
+			*return_sourceID = sqlite3_column_int(query,1);
+			*return_route = reinterpret_cast<genRoute_t*>(sqlite3_column_int(query,2));
 			return GEN_OK;
 		} else {
 			return GEN_UNKNOWN;
@@ -807,75 +676,60 @@ genError_t DataBaseHandler::getMainConnectionDatafromID(
 	}
 }
 
-connection_t DataBaseHandler::returnMainconnectionIDforSinkSourceID(
-		sink_t sink, source_t source) {
-	QSqlQuery query;
-	query.prepare(
-			"SELECT ID FROM " + QString(MAIN_TABLE)
-					+ " WHERE Sink_ID=:sinkID AND Source_ID=:SourceID");
-	query.bindValue(":SinkID", sink);
-	query.bindValue(":SourceID", source);
+connection_t DataBaseHandler::returnMainconnectionIDforSinkSourceID(sink_t sink, source_t source) {
+	sqlite3_stmt* query;
+	std::string command="SELECT ID FROM " + std::string(MAIN_TABLE) + " WHERE Sink_ID=:sinkID AND Source_ID=:SourceID";
+	sqlite3_prepare_v2(m_database,command.c_str(),NULL,&query,NULL);
+	sqlite3_bind_int(query,0,sink);
+	sqlite3_bind_int(query,1,source);
 
-	if (query.exec() != true) {
+	if (SQexecute(command)) {
 		return -1;
 	} else {
-		if (query.next()) {
-			return query.value(0).toInt();
-		}
+		sqlite3_step(query);
+		return sqlite3_column_int(query,0);
 	}
-	return -1;
-}
-
-QList<source_t> DataBaseHandler::getSourceIDsForSinkID(sink_t sink) {
-	QList<source_t> list;
-	QSqlQuery query;
-	query.prepare(
-			"SELECT Source_ID FROM " + QString(MAIN_TABLE)
-					+ " WHERE Sink_ID=:sinkID");
-	query.bindValue(":sinkID", sink);
-	if (query.exec() == true) {
-		DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("query good"));
-		while (query.next()) {
-			int p = query.value(0).toInt();
-			DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("SourceID"), DLT_INT(p));
-			list.append(query.value(0).toInt());
+}
+
+std::list<source_t> DataBaseHandler::getSourceIDsForSinkID(sink_t sink) {
+	std::list<source_t> list;
+	sqlite3_stmt* query;
+
+	std::string command="SELECT Source_ID FROM " + std::string(MAIN_TABLE) + " WHERE Sink_ID=" + int2string(sink);
+
+	if (SQexecute(command)) {
+		while (sqlite3_step(query)) {
+			list.push_back(sqlite3_column_int(query,0));
 		}
 	}
 	return list;
 }
 
-QList<ConnectionType> DataBaseHandler::getListAllMainConnections() {
-	QList<ConnectionType> connectionList;
-	QSqlQuery query;
-	QString command = "SELECT Sink_ID, Source_ID FROM " + QString(
-			MAIN_TABLE) + ";";
+std::list<ConnectionType> DataBaseHandler::getListAllMainConnections() {
+	std::list<ConnectionType> connectionList;
+	sqlite3_stmt* query;
+	std::string command = "SELECT Sink_ID, Source_ID FROM " + std::string(MAIN_TABLE) + ";";
 
-	if (query.exec(command) != true) {
-
-	} else {
-		while (query.next()) {
+	if (SQexecute(command)) {
+		while (sqlite3_step(query)) {
 			ConnectionType temp;
-			temp.Sink_ID = query.value(0).toInt();
-			temp.Source_ID = query.value(1).toInt();
-			connectionList.append(temp);
-			DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Added Connection"), DLT_INT(temp.Sink_ID),DLT_INT(temp.Source_ID));
+			temp.Sink_ID = sqlite3_column_int(query,0);
+			temp.Source_ID = sqlite3_column_int(query,1);
+			connectionList.push_back(temp);
+			DLT_LOG( AudioManager, DLT_LOG_INFO, DLT_STRING("Added Connection"), DLT_INT(temp.Sink_ID), DLT_INT(temp.Source_ID));
 		}
 	}
 	return connectionList;
 }
 
 genError_t DataBaseHandler::removeMainConnection(connection_t connID) {
-	QSqlQuery query;
-	QString command = "SELECT route FROM " + QString(MAIN_TABLE) + " WHERE ID="
-			+ QString::number(connID) + ";";
-	if (query.exec(command) != true) {
-		return GEN_DATABASE_ERROR;
-	} else {
-		if (query.next()) {
-			delete reinterpret_cast<genRoute_t*> (query.value(0).toInt());
-			command = "DELETE FROM " + QString(MAIN_TABLE) + " WHERE ID=\""
-					+ QString::number(connID) + "\";";
-			if (query.exec(command) != true) {
+	sqlite3_stmt* query;
+	std::string command = "SELECT route FROM " + std::string(MAIN_TABLE) + " WHERE ID=" + int2string(connID) + ";";
+	if (SQexecute(command)) {
+		if (sqlite3_step(query)) {
+			delete reinterpret_cast<genRoute_t*>(sqlite3_column_int(query,0));
+			command = "DELETE FROM " + std::string(MAIN_TABLE) + " WHERE ID='" + int2string(connID) + "';";
+			if (SQexecute(command)!=true) {
 				return GEN_DATABASE_ERROR;
 			} else {
 				return GEN_OK;
diff --git a/AudioManagerDaemon/DataBaseHandler.h b/AudioManagerDaemon/DataBaseHandler.h
index 03704af..5f3b516 100644
--- a/AudioManagerDaemon/DataBaseHandler.h
+++ b/AudioManagerDaemon/DataBaseHandler.h
@@ -26,6 +26,9 @@
 #ifndef DATABASEHANDLER_H_
 #define DATABASEHANDLER_H_
 
+#include <string>
+#include <sqlite3.h>
+
 #define AUDIO_DATABASE "audiomanagerDB.sqlite"
 
 #define DOMAIN_TABLE "Domains"
@@ -38,13 +41,7 @@
 #define INTERRUPT_TABLE "Interrupts"
 #define MAIN_TABLE "MainTable"
 
-#include <QtSql>
-#include <QString>
-#include <QObject>
-#include <QSqlDatabase>
-#include <QSqlError>
-#include <QFile>
-#include <qfile.h>
+#define SQexecute(command) sqlite3_exec(m_database,command.c_str(),NULL,&query,NULL)!= SQLITE_OK
 
 #include "audioManagerIncludes.h"
 
@@ -66,14 +63,14 @@ class RoutingTree;
  * \fn DataBaseHandler::close_database()
  * \brief closes the database
  *
- * \fn bool DataBaseHandler::delete_data(QString table)
+ * \fn bool DataBaseHandler::delete_data(std::string table)
  * \brief deletes the data of a complete table
  * \param table the name of the table to be deleted
  *
  * \fn bool DataBaseHandler::create_tables()
  * \brief creates all neccessary tables
  *
- * \fn domain_t DataBaseHandler::insert_into_Domains_table(QString DomainName, QString BusName, QString NodeName, bool EarlyMode)
+ * \fn domain_t DataBaseHandler::insert_into_Domains_table(std::string DomainName, std::string BusName, std::string NodeName, bool EarlyMode)
  * \brief inserts data into the domain table
  * \param DomainName the name to be inserted
  * \param BusName the name of the Bus that is used for the domain
@@ -81,7 +78,7 @@ class RoutingTree;
  * \param EarlyMode true if the domain is an early domain
  * \return the domain id (unique)
  *
- * \fn sourceClass_t DataBaseHandler::insert_into_Source_Class_table(QString ClassName, volume_t VolumeOffset, bool IsInterrupt, bool IsMixed)
+ * \fn sourceClass_t DataBaseHandler::insert_into_Source_Class_table(std::string ClassName, volume_t VolumeOffset, bool IsInterrupt, bool IsMixed)
  * \brief inserts data into the Source Class table
  * \param ClassName name of the class
  * \param VolumeOffset the volume offset of the class
@@ -89,12 +86,12 @@ class RoutingTree;
  * \param IsMixed true if it is mixed
  * \return the unique Class ID
  *
- * \fn sinkClass_t DataBaseHandler::insert_into_Sink_Class_table(QString ClassName)
+ * \fn sinkClass_t DataBaseHandler::insert_into_Sink_Class_table(std::string ClassName)
  * \brief enters new Sink Class in the Class Table
  * \param ClassName the name of the class
  * \return unique class ID
  *
- * \fn source_t DataBaseHandler::insert_into_Source_table(QString Name, sourceClass_t Class_ID, domain_t Domain_ID, bool IsGateway)
+ * \fn source_t DataBaseHandler::insert_into_Source_table(std::string Name, sourceClass_t Class_ID, domain_t Domain_ID, bool IsGateway)
  * \brief inserts a new source into the source table
  * \param Name the name of the source
  * \param Class_ID the class ID of the source
@@ -102,7 +99,7 @@ class RoutingTree;
  * \param IsGateway true if it is a gateway
  * \return returns a new source ID
  *
- * \fn sink_t DataBaseHandler::insert_into_Sink_table(QString Name, sinkClass_t Class_ID, domain_t Domain_ID, bool IsGateway)
+ * \fn sink_t DataBaseHandler::insert_into_Sink_table(std::string Name, sinkClass_t Class_ID, domain_t Domain_ID, bool IsGateway)
  * \brief inserts a new Sink into the table
  * \param Name the name of the sink
  * \param Class_ID the class ID
@@ -110,7 +107,7 @@ class RoutingTree;
  * \param IsGateway true if it is a gateway
  * \return the new Sink ID
  *
- * \fn gateway_t DataBaseHandler::insert_into_Gatway_table(QString Name, sink_t Sink_ID, source_t Source_ID, domain_t DomainSource_ID, domain_t DomainSink_ID, domain_t ControlDomain_ID)
+ * \fn gateway_t DataBaseHandler::insert_into_Gatway_table(std::string Name, sink_t Sink_ID, source_t Source_ID, domain_t DomainSource_ID, domain_t DomainSink_ID, domain_t ControlDomain_ID)
  * \brief inserts a gateway into the database
  * \param Name the name of the gateway
  * \param Sink_ID the sink id of the gateway
@@ -120,7 +117,7 @@ class RoutingTree;
  * \param ControlDomain_ID the domain which controls the gateway
  * \return the unique id of the gateway
  *
- * \fn domain_t DataBaseHandler::peek_Domain_ID(QString DomainName)
+ * \fn domain_t DataBaseHandler::peek_Domain_ID(std::string DomainName)
  * \brief reserves a domain ID but does not register it.
  * \details This function is used to register Gateways. The problem is that a gateway is registered from one domain that does not know if the other end of the gateway domain is already registered.
  * this can be solved via peeking a domain ID. By using this function the domain is only "reserved" not registered.
@@ -137,26 +134,26 @@ class RoutingTree;
  * \param Sink_ID the sink ID
  * \return the domain ID
  *
- * \fn source_t DataBaseHandler::get_Source_ID_from_Name(QString name)
+ * \fn source_t DataBaseHandler::get_Source_ID_from_Name(std::string name)
  * \brief returns the source ID from a name
  * \param name the name for witch the source ID shall be returned
  * \return the source ID
  *
- * \fn sourceClass_t DataBaseHandler::get_Source_Class_ID_from_Name(QString name)
+ * \fn sourceClass_t DataBaseHandler::get_Source_Class_ID_from_Name(std::string name)
  * \brief returns the source class ID from a given class name
  * \return the source class ID
  *
- * \fn domain_t DataBaseHandler::get_Domain_ID_from_Name(QString name)
+ * \fn domain_t DataBaseHandler::get_Domain_ID_from_Name(std::string name)
  * \brief returns the domain ID from given domain name
  * \param name the name
  * \return the domain ID
  *
- * \fn sink_t DataBaseHandler::get_Sink_ID_from_Name(QString name)
+ * \fn sink_t DataBaseHandler::get_Sink_ID_from_Name(std::string name)
  * \brief returns the Sink ID from a given name
  * \param name the name
  * \return the sink ID
  *
- * \fn QString DataBaseHandler::get_Bus_from_Domain_ID(domain_t Domain_ID)
+ * \fn std::string DataBaseHandler::get_Bus_from_Domain_ID(domain_t Domain_ID)
  * \brief returns the bus name for a given domain ID
  * \param Domain_ID the domain ID
  * \return the name of the bus
@@ -184,21 +181,21 @@ class RoutingTree;
  * \param return_Sink_ID call by reference Sink ID return value
  * \param return_ControlDomain_ID call by reference Control Domain ID return value
  *
- * \fn void DataBaseHandler::get_Domain_ID_Tree(bool onlyfree, RoutingTree* Tree, QList<RoutingTreeItem*>* allItems)
+ * \fn void DataBaseHandler::get_Domain_ID_Tree(bool onlyfree, RoutingTree* Tree, std::list<RoutingTreeItem*>* allItems)
  * \brief is used to create a Tree out of RoutingTreeItems. Used for routing algorithm
  * \param onlyfree if called with true then only routes via free gateways will be returned
  * \param Tree pointer the the Routing Tree
  * \param allItems pointer to a list of all Routing Tree Items as call by reference value
  *
- * \fn void DataBaseHandler::getListofSources(QList<SourceType>* SourceList)
+ * \fn void DataBaseHandler::getListofSources(std::list<SourceType>* SourceList)
  * \brief returns a list of all sources
  * \param SourceList call by reference pointer to return value
  *
- * \fn void DataBaseHandler::getListofSinks(QList<SinkType>* SinkList)
+ * \fn void DataBaseHandler::getListofSinks(std::list<SinkType>* SinkList)
  * \brief returns a list of all sinks
  * \param SinkList call by reference pointer to return value
  *
- * \fn void DataBaseHandler::getListofConnections(QList<ConnectionType>* ConnectionList)
+ * \fn void DataBaseHandler::getListofConnections(std::list<ConnectionType>* ConnectionList)
  * \brief returns a list of all connections
  * \param ConnectionList call by reference pointer to return value
  *
@@ -245,12 +242,12 @@ class RoutingTree;
  * \param source the source ID
  * \return the connection ID
  *
- * \fn QList<source_t> DataBaseHandler::getSourceIDsForSinkID (sink_t sink)
+ * \fn std::list<source_t> DataBaseHandler::getSourceIDsForSinkID (sink_t sink)
  * \brief returns the list of source IDs that are connected to a sink ID
  * \param sink the sink ID
  * \return a list of source IDs
  *
- * \fn QList<ConnectionType> DataBaseHandler::getListAllMainConnections()
+ * \fn std::list<ConnectionType> DataBaseHandler::getListAllMainConnections()
  * \brief returns a list of all mainconnections
  * \return a list of all connections
  *
@@ -266,7 +263,7 @@ class RoutingTree;
  * \param Source_ID the source ID
  * \return the interrupt ID
  *
- * \fn genError_t DataBaseHandler::updateInterrupt(const genInt_t intID,connection_t connID, bool mixed, QList<source_t> listInterrruptedSources)
+ * \fn genError_t DataBaseHandler::updateInterrupt(const genInt_t intID,connection_t connID, bool mixed, std::list<source_t> listInterrruptedSources)
  * \brief use this to enter the missing information into a reserved Interrupt into the database
  * \param intID the interrupt ID
  * \param connID the connection ID that is used
@@ -274,7 +271,7 @@ class RoutingTree;
  * \param listInterrruptedSources the list of interrupted sources. Used to restore the old state afterwards
  * \return GEN_OK on success
  *
- * \fn genError_t DataBaseHandler::getInterruptDatafromID(const genInt_t intID, connection_t* return_connID, sink_t* return_Sink_ID, source_t* return_Source_ID, bool* return_mixed, QList<source_t>** return_listInterrruptedSources)
+ * \fn genError_t DataBaseHandler::getInterruptDatafromID(const genInt_t intID, connection_t* return_connID, sink_t* return_Sink_ID, source_t* return_Source_ID, bool* return_mixed, std::list<source_t>** return_listInterrruptedSources)
  * \brief returns information about interrupts from the ID
  * \param intID the interrupt ID
  * \param return_connID pointer to call by reference connection ID
@@ -300,39 +297,39 @@ class RoutingTree;
  *
  */
 
-class DataBaseHandler: public QObject {
-Q_OBJECT
+class DataBaseHandler {
+
 public:
 	DataBaseHandler();
 	virtual ~DataBaseHandler();
 
 	bool open_database();
 	void close_database();
-	bool delete_data(QString table);
+	bool delete_data(std::string table);
 	bool create_tables();
 
-	domain_t insert_into_Domains_table(QString DomainName, QString BusName,
-			QString NodeName, bool EarlyMode);
-	sourceClass_t insert_into_Source_Class_table(QString ClassName,
+	domain_t insert_into_Domains_table(std::string DomainName, std::string BusName,
+			std::string NodeName, bool EarlyMode);
+	sourceClass_t insert_into_Source_Class_table(std::string ClassName,
 			volume_t VolumeOffset, bool IsInterrupt, bool IsMixed);
-	sinkClass_t insert_into_Sink_Class_table(QString ClassName);
-	source_t insert_into_Source_table(QString Name, sourceClass_t Class_ID,
+	sinkClass_t insert_into_Sink_Class_table(std::string ClassName);
+	source_t insert_into_Source_table(std::string Name, sourceClass_t Class_ID,
 			domain_t Domain_ID, bool IsGateway);
-	sink_t insert_into_Sink_table(QString Name, sinkClass_t Class_ID,
+	sink_t insert_into_Sink_table(std::string Name, sinkClass_t Class_ID,
 			domain_t Domain_ID, bool IsGateway);
-	gateway_t insert_into_Gatway_table(QString Name, sink_t Sink_ID,
+	gateway_t insert_into_Gatway_table(std::string Name, sink_t Sink_ID,
 			source_t Source_ID, domain_t DomainSource_ID,
 			domain_t DomainSink_ID, domain_t ControlDomain_ID);
 
-	domain_t peek_Domain_ID(QString DomainName);
+	domain_t peek_Domain_ID(std::string DomainName);
 	domain_t get_Domain_ID_from_Source_ID(source_t Source_ID);
 	domain_t get_Domain_ID_from_Sink_ID(sink_t Sink_ID);
 
-	source_t get_Source_ID_from_Name(QString name);
-	sourceClass_t get_Source_Class_ID_from_Name(QString name);
-	domain_t get_Domain_ID_from_Name(QString name);
-	sink_t get_Sink_ID_from_Name(QString name);
-	QString get_Bus_from_Domain_ID(domain_t Domain_ID);
+	source_t get_Source_ID_from_Name(std::string name);
+	sourceClass_t get_Source_Class_ID_from_Name(std::string name);
+	domain_t get_Domain_ID_from_Name(std::string name);
+	sink_t get_Sink_ID_from_Name(std::string name);
+	std::string get_Bus_from_Domain_ID(domain_t Domain_ID);
 	domain_t get_Domain_ID_from_Connection_ID(connection_t ID);
 
 	bool is_source_Mixed(source_t source);
@@ -343,11 +340,11 @@ public:
 			source_t* return_Source_ID, sink_t* return_Sink_ID,
 			domain_t* return_ControlDomain_ID);
 	void get_Domain_ID_Tree(bool onlyfree, RoutingTree* Tree,
-			QList<RoutingTreeItem*>* allItems);
+			std::list<RoutingTreeItem*>* allItems);
 
-	void getListofSources(QList<SourceType>* SourceList);
-	void getListofSinks(QList<SinkType>* SinkList);
-	void getListofConnections(QList<ConnectionType>* ConnectionList);
+	void getListofSources(std::list<SourceType>* SourceList);
+	void getListofSinks(std::list<SinkType>* SinkList);
+	void getListofConnections(std::list<ConnectionType>* ConnectionList);
 
 	connection_t getConnectionID(source_t SourceID, sink_t SinkID);
 	connection_t insertConnection(source_t SourceID, sink_t SinkID);
@@ -359,25 +356,27 @@ public:
 			genRoute_t** return_route);
 	connection_t returnMainconnectionIDforSinkSourceID(sink_t sink,
 			source_t source);
-	QList<source_t> getSourceIDsForSinkID(sink_t sink);
-	QList<ConnectionType> getListAllMainConnections();
+	std::list<source_t> getSourceIDsForSinkID(sink_t sink);
+	std::list<ConnectionType> getListAllMainConnections();
 	genError_t removeMainConnection(connection_t connID);
 	genInt_t reserveInterrupt(sink_t Sink_ID, source_t Source_ID);
 	genError_t updateInterrupt(const genInt_t intID, connection_t connID,
-			bool mixed, QList<source_t> listInterrruptedSources);
+			bool mixed, std::list<source_t> listInterrruptedSources);
 	genError_t getInterruptDatafromID(const genInt_t intID,
 			connection_t* return_connID, sink_t* return_Sink_ID,
 			source_t* return_Source_ID, bool* return_mixed,
-			QList<source_t>** return_listInterrruptedSources);
+			std::list<source_t>** return_listInterrruptedSources);
 	genError_t removeInterrupt(const genInt_t intID);
 
-signals:
 	void signal_connectionChanged();
 	void signal_numberOfSinksChanged();
 	void signal_numberOfSourcesChanged();
 
 private:
-	QSqlDatabase m_database; //!< pointer to database
+	bool pQuery(std::string command);
+	std::string int2string(int i);
+	sqlite3 *m_database; //!< pointer to database
+	std::string m_path;
 };
 
 #endif /* DATABASEHANDLER_H_ */
diff --git a/AudioManagerDaemon/HookEngine.cpp b/AudioManagerDaemon/HookEngine.cpp
index d78a88d..2f2eaa6 100644
--- a/AudioManagerDaemon/HookEngine.cpp
+++ b/AudioManagerDaemon/HookEngine.cpp
@@ -35,8 +35,8 @@ HookHandler::HookHandler() {
 }
 
 HookHandler::~HookHandler() {
-	foreach (BaseHook* hook,m_listofPlugins) {
-		hook->DeinitHook();
+	for (std::list<BaseHook*>::iterator hook = m_listofPlugins.begin(); hook != m_listofPlugins.end(); hook++) {
+		(*hook)->DeinitHook();
 	}
 }
 
@@ -51,7 +51,7 @@ genError_t BaseHook::registerHookEngine(HookHandler* engine) {
 
 genError_t HookHandler::registerHook(hookprio_t prio, genHook_t hookType, BaseHook* hookClass) {
 	prioList newEntry;
-	QList<prioList>* list;
+	std::list<prioList>* list;
 
 	if (prio < 0 || prio > 100) {
 		DLT_LOG( AudioManager, DLT_LOG_WARN, DLT_STRING("Register Hook: Priority out of range: "), DLT_INT(prio));
@@ -134,213 +134,192 @@ genError_t HookHandler::registerHook(hookprio_t prio, genHook_t hookType, BaseHo
 	}
 
 	int index = 0;
-	foreach(prioList l,*list)
-	{
-		if (l.prio > prio) {
+	std::list<prioList>::iterator l;
+	for (l = list->begin(); l != list->end(); l++) {
+		if (l->prio > prio) {
 			index++;
 		}
 	}
-	list->insert(index, newEntry);
+	std::advance(l, index);
+	list->insert(l, newEntry);
 	//TODO test the sorting of the hooks with more than one plugin
 
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookDomainRegister(char* Name, domain_t ID) {
-	foreach (prioList hook,m_domainRegisterList)
-	{
-		if (hook.hook->hookDomainRegister(Name, ID) == HOOK_STOP)
+	for (std::list<prioList>::iterator hook = m_domainRegisterList.begin(); hook != m_domainDeregisterList.end(); hook++) {
+		if (hook->hook->hookDomainRegister(Name, ID) == HOOK_STOP)
 			break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookDomainDeregister(domain_t ID) {
-	foreach (prioList hook,m_domainDeregisterList)
-	{
-		if (hook.hook->hookDomainDeregister(ID) == HOOK_STOP)
+	for (std::list<prioList>::iterator hook = m_domainDeregisterList.begin(); hook != m_domainDeregisterList.end(); hook++) {
+		if (hook->hook->hookDomainDeregister(ID) == HOOK_STOP)
 			break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookSinkRegister(char* Name, sink_t ID) {
-	foreach (prioList hook,m_sinkRegisterList)
-	{
-		if (hook.hook->hookSinkRegister(Name, ID) == HOOK_STOP)
+	for (std::list<prioList>::iterator hook = m_sinkRegisterList.begin(); hook != m_sinkRegisterList.end(); hook++) {
+		if (hook->hook->hookSinkRegister(Name, ID) == HOOK_STOP)
 			break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookSinkDeregister(sink_t ID) {
-	foreach (prioList hook,m_sinkDeregisterList)
-	{
-		if (hook.hook->hookSinkDeregister(ID) == HOOK_STOP)
+	for (std::list<prioList>::iterator hook = m_sinkDeregisterList.begin(); hook != m_sinkDeregisterList.end(); hook++) {
+		if (hook->hook->hookSinkDeregister(ID) == HOOK_STOP)
 			break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookSourceRegister(char* Name, source_t ID) {
-	foreach (prioList hook,m_sourceRegisterList)
-	{
-		if (hook.hook->hookSinkRegister(Name, ID) == HOOK_STOP)
+	for (std::list<prioList>::iterator hook = m_sourceRegisterList.begin(); hook != m_sourceRegisterList.end(); hook++) {
+		if (hook->hook->hookSourceRegister(Name, ID) == HOOK_STOP)
 			break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookSourceDeregister(source_t ID) {
-	foreach (prioList hook,m_sourceDeregisterList)
-	{
-		if (hook.hook->hookSourceDeregister(ID) == HOOK_STOP)
+	for (std::list<prioList>::iterator hook = m_sourceDeregisterList.begin(); hook != m_sourceDeregisterList.end(); hook++) {
+		if (hook->hook->hookSourceDeregister(ID) == HOOK_STOP)
 			break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookGatewayRegister(char* Name, gateway_t ID) {
-	foreach (prioList hook,m_gatewayRegisterList)
-	{
-		if (hook.hook->hookGatewayRegister(Name, ID) == HOOK_STOP)
+	for (std::list<prioList>::iterator hook = m_gatewayRegisterList.begin(); hook != m_gatewayRegisterList.end(); hook++) {
+		if (hook->hook->hookGatewayRegister(Name, ID) == HOOK_STOP)
 			break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookGatewayDeregister(gateway_t ID) {
-	foreach (prioList hook,m_gatewayDeregisterList)
-	{
-		if (hook.hook->hookGatewayDeregister(ID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_gatewayDeregisterList.begin(); hook != m_gatewayDeregisterList.end(); hook++) {
+		if (hook->hook->hookGatewayDeregister(ID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookSystemReady(void) {
-	foreach (prioList hook,m_systemReadyList)
-	{
-		if (hook.hook->hookSystemReady() == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_systemReadyList.begin(); hook != m_systemReadyList.end(); hook++) {
+		if (hook->hook->hookSystemReady() == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookSystemDown(void) {
-	foreach (prioList hook,m_systemDownList)
-	{
-		if (hook.hook->hookSystemDown() == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_systemDownList.begin(); hook != m_systemDownList.end(); hook++) {
+		if (hook->hook->hookSystemDown() == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookConnectionRequest(source_t SourceID, sink_t SinkID) {
-	foreach (prioList hook,m_connectionRequestList)
-	{
-		if (hook.hook->hookConnectionRequest(SourceID, SinkID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_connectionRequestList.begin(); hook != m_connectionRequestList.end(); hook++) {
+		if (hook->hook->hookConnectionRequest(SourceID, SinkID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookDisconnectionRequest(connection_t ID) {
-	foreach (prioList hook,m_disconnectionReuestList)
-	{
-		if (hook.hook->hookDisconnectionRequest(ID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_disconnectionReuestList.begin(); hook != m_disconnectionReuestList.end(); hook++) {
+		if (hook->hook->hookDisconnectionRequest(ID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookUserConnectionRequest(Queue* queue, source_t SourceID, sink_t SinkID) {
-	foreach (prioList hook,m_userConnectionRequestList)
-	{
-		if (hook.hook->hookUserConnectionRequest(queue, SourceID, SinkID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_userConnectionRequestList.begin(); hook != m_userConnectionRequestList.end(); hook++) {
+		if (hook->hook->hookUserConnectionRequest(queue, SourceID, SinkID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookUserDisconnectionRequest(Queue* queue, connection_t connID) {
-	foreach (prioList hook,m_userDisconnectionReuestList)
-	{
-		if (hook.hook->hookUserDisconnectionRequest(queue, connID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_userDisconnectionReuestList.begin(); hook != m_userDisconnectionReuestList.end(); hook++) {
+		if (hook->hook->hookUserDisconnectionRequest(queue, connID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
-genError_t HookHandler::fireHookRoutingRequest(bool onlyfree, source_t source, sink_t sink, QList<genRoute_t>* ReturnList) {
-	foreach (prioList hook,m_routingRequestList)
-	{
-		if (hook.hook->hookRoutingRequest(onlyfree, source, sink, ReturnList) == HOOK_STOP)
-			break;
+genError_t HookHandler::fireHookRoutingRequest(bool onlyfree, source_t source, sink_t sink, std::list<genRoute_t>* ReturnList) {
+	for (std::list<prioList>::iterator hook = m_routingRequestList.begin(); hook != m_routingRequestList.end(); hook++) {
+		if (hook->hook->hookRoutingRequest(onlyfree, source, sink, ReturnList) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 //todo change type
 genError_t HookHandler::fireHookRoutingComplete(genRoute_t route) {
-	foreach (prioList hook,m_routingCompleteList)
-	{
-		if (hook.hook->hookRoutingComplete(route) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_routingCompleteList.begin(); hook != m_routingCompleteList.end(); hook++) {
+		if (hook->hook->hookRoutingComplete(route) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookVolumeChange(volume_t newVolume, sink_t SinkID) {
-	foreach (prioList hook,m_volumeChangeList)
-	{
-		if (hook.hook->hookVolumeChange(newVolume, SinkID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_volumeChangeList.begin(); hook != m_volumeChangeList.end(); hook++) {
+		if (hook->hook->hookVolumeChange(newVolume, SinkID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookMuteSource(source_t ID) {
-	foreach (prioList hook,m_muteSourceList)
-	{
-		if (hook.hook->hookMuteSource(ID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_muteSourceList.begin(); hook != m_muteSourceList.end(); hook++) {
+		if (hook->hook->hookMuteSource(ID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookUnmuteSource(source_t ID) {
-	foreach (prioList hook,m_unmuteSourceList)
-	{
-		if (hook.hook->hookUnmuteSource(ID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_unmuteSourceList.begin(); hook != m_unmuteSourceList.end(); hook++) {
+		if (hook->hook->hookUnmuteSource(ID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookMuteSink(sink_t ID) {
-	foreach (prioList hook,m_muteSinkList)
-	{
-		if (hook.hook->hookMuteSink(ID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_muteSinkList.begin(); hook != m_muteSinkList.end(); hook++) {
+		if (hook->hook->hookMuteSink(ID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookUnmuteSink(sink_t ID) {
-	foreach (prioList hook,m_unmuteSinkList)
-	{
-		if (hook.hook->hookUnmuteSink(ID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_unmuteSinkList.begin(); hook != m_unmuteSinkList.end(); hook++) {
+		if (hook->hook->hookUnmuteSink(ID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
 
 genError_t HookHandler::fireHookInterruptRequest(Queue* queue, source_t interruptSource, sink_t sink, genInt_t* interruptID) {
-	foreach (prioList hook,m_interruptRequestList)
-	{
-		if (hook.hook->hookInterruptRequest(queue, interruptSource, sink, interruptID) == HOOK_STOP)
-			break;
+	for (std::list<prioList>::iterator hook = m_interruptRequestList.begin(); hook != m_interruptRequestList.end(); hook++) {
+		if (hook->hook->hookInterruptRequest(queue, interruptSource, sink, interruptID) == HOOK_STOP)
+		break;
 	}
 	return GEN_OK;
 }
@@ -351,19 +330,20 @@ void HookHandler::registerAudioManagerCore(AudioManagerCore* core) {
 
 void HookHandler::loadHookPlugins() {
 	BaseHook *b = NULL;
-	foreach (QObject *plugin, QPluginLoader::staticInstances()) {
-		HookPluginFactory* HookPluginFactory_ = qobject_cast<HookPluginFactory *>(plugin);
-		if (HookPluginFactory_) {
-			b = HookPluginFactory_->returnInstance();
-			b->registerHookEngine(this);
-			b->registerAudioManagerCore(m_core);
-			b->InitHook();
-			char pName[40];
-			if (b->returnPluginName(pName) == GEN_OK) {
-				DLT_LOG( AudioManager, DLT_LOG_INFO, DLT_STRING("Registered Hook Plugin:"), DLT_STRING(pName));
-				m_listofPlugins.append(b);
-			}
-		}
-	}
+//	foreach(QObject * plugin, QPluginLoader::staticInstances())
+//	{
+//		HookPluginFactory* HookPluginFactory_ = qobject_cast<HookPluginFactory *>(plugin);
+//		if (HookPluginFactory_) {
+//			b = HookPluginFactory_->returnInstance();
+//			b->registerHookEngine(this);
+//			b->registerAudioManagerCore(m_core);
+//			b->InitHook();
+//			char pName[40];
+//			if (b->returnPluginName(pName) == GEN_OK) {
+//				DLT_LOG( AudioManager, DLT_LOG_INFO, DLT_STRING("Registered Hook Plugin:"), DLT_STRING(pName));
+//				m_listofPlugins.append(b);
+//			}
+//		}
+//	}
 }
 
diff --git a/AudioManagerDaemon/HookEngine.h b/AudioManagerDaemon/HookEngine.h
index 6a43d26..33cd667 100644
--- a/AudioManagerDaemon/HookEngine.h
+++ b/AudioManagerDaemon/HookEngine.h
@@ -183,7 +183,7 @@ public:
 	}
 	;
 	virtual genHookResult_t hookRoutingRequest(bool onlyfree, source_t source,
-			sink_t sink, QList<genRoute_t>* ReturnList) {
+			sink_t sink, std::list<genRoute_t>* ReturnList) {
 		(void) onlyfree;
 		(void) source;
 		(void) sink;
@@ -282,8 +282,7 @@ public:
 			sink_t SinkID);
 	genError_t fireHookUserDisconnectionRequest(Queue* queue,
 			connection_t connID);
-	genError_t fireHookRoutingRequest(bool onlyfree, source_t SourceID,
-			sink_t SinkID, QList<genRoute_t>* ReturnList);
+	genError_t fireHookRoutingRequest(bool onlyfree, source_t SourceID, sink_t SinkID, std::list<genRoute_t>* ReturnList);
 	genError_t fireHookRoutingComplete(genRoute_t route);
 	genError_t fireHookVolumeChange(volume_t newVolume, sink_t SinkID);
 	genError_t fireHookMuteSource(source_t ID);
@@ -303,44 +302,31 @@ private:
 		hookprio_t prio;
 	};
 
-	QList<prioList> m_domainRegisterList;
-	QList<prioList> m_domainDeregisterList;
-	QList<prioList> m_sinkRegisterList;
-	QList<prioList> m_sinkDeregisterList;
-	QList<prioList> m_sourceRegisterList;
-	QList<prioList> m_sourceDeregisterList;
-	QList<prioList> m_gatewayRegisterList;
-	QList<prioList> m_gatewayDeregisterList;
-	QList<prioList> m_systemReadyList;
-	QList<prioList> m_systemDownList;
-	QList<prioList> m_connectionRequestList;
-	QList<prioList> m_disconnectionReuestList;
-	QList<prioList> m_userConnectionRequestList;
-	QList<prioList> m_userDisconnectionReuestList;
-	QList<prioList> m_routingRequestList;
-	QList<prioList> m_routingCompleteList;
-	QList<prioList> m_volumeChangeList;
-	QList<prioList> m_muteSourceList;
-	QList<prioList> m_unmuteSourceList;
-	QList<prioList> m_muteSinkList;
-	QList<prioList> m_unmuteSinkList;
-	QList<prioList> m_interruptRequestList;
+	std::list<prioList> m_domainRegisterList;
+	std::list<prioList> m_domainDeregisterList;
+	std::list<prioList> m_sinkRegisterList;
+	std::list<prioList> m_sinkDeregisterList;
+	std::list<prioList> m_sourceRegisterList;
+	std::list<prioList> m_sourceDeregisterList;
+	std::list<prioList> m_gatewayRegisterList;
+	std::list<prioList> m_gatewayDeregisterList;
+	std::list<prioList> m_systemReadyList;
+	std::list<prioList> m_systemDownList;
+	std::list<prioList> m_connectionRequestList;
+	std::list<prioList> m_disconnectionReuestList;
+	std::list<prioList> m_userConnectionRequestList;
+	std::list<prioList> m_userDisconnectionReuestList;
+	std::list<prioList> m_routingRequestList;
+	std::list<prioList> m_routingCompleteList;
+	std::list<prioList> m_volumeChangeList;
+	std::list<prioList> m_muteSourceList;
+	std::list<prioList> m_unmuteSourceList;
+	std::list<prioList> m_muteSinkList;
+	std::list<prioList> m_unmuteSinkList;
+	std::list<prioList> m_interruptRequestList;
 
 	AudioManagerCore* m_core;
-	QList<BaseHook*> m_listofPlugins;
+	std::list<BaseHook*> m_listofPlugins;
 };
 
-/**Factory class for plugin. Needs just to return an instance of the class that the plugin implements.
- *
- */
-class HookPluginFactory {
-public:
-	virtual ~HookPluginFactory() {
-	}
-	virtual BaseHook* returnInstance()=0;
-};
-
-Q_DECLARE_INTERFACE(HookPluginFactory,"HookPluginFactory/1.0")
-;
-
 #endif /* HOOKENGINE_H_ */
diff --git a/AudioManagerDaemon/PluginHandler.cpp b/AudioManagerDaemon/PluginHandler.cpp
new file mode 100644
index 0000000..478ce1f
--- /dev/null
+++ b/AudioManagerDaemon/PluginHandler.cpp
@@ -0,0 +1,18 @@
+/*
+ * PluginHandler.cpp
+ *
+ *  Created on: Jul 15, 2011
+ *      Author: blacky
+ */
+
+#include "PluginHandler.h"
+
+PluginHandler::PluginHandler() {
+	// TODO Auto-generated constructor stub
+
+}
+
+PluginHandler::~PluginHandler() {
+	// TODO Auto-generated destructor stub
+}
+
diff --git a/AudioManagerDaemon/PluginHandler.h b/AudioManagerDaemon/PluginHandler.h
new file mode 100644
index 0000000..47525c6
--- /dev/null
+++ b/AudioManagerDaemon/PluginHandler.h
@@ -0,0 +1,17 @@
+/*
+ * PluginHandler.h
+ *
+ *  Created on: Jul 15, 2011
+ *      Author: blacky
+ */
+
+#ifndef PLUGINHANDLER_H_
+#define PLUGINHANDLER_H_
+
+class PluginHandler {
+public:
+	PluginHandler();
+	virtual ~PluginHandler();
+};
+
+#endif /* PLUGINHANDLER_H_ */
diff --git a/AudioManagerDaemon/Router.cpp b/AudioManagerDaemon/Router.cpp
index 6952433..b507301 100644
--- a/AudioManagerDaemon/Router.cpp
+++ b/AudioManagerDaemon/Router.cpp
@@ -23,8 +23,6 @@
  *
  */
 
-#include <qstring.h>
-#include <QMutableListIterator>
 #include <iostream>
 #include <stdio.h>
 
@@ -43,7 +41,7 @@ void Router::registerDatabasehandler(DataBaseHandler* db_handler) {
 
 bool Router::get_Route_from_Source_ID_to_Sink_ID(const bool onlyfree,
 		const source_t Source_ID, const sink_t Sink_ID,
-		QList<genRoute_t>* ReturnList) {
+		std::list<genRoute_t>* ReturnList) {
 
 	domain_t Source_Domain = m_dbHandler->get_Domain_ID_from_Source_ID(
 			Source_ID); //first find out in which domains the source and sink are
@@ -54,11 +52,11 @@ bool Router::get_Route_from_Source_ID_to_Sink_ID(const bool onlyfree,
 	} //if source or sink does not exists, exit here
 
 	RoutingTree routingtree(Source_Domain); //Build up a Tree from the Source_Domain to every other domain.
-	QList<RoutingTreeItem*> flattree; //This list is the flat tree
-	QList<RoutingTreeItem*> matchtree; //This List holds all TreeItems which have the right Domain Sink IDs
-	QList<gateway_t> gwids; //holds all gateway ids of the route
+	std::list<RoutingTreeItem*> flattree; //This list is the flat tree
+	std::list<RoutingTreeItem*> matchtree; //This List holds all TreeItems which have the right Domain Sink IDs
+	std::list<gateway_t> gwids; //holds all gateway ids of the route
 	genRoutingElement_t element;
-	QList<genRoutingElement_t> actualRoutingElement;//intermediate list of current routing pairs
+	std::list<genRoutingElement_t> actualRoutingElement;//intermediate list of current routing pairs
 	genRoute_t actualRoute; //holds the actual Route
 	source_t ReturnSource = 0;
 	sink_t ReturnSink = 0;
@@ -69,46 +67,46 @@ bool Router::get_Route_from_Source_ID_to_Sink_ID(const bool onlyfree,
 	m_dbHandler->get_Domain_ID_Tree(onlyfree, &routingtree, &flattree); //Build up the tree out of the database as
 
 	//we go through the returned flattree and look for our sink, after that flattree holds only treeItems that match
-	foreach (RoutingTreeItem* rTree,flattree)
-		{
-			if (rTree->returnDomainID() == Sink_Domain) {
-				matchtree.append(rTree);
-			}
+	for(std::list<RoutingTreeItem*>::iterator rTree=flattree.begin();rTree!=flattree.end();rTree++) {
+		RoutingTreeItem *p=*rTree;
+		if (p->returnDomainID() == Sink_Domain) {
+			matchtree.push_back(*rTree);
 		}
+	}
 
 	//No we need to trace back the routes for each entry in matchtree
-	foreach (RoutingTreeItem* match, matchtree)
+	for(std::list<RoutingTreeItem*>::iterator match=matchtree.begin(); match!=matchtree.end(); match++)
 		{
 			//getting the route for the actual item
-			actualRoute.len = routingtree.getRoute(match, &gwids); //This gives only the Gateway IDs we need more
+			actualRoute.len = routingtree.getRoute(*match, &gwids); //This gives only the Gateway IDs we need more
 
 			//go throught the gatewayids and get more information
-			for (int i = 0; i < gwids.length(); i++) {
-				m_dbHandler->get_Gateway_Source_Sink_Domain_ID_from_ID(
-						gwids.value(i), &ReturnSource, &ReturnSink,
-						&ReturnDomain);
+			for (std::list<gateway_t>::iterator i=gwids.begin(); i!=gwids.end();i++) {
+				m_dbHandler->get_Gateway_Source_Sink_Domain_ID_from_ID(*i, &ReturnSource, &ReturnSink,&ReturnDomain);
 				//first routing pair is source to ReturnSink of course;
-				if (i == 0) {
-					element.source = Source_ID;
-					element.sink = ReturnSink;
-					element.Domain_ID = Source_Domain;
-				} else {
-					element.source = LastSource;
-					element.sink = ReturnSink;
-					element.Domain_ID = ReturnDomain;
-				}
-				actualRoutingElement.append(element);
+//				if (i == 0) {
+//					element.source = Source_ID;
+//					element.sink = ReturnSink;
+//					element.Domain_ID = Source_Domain;
+//				}
+//
+//				else {
+//					element.source = LastSource;
+//					element.sink = ReturnSink;
+//					element.Domain_ID = ReturnDomain;
+//				}
+				actualRoutingElement.push_back(element);
 				LastSource = ReturnSource;
 			}
 			element.source = LastSource;
 			element.sink = Sink_ID;
 			element.Domain_ID = Sink_Domain;
-			actualRoutingElement.append(element);
+			actualRoutingElement.push_back(element);
 
 			actualRoute.Source_ID = Source_ID;
 			actualRoute.Sink_ID = Sink_ID;
 			actualRoute.route = actualRoutingElement;
-			ReturnList->append(actualRoute);
+			ReturnList->push_back(actualRoute);
 		}
 
 	return true;
@@ -127,11 +125,13 @@ RoutingTreeItem::RoutingTreeItem() {
 }
 
 RoutingTreeItem::~RoutingTreeItem() {
-	qDeleteAll(childItems);
+	for (std::list<RoutingTreeItem*>::iterator i=childItems.begin();i!=childItems.end();i++) {
+		delete *i;
+	}
 }
 
 void RoutingTreeItem::appendChild(RoutingTreeItem *item) {
-	childItems.append(item);
+	childItems.push_back(item);
 }
 
 RoutingTreeItem *RoutingTreeItem::return_Parent() {
@@ -158,15 +158,15 @@ RoutingTreeItem* RoutingTree::insertItem(const domain_t Domain_ID,
 	RoutingTreeItem *newTree = new RoutingTreeItem(Domain_ID, Gateway_ID,
 			parentItem);
 	parentItem->appendChild(newTree);
-	m_allChildList.append(newTree);
+	m_allChildList.push_back(newTree);
 	return newTree;
 }
 
-int RoutingTree::getRoute(RoutingTreeItem* Targetitem, QList<gateway_t>* route) {
+int RoutingTree::getRoute(RoutingTreeItem* Targetitem, std::list<gateway_t>* route) {
 	int hopps = 0;
 	RoutingTreeItem *parentItem = Targetitem;
 	while (parentItem != &m_rootItem) {
-		route->prepend(parentItem->returnGatewayID());
+		route->push_front(parentItem->returnGatewayID());
 		hopps++;
 		parentItem = parentItem->return_Parent();
 	}
@@ -185,45 +185,45 @@ void Bushandler::load_Bus_plugins() {
 	RoutingSendInterface *b = NULL;
 	char BusName[40];
 	Bus newBus;
-	foreach (QObject *plugin, QPluginLoader::staticInstances())
-		{
-			strcpy(BusName, "");
-			RoutingInterfaceFactory* busInterfaceFactory = qobject_cast<
-					RoutingInterfaceFactory *> (plugin);
-			if (busInterfaceFactory) {
-				b = busInterfaceFactory->returnInstance();
-				b->return_BusName(BusName);
-				newBus.Name = QString(BusName);
-				newBus.sendInterface = b;
-				Busses.append(newBus);
-				QObject::connect((const QObject*) this,
-						SIGNAL (signal_system_ready(void)), (const QObject*) b,
-						SLOT(slot_system_ready(void)));
-				DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Bushandler:Found new bus interface"), DLT_STRING(newBus.Name.toAscii()));
-			}
-		}
+//	foreach (QObject *plugin, QPluginLoader::staticInstances())
+//		{
+//			strcpy(BusName, "");
+//			RoutingInterfaceFactory* busInterfaceFactory = qobject_cast<
+//					RoutingInterfaceFactory *> (plugin);
+//			if (busInterfaceFactory) {
+//				b = busInterfaceFactory->returnInstance();
+//				b->return_BusName(BusName);
+//				newBus.Name = QString(BusName);
+//				newBus.sendInterface = b;
+//				Busses.append(newBus);
+//				QObject::connect((const QObject*) this,
+//						SIGNAL (signal_system_ready(void)), (const QObject*) b,
+//						SLOT(slot_system_ready(void)));
+//				DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Bushandler:Found new bus interface"), DLT_STRING(newBus.Name.toAscii()));
+//			}
+//		}
 }
 
 void Bushandler::StartupInterfaces() {
-	foreach (Bus bus, Busses)
-		{
-			bus.sendInterface->startup_interface(m_receiver);
-			DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Bushandler:Started Interface"), DLT_STRING(bus.Name.toAscii()));
-		}
-	emit signal_system_ready();
+//	foreach (Bus bus, Busses)
+//		{
+//			bus.sendInterface->startup_interface(m_receiver);
+//			DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Bushandler:Started Interface"), DLT_STRING(bus.Name.toAscii()));
+//		}
+//	emit signal_system_ready();
 }
 
 void Bushandler::registerReceiver(RoutingReceiver * receiver) {
 	m_receiver = receiver;
 }
 
-RoutingSendInterface* Bushandler::getInterfaceforBus(QString bus) {
-	foreach (Bus b, Busses)
-		{
-			if (b.Name.compare(bus) == 0) {
-				return b.sendInterface;
-			}
-		}
-	return NULL;
+RoutingSendInterface* Bushandler::getInterfaceforBus(std::string bus) {
+//	foreach (Bus b, Busses)
+//		{
+//			if (b.Name.compare(bus) == 0) {
+//				return b.sendInterface;
+//			}
+//		}
+//	return NULL;
 }
 
diff --git a/AudioManagerDaemon/Router.h b/AudioManagerDaemon/Router.h
index 683b75e..05d2d88 100644
--- a/AudioManagerDaemon/Router.h
+++ b/AudioManagerDaemon/Router.h
@@ -55,7 +55,7 @@ public:
 	 */
 	bool get_Route_from_Source_ID_to_Sink_ID(const bool onlyfree,
 			const source_t Source_ID, const sink_t Sink_ID,
-			QList<genRoute_t>* ReturnList);
+			std::list<genRoute_t>* ReturnList);
 
 private:
 	DataBaseHandler* m_dbHandler;
@@ -88,13 +88,13 @@ public:
 	 *
 	 * @param ChildItems buffer for the child items
 	 */
-	void returnChildItems(QList<RoutingTreeItem*> ChildItems);
+	void returnChildItems(std::list<RoutingTreeItem*> ChildItems);
 
 	/**returns the domain ID
 	 *
 	 * @return the domain ID
 	 */
-	domain_t returnDomainID(void);
+	domain_t returnDomainID();
 
 	/**returns the gateway ID
 	 *
@@ -109,7 +109,7 @@ public:
 	RoutingTreeItem* return_Parent();
 
 private:
-	QList<RoutingTreeItem*> childItems; //!< List of all child items
+	std::list<RoutingTreeItem*> childItems; //!< List of all child items
 	domain_t m_domainID; //!< the domain ID of the item
 	gateway_t m_gatewayID; //!< the gateway Id
 	RoutingTreeItem *parentItem; //!< pointer to the parent item
@@ -144,7 +144,7 @@ public:
 	 * @param route pointer to a list of gateway IDs that need to be connected
 	 * @return the length of the route.
 	 */
-	int getRoute(RoutingTreeItem* TargetItem, QList<gateway_t>* route);
+	int getRoute(RoutingTreeItem* TargetItem, std::list<gateway_t>* route);
 
 	/**returns the DomainId of the rootItem
 	 *
@@ -160,15 +160,15 @@ public:
 
 private:
 	RoutingTreeItem m_rootItem; //!< pointer to root item
-	QList<RoutingTreeItem*> m_allChildList; //!< list of all childs
+	std::list<RoutingTreeItem*> m_allChildList; //!< list of all childs
 };
 
 /**This class is responsible for loading the RoutingInterface Plugins
  * In order to let a plugin be loaded by the BusManager, just add it in main.cpp  like this
  * @code Q_IMPORT_PLUGIN(RoutingPlugin) @code
  */
-class Bushandler: public QObject {
-Q_OBJECT
+class Bushandler {
+
 public:
 	Bushandler() {
 	}
@@ -198,9 +198,8 @@ public:
 	 * @param bus the name of the bus
 	 * @return pointer to the interface
 	 */
-	RoutingSendInterface* getInterfaceforBus(QString bus);
+	RoutingSendInterface* getInterfaceforBus(std::string bus);
 
-signals:
 	/**This signal informs the plugins that the AudioManager is ready to register Domains Sinks and Sources
 	 *
 	 */
@@ -212,10 +211,10 @@ private:
 	 */
 	struct Bus {
 		RoutingSendInterface* sendInterface;
-		QString Name;
+		std::string Name;
 	};
 
-	QList<Bus> Busses; //!< list of all busses
+	std::list<Bus> Busses; //!< list of all busses
 	RoutingReceiver* m_receiver; //!< pointer to the routing receiver
 };
 
diff --git a/AudioManagerDaemon/RoutingReceive.cpp b/AudioManagerDaemon/RoutingReceive.cpp
index 6108495..447e3ec 100644
--- a/AudioManagerDaemon/RoutingReceive.cpp
+++ b/AudioManagerDaemon/RoutingReceive.cpp
@@ -29,90 +29,80 @@ void RoutingReceiver::register_Databasehandler(DataBaseHandler* handler_) {
 	handler = handler_;
 }
 
-int RoutingReceiver::registerDomain(char* name, char* busname, char* node,
-		bool earlymode) {
-	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Domain Registered: "), DLT_STRING(name));
-	return handler->insert_into_Domains_table(QString(name), QString(busname),
-			QString(node), earlymode);
+int RoutingReceiver::registerDomain(char* name, char* busname, char* node, bool earlymode) {
+	DLT_LOG(AudioManager, DLT_LOG_INFO, DLT_STRING("Domain Registered: "), DLT_STRING(name));
+	return handler->insert_into_Domains_table(std::string(name), std::string(busname), std::string(node), earlymode);
 }
 
 int RoutingReceiver::registerSource(char* name, char* audioclass, char* domain) {
-	int id_class = handler->get_Source_Class_ID_from_Name(QString(audioclass));
-	int id_domain = handler->get_Domain_ID_from_Name(QString(domain));
+	int id_class = handler->get_Source_Class_ID_from_Name(std::string(audioclass));
+	int id_domain = handler->get_Domain_ID_from_Name(std::string(domain));
 
 	if (id_class == 0) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Class unknown: "), DLT_STRING(audioclass));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Class unknown: "), DLT_STRING(audioclass));
 		return -1;
 	} else if (id_class == -1) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Database Error: "));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Database Error: "));
 		return -1;
 	}
 	if (id_domain == 0) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Domain unknown: "));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Domain unknown: "));
 		return -1;
 	} else if (id_class == -1) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Database Error: "));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Database Error: "));
 		return -1;
 	}
 
-	return handler->insert_into_Source_table(QString(name), id_class,
-			id_domain, false);
+	return handler->insert_into_Source_table(std::string(name), id_class, id_domain, false);
 }
 int RoutingReceiver::registerSink(char* name, char* sinkclass, char* domain) {
 	//TODO: Integrate Sink Classes
 	(void) sinkclass;
 	int id_sinkclass = 1;
-	int id_domain = handler->get_Domain_ID_from_Name(QString(domain));
+	int id_domain = handler->get_Domain_ID_from_Name(std::string(domain));
 
 	if (id_domain == 0) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Domain unknown: "));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Domain unknown: "));
 		return -1;
 	}
 
-	return handler->insert_into_Sink_table(QString(name), id_sinkclass,
-			id_domain, false);
+	return handler->insert_into_Sink_table(std::string(name), id_sinkclass, id_domain, false);
 }
-int RoutingReceiver::registerGateway(char* name, char* sink, char* source,
-		char *domainSource, char* domainSink, char* controlDomain) {
+int RoutingReceiver::registerGateway(char* name, char* sink, char* source, char *domainSource, char* domainSink, char* controlDomain) {
 
-	int domainSourceID =
-			handler->get_Domain_ID_from_Name(QString(domainSource));
+	int domainSourceID = handler->get_Domain_ID_from_Name(std::string(domainSource));
 	if (domainSourceID == 0) {
-		domainSourceID = handler->peek_Domain_ID(QString(domainSource));
+		domainSourceID = handler->peek_Domain_ID(std::string(domainSource));
 	}
-	int domainSinkID = handler->get_Domain_ID_from_Name(QString(domainSink));
+	int domainSinkID = handler->get_Domain_ID_from_Name(std::string(domainSink));
 	if (domainSinkID == 0) {
-		domainSinkID = handler->peek_Domain_ID(QString(domainSink));
+		domainSinkID = handler->peek_Domain_ID(std::string(domainSink));
 	}
-	int domainControlID = handler->get_Domain_ID_from_Name(
-			QString(controlDomain));
+	int domainControlID = handler->get_Domain_ID_from_Name(std::string(controlDomain));
 
 	if (domainSourceID == 0) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Domain Source unknown: "));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Domain Source unknown: "));
 		return -1;
 	}
 	if (domainSink == 0) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Domain Sink unknown: "));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Domain Sink unknown: "));
 		return -1;
 	}
 	if (domainControlID == 0) {
-		DLT_LOG(AudioManager,DLT_LOG_ERROR, DLT_STRING("Domain Control unknown: "));
+		DLT_LOG(AudioManager, DLT_LOG_ERROR, DLT_STRING("Domain Control unknown: "));
 		return -1;
 	}
 
-	int sourceId = handler->insert_into_Source_table(QString(source), 0,
-			domainSourceID, true);
-	int sinkID = handler->insert_into_Sink_table(QString(sink), 0,
-			domainSinkID, true);
-	return handler->insert_into_Gatway_table(QString(name), sinkID, sourceId,
-			domainSourceID, domainSinkID, domainControlID);
+	int sourceId = handler->insert_into_Source_table(std::string(source), 0, domainSourceID, true);
+	int sinkID = handler->insert_into_Sink_table(std::string(sink), 0, domainSinkID, true);
+	return handler->insert_into_Gatway_table(std::string(name), sinkID, sourceId, domainSourceID, domainSinkID, domainControlID);
 
 }
 
 int RoutingReceiver::peekDomain(char* name) {
-	return handler->peek_Domain_ID(QString(name));
+	return handler->peek_Domain_ID(std::string(name));
 }
 
 void RoutingReceiver::ackConnect(genHandle_t handle, genError_t error) {
-	emit signal_ackConnect(handle, error);
+	//emit signal_ackConnect(handle, error);
 }
diff --git a/AudioManagerDaemon/RoutingReceive.h b/AudioManagerDaemon/RoutingReceive.h
index 81e9213..fdb6edc 100644
--- a/AudioManagerDaemon/RoutingReceive.h
+++ b/AudioManagerDaemon/RoutingReceive.h
@@ -33,8 +33,8 @@ class DataBaseHandler;
 /**implementation of the interface
  *
  */
-class RoutingReceiver: public QObject, public RoutingReceiveInterface {
-Q_OBJECT
+class RoutingReceiver: public RoutingReceiveInterface {
+
 public:
 	void register_Databasehandler(DataBaseHandler* handler_); //is used to register the Database handler
 
@@ -46,7 +46,6 @@ public:
 	int peekDomain(char* name);
 	void ackConnect(genHandle_t handle, genError_t error);
 
-signals:
 	void signal_ackConnect(genHandle_t handle, genError_t error);
 
 private:
diff --git a/AudioManagerDaemon/audioManagerIncludes.h b/AudioManagerDaemon/audioManagerIncludes.h
index f5aeeef..483ea2c 100644
--- a/AudioManagerDaemon/audioManagerIncludes.h
+++ b/AudioManagerDaemon/audioManagerIncludes.h
@@ -33,10 +33,9 @@
 #include "DataBaseHandler.h"
 #include "RoutingReceive.h"
 #include "Router.h"
-#include "DBusTypes.h"
 #include "HookEngine.h"
 #include "AudioManagerCore.h"
-#include "DBusCommandInterface.h"
+//#include "DBusCommandInterface.h"
 
 DLT_IMPORT_CONTEXT(AudioManager)
 
diff --git a/AudioManagerDaemon/dataTypes.h b/AudioManagerDaemon/dataTypes.h
index 604e7aa..c3c451c 100644
--- a/AudioManagerDaemon/dataTypes.h
+++ b/AudioManagerDaemon/dataTypes.h
@@ -13,7 +13,8 @@
 #ifndef DATATYPES_H_
 #define DATATYPES_H_
 
-#include <qlist.h>
+#include <list>
+#include <string>
 
 typedef int source_t;
 typedef int sink_t;
@@ -67,7 +68,7 @@ public:
 	int len;
 	source_t Source_ID;
 	sink_t Sink_ID;
-	QList<genRoutingElement_t> route;
+	std::list<genRoutingElement_t> route;
 };
 
 /**This class describes the interrupt Type.
@@ -85,7 +86,25 @@ public:
 	source_t sourceID;
 	sink_t SinkID;
 	bool mixed;
-	QList<source_t> listInterruptedSources;
+	std::list<source_t> listInterruptedSources;
+};
+
+class SinkType {
+public:
+	std::string name;
+	sink_t ID;
+};
+
+class SourceType {
+public:
+	std::string name;
+	source_t ID;
+};
+
+class ConnectionType {
+public:
+	source_t Source_ID;
+	sink_t Sink_ID;
 };
 
 #endif /* DATATYPES_H_ */
diff --git a/AudioManagerDaemon/main.cpp b/AudioManagerDaemon/main.cpp
index 703c434..43efaea 100644
--- a/AudioManagerDaemon/main.cpp
+++ b/AudioManagerDaemon/main.cpp
@@ -23,29 +23,25 @@
  *
  */
 
-#include <QtCore/qcoreapplication.h>
 #include "audioManagerIncludes.h"
 /**
  * \todo: write some documentation about Plugin mechanism
  *
  */
 //put here all plugins you want to use with the Routing Interface
-Q_IMPORT_PLUGIN(RoutingPlugin)
-Q_IMPORT_PLUGIN(RoutingJackPlugin)
+//Q_IMPORT_PLUGIN(RoutingPlugin)
+//Q_IMPORT_PLUGIN(RoutingJackPlugin)
 //put here all plugins that you want to use with the hooks. No more modification needed (besides adoption of the CMakeList) !
-Q_IMPORT_PLUGIN(TestPlugin)
+//Q_IMPORT_PLUGIN(TestPlugin)
 DLT_DECLARE_CONTEXT(AudioManager);
 
 int main(int argc, char *argv[]) {
-	QCoreApplication a(argc, argv);
 
 	//of course, we need some logging :-)
 	DLT_REGISTER_APP("AudioManagerDeamon","AudioManagerDeamon");
 	DLT_REGISTER_CONTEXT(AudioManager,"Main","Main Context");
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("The AudioManager is started "));
 
-	//add library path
-	a.addLibraryPath("../plugins");
 
 	//Here are our Main Classes
 	DataBaseHandler dhandler;
@@ -54,7 +50,7 @@ int main(int argc, char *argv[]) {
 	Router router;
 	HookHandler hookhandler;
 	AudioManagerCore core;
-	DBusCommandInterface commandIface;
+	//DBusCommandInterface commandIface;
 
 	//meet and greet: register all the classes @ each other
 	hookhandler.registerAudioManagerCore(&core);
@@ -63,11 +59,11 @@ int main(int argc, char *argv[]) {
 	core.registerRouter(&router);
 	core.registerHookEngine(&hookhandler);
 	core.registerReceiver(&breceiver);
-	core.registerCommandInterface(&commandIface);
+	//core.registerCommandInterface(&commandIface);
 	router.registerDatabasehandler(&dhandler);
 	//commandIface.registerDatabasehandler(&dhandler);
 
-	commandIface.registerAudioManagerCore(&core);
+	//commandIface.registerAudioManagerCore(&core);
 	breceiver.register_Databasehandler(&dhandler);
 	bushandler.registerReceiver(&breceiver);
 
@@ -91,9 +87,11 @@ int main(int argc, char *argv[]) {
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("load bus plugins"));
 	bushandler.load_Bus_plugins();
 	bushandler.StartupInterfaces();
-	commandIface.startupInterface();
+	//commandIface.startupInterface();
 	DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("Init phase is over, everything up and running"));
 
-	return a.exec();
+	while (1) {
+		sleep(2000);
+	}
 }
 
diff --git a/AudioManagerDaemon/routinginterface.h b/AudioManagerDaemon/routinginterface.h
index d8a063e..d4323c1 100644
--- a/AudioManagerDaemon/routinginterface.h
+++ b/AudioManagerDaemon/routinginterface.h
@@ -26,7 +26,6 @@
 #ifndef ROUTINGINTERFACE_H_
 #define ROUTINGINTERFACE_H_
 
-#include <QObject>
 #include "dataTypes.h"
 
 class RoutingSendInterface;
@@ -91,7 +90,7 @@ public:
 /** Routing Send sendInterface
  *  This class implements everything from Audiomanager -> RoutingAdapter
  */
-class RoutingSendInterface: public QObject {
+class RoutingSendInterface {
 public:
 	/** destructor*/
 	virtual ~RoutingSendInterface() {
@@ -171,7 +170,6 @@ public:
 	virtual bool unmuteSink(sink_t sinkID /**< SinkID to be unmuted */
 	)=0;
 
-public slots:
 	/** signal that tells the plugin that the system is ready. Is used to trigger a registration of Domains, etc..*/
 	void slot_system_ready();
 };
@@ -191,7 +189,5 @@ public:
 	virtual RoutingSendInterface* returnInstance()=0;
 };
 
-Q_DECLARE_INTERFACE(RoutingInterfaceFactory,"RoutingInterfaceFactory/1.0")
-;
 
 #endif /* ROUTINGINTERFACE_H_ */