mail2 should display (most) mails now with these workarounds. imap handling

is still buggy by design though.

7 files changed, 194 insertions, 89 deletions

diff --git a/noncore/unsupported/mail2/libmail/configfile.cpp b/noncore/unsupported/mail2/libmail/configfile.cpp
index a5c2b49..082b330 100644
--- a/noncore/unsupported/mail2/libmail/configfile.cpp
+++ b/noncore/unsupported/mail2/libmail/configfile.cpp
@@ -1,112 +1,112 @@
 #include <qdir.h>
 
 #include <qpe/config.h>
 
 #include <stdlib.h>
 
 #include "configfile.h"
 
 ConfigFile::ConfigFile() : QObject()
 {
 	checkDirectory();
 
 	QDir dir((QString) getenv("HOME") + "/Applications/mail/accounts");
 	QStringList entries = dir.entryList("account-*"); 
 
 	QStringList::Iterator it;
 	for (it = entries.begin(); it != entries.end(); it++) {
 		Account account;
 
 		Config *config = new Config((QString) getenv("HOME") + "/Applications/mail/accounts/" + *it, Config::File);
 		config->setGroup("Account");
 		account.setAccountName((*it).replace(0, 8, ""));
 		account.setRealName(config->readEntry("RealName"));
 		account.setEmail(config->readEntry("Email"));
 		account.setOrg(config->readEntry("Organization"));
 		account.setImapServer(config->readEntry("ImapServer"));
 		account.setImapPort(config->readEntry("ImapPort"));
 		account.setSmtpServer(config->readEntry("SmtpServer"));
 		account.setSmtpPort(config->readEntry("SmtpPort"));
 		account.setUser(config->readEntry("User"));
 		account.setPass(rot13(config->readEntryCrypt("Pass")));
 		account.setSmtpSsl(config->readBoolEntry("SmtpSsl"));
 		account.setSmtpSslPort(config->readEntry("SmtpSslPort"));
 		account.setImapSsl(config->readBoolEntry("ImapSsl"));
 		account.setImapSslPort(config->readEntry("ImapSslPort"));
 		account.setDefaultCc(config->readBoolEntry("DefaultCc"));
 		account.setDefaultBcc(config->readBoolEntry("DefaultBcc"));
 		account.setDefaultReplyTo(config->readBoolEntry("DefaultReplyTo"));
 		account.setCc(config->readEntry("Cc"));
 		account.setBcc(config->readEntry("Bcc"));
 		account.setReplyTo(config->readEntry("ReplyTo"));
 		account.setSignature(config->readEntry("Signature").replace(QRegExp("<br>"), "\n"));
 
 		_accounts.append(account);
 	}
 }
 
 QValueList<Account> ConfigFile::getAccounts()
 {
 	ConfigFile *configFile = new ConfigFile();
 	return configFile->_accounts;
 }
 
 void ConfigFile::updateAccount(Account account)
 {
 	checkDirectory();
 	Config *config = new Config((QString) getenv("HOME") + "/Applications/mail/accounts/account-" + account.accountName(), Config::File);
 
 	config->setGroup("Account");
 	config->writeEntry("RealName", account.realName());
 	config->writeEntry("Email", account.email());
 	config->writeEntry("Organization", account.org());
 	config->writeEntry("ImapServer", account.imapServer());
 	config->writeEntry("ImapPort", account.imapPort());
 	config->writeEntry("SmtpServer", account.smtpServer());
 	config->writeEntry("SmtpPort", account.smtpPort());
 	config->writeEntry("User", account.user());
 	config->writeEntryCrypt("Pass", rot13(account.pass()));
 	config->writeEntry("SmtpSsl", account.smtpSsl());
 	config->writeEntry("SmtpSslPort", account.smtpSslPort());
 	config->writeEntry("ImapSsl", account.imapSsl());
 	config->writeEntry("ImapSslPort", account.imapSslPort());
 	config->writeEntry("DefaultCc", account.defaultCc());
 	config->writeEntry("DefaultBcc", account.defaultBcc());
 	config->writeEntry("DefaultReplyTo", account.defaultReplyTo());
 	config->writeEntry("Cc", account.cc());
 	config->writeEntry("Bcc", account.bcc());
 	config->writeEntry("ReplyTo", account.replyTo());
 	config->writeEntry("Signature", account.signature().replace(QRegExp("\\n"), "<br>"));
 
 	config->write();
 }
 
 void ConfigFile::deleteAccount(Account account)
 {
 	QFile f((QString) getenv("HOME") + "/Applications/mail/accounts/account-" + account.accountName());
 	f.remove();
 }
 
 void ConfigFile::checkDirectory()
 {
 	if (!QDir((QString) getenv("HOME") + "/Applications/mail/accounts").exists()) {
 		system("mkdir -p $HOME/Applications/mail/accounts");
 		qWarning("mail: $HOME/Applications/mail/accounts created");
 	}
 }
 
 QString ConfigFile::rot13(const QString &input)
 {
 	QString i = input;
 	int l = i.length();
 	while(l--) {
 		if (i[l] >= QChar('A') && i[l] <= QChar('M') ||
 		    i[l] >= QChar('a') && i[l] <= QChar('m'))
-			i[l] = (char)((int)QChar(l[i])+13);
+			i[l] = QChar(i[l].unicode()+13);
 		else if (i[l] >= QChar('N') && i[l] <= QChar('Z') ||
 			 i[l] >= QChar('n') && i[l] <= QChar('z'))
-			i[l] = (char)((int)QChar(l[i])-13);
+			i[l] = QChar(i[l].unicode()-13);
 	}
 	return i;
 }
 
diff --git a/noncore/unsupported/mail2/libmail/imapbase.cpp b/noncore/unsupported/mail2/libmail/imapbase.cpp
index 9a2ba47..4753f43 100644
--- a/noncore/unsupported/mail2/libmail/imapbase.cpp
+++ b/noncore/unsupported/mail2/libmail/imapbase.cpp
@@ -1,110 +1,132 @@
 #include <qsocket.h>
 #include <qtimer.h>
 
 #include "imapbase.h"
 
 IMAPBase::IMAPBase(const Account &account)
 	: QObject(), _account(account)
 {
 	_connected = false;
 	_writingAllowed = false;
 	_socket = new QSocket(this);
 
 	connect(_socket, SIGNAL(readyRead()), SLOT(slotDataAvailiable()));
 	connect(_socket, SIGNAL(hostFound()), SLOT(slotHostFound()));
 	connect(_socket, SIGNAL(connected()), SLOT(slotConnected()));
 	connect(_socket, SIGNAL(connectionClosed()), SLOT(slotDisconnected()));
 	connect(_socket, SIGNAL(error(int)), SLOT(slotError(int)));
 
 	QTimer *commandTimer = new QTimer(this);
 	commandTimer->start(200);
 	connect(commandTimer, SIGNAL(timeout()), SLOT(writeCommands()));
 }
 
 void IMAPBase::sendCommand(const QString &command)
 {
 	if (!_connected) makeConnect();
 	_commandQueue.append(command);
 }
 
 void IMAPBase::disconnect()
 {
 	_connected = false;
 	delete _socket;
 	emit disconnected();
 }
 
 void IMAPBase::makeConnect()
 {
 	emit lookingUpHost();
 	if (_socket == NULL) _socket = new QSocket(this);
 
 	Q_UINT16 port = _account.imapPort().toUInt();
 	_socket->connectToHost(_account.imapServer(), port);
 }
 
 void IMAPBase::writeCommands()
 {
 	if (!_connected) return;
 	if (_commandQueue.isEmpty()) return;
 	if (!_writingAllowed) return;
 
 	QStringList::Iterator it;
 	for (it = _commandQueue.begin(); it != _commandQueue.end(); it++) {
 		if (!(*it).isEmpty() && _writingAllowed) {
 #ifndef QT_NO_DEBUG
-			qDebug("IMAP > " + (*it).stripWhiteSpace());
+			qDebug("IMAP > " + (*it).stripWhiteSpace().local8Bit ());
 #endif
 			_socket->writeBlock((*it).latin1(), (*it).length());
 			_writingAllowed = false;
+			if (( *it ). find ( QRegExp ( "^[a-z][0-9]+ " )) == 0 )
+				_lasttag = (*it).left(2);
+
+			connect(_socket, SIGNAL(readyRead()), SLOT(slotDataAvailiable()));
 			_commandQueue.remove(it);
 			break;
 		}
 	}
 }
 
 void IMAPBase::slotError(int err)
 {
 	if (err == QSocket::ErrConnectionRefused) {
 		emit error(IMAPErrConnectionRefused);
 	} else if (err == QSocket::ErrHostNotFound) {
 		emit error(IMAPErrHostNotFound);
 	} else if (err == QSocket::ErrSocketRead) {
 		emit error(IMAPErrSocketRead);
 	} else {
 		emit error(IMAPErrUnknownError);
 	}
 }
 
 void IMAPBase::slotHostFound()
 {
 	emit hostFound();
 }
 
 void IMAPBase::slotConnected()
 {
 	_connected = true;
 	emit connected();
 }
 
 void IMAPBase::slotDisconnected()
 {
 	_connected = false;
 	emit disconnected();
 }
 
+#include <unistd.h>
+
 void IMAPBase::slotDataAvailiable()
 {
+	static bool firstline = true;
+
 	while (_socket->canReadLine()) {
-		_data += _socket->readLine();
-		if (_socket->atEnd()) {
-#ifndef QT_NO_DEBUG
-			qDebug("IMAP < " + _data.stripWhiteSpace());
-#endif
+		QString tmp = _socket-> readLine ( );
+	
+		_data += tmp;
+		qDebug ( "New Line [%d]: '%s'\n", _connected ? 1 : 0, tmp.latin1( ));
+		
+		if ( firstline || tmp. left(2) == _lasttag ) {
+			firstline = false;
+					
+//		if ( _socket-> atEnd ( )) 
+			qDebug ( "at end -> emitting\n" );
+		
+			QObject::disconnect(_socket, SIGNAL(readyRead()), this, SLOT(slotDataAvailiable()));
 			emit dataReceived(_data);
+			_data = QString::null;
 			_writingAllowed = true;
-			_data = QString(0);
 		}
 	}
 }
 
+void IMAPBase::tryRead ( QString &data )
+{
+	qDebug ( "Trying to read...\n" );
+
+	while ( _socket-> canReadLine ( ))
+		data += _socket-> readLine ( );
+}
diff --git a/noncore/unsupported/mail2/libmail/imapbase.h b/noncore/unsupported/mail2/libmail/imapbase.h
index e4a0b97..7697ffe 100644
--- a/noncore/unsupported/mail2/libmail/imapbase.h
+++ b/noncore/unsupported/mail2/libmail/imapbase.h
@@ -1,52 +1,53 @@
 #ifndef IMAPBASE_H
 #define IMAPBASE_H
 
 #include <qobject.h>
 
 #include "configfile.h"
 
 class QSocket;
 
 class IMAPBase : public QObject
 {
 	Q_OBJECT
 
 public:
 	IMAPBase(const Account &account);
 
 	enum Error { IMAPErrConnectionRefused, IMAPErrHostNotFound, 
 		     IMAPErrSocketRead, IMAPErrUnknownError,
 		     IMAPErrLoginFailed };
 
 	void sendCommand(const QString &command);
 	void disconnect();
 
 signals:
 	void dataReceived(const QString &data);
 	void lookingUpHost();
 	void hostFound();
 	void connected();
 	void disconnected();
 	void error(int err);
 
 protected:
 	void makeConnect();
 
 protected slots:
 	void writeCommands();
 	void slotError(int error);
 	void slotHostFound();
 	void slotConnected();
 	void slotDisconnected();
 	void slotDataAvailiable();
+	void tryRead ( QString & );
 
 private:
 	Account _account;
 	QString _data;
 	QSocket *_socket;
 	QStringList _commandQueue;
 	bool _connected, _writingAllowed;
-
+	QString _lasttag;
 };
 
 #endif
diff --git a/noncore/unsupported/mail2/libmail/imaphandler.cpp b/noncore/unsupported/mail2/libmail/imaphandler.cpp
index 7493240..dc97b28 100644
--- a/noncore/unsupported/mail2/libmail/imaphandler.cpp
+++ b/noncore/unsupported/mail2/libmail/imaphandler.cpp
@@ -1,343 +1,346 @@
 #include "imapresponse.h"
 #include "imaphandler.h"
 #include "imapbase.h"
 
 IMAPHandler::IMAPHandler(const Account &account)
 	: QObject(), _account(account)
 {
 	_ready = false;
 	_loggingin = false;
 	_loggedin = false;
 	_tag = 0;
 	_ibase = new IMAPBase(account);
 
 	connect(_ibase, SIGNAL(dataReceived(const QString &)), SLOT(slotDataReceived(const QString &)));
 	connect(_ibase, SIGNAL(lookingUpHost()), SLOT(slotLookingUpHost()));
 	connect(_ibase, SIGNAL(hostFound()), SLOT(slotHostFound()));
 	connect(_ibase, SIGNAL(connected()), SLOT(slotConnected()));
 	connect(_ibase, SIGNAL(disconnected()), SLOT(slotDisconnected()));
 	connect(_ibase, SIGNAL(error(int)), SLOT(slotError(int)));
 }
 
 void IMAPHandler::doLogin()
 {
 	if (_loggedin) return;
 	if (_loggingin) return;
 
 	_loggingin = true;
 	iLogin(_account.user(), _account.pass());
 }
 
 QString IMAPHandler::iCapability()
 {
 	_ibase->sendCommand(QString("%1 CAPABILITY\r\n")
 		.arg(tag()));
 	return tag(false);
 }
 
 QString IMAPHandler::iNoop()
 {
 	_ibase->sendCommand(QString("%1 NOOP\r\n")
 		.arg(tag()));
 	return tag(false);
 }
 
 QString IMAPHandler::iLogout()
 {
 	_ibase->sendCommand(QString("%1 LOGOUT\r\n")
 		.arg(tag()));
 	return tag(false);
 }
 
 QString IMAPHandler::iAuthenticate(const QString &mechanism)
 {
 	_ibase->sendCommand(QString("%1 AUTHENTICATE \"%2\"\r\n")
 		.arg(tag())
 		.arg(escape(mechanism)));
 	return tag(false);
 }
 
 QString IMAPHandler::iLogin(const QString &user, const QString &pass)
 {
 	_ibase->sendCommand(QString("%1 LOGIN \"%2\" \"%3\"\r\n")
 		.arg(tag())
 		.arg(escape(user))
 		.arg(escape(pass)));
 	return tag(false);
 }
 
 QString IMAPHandler::iSelect(const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 SELECT \"%2\"\r\n")
 		.arg(tag())
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iExamine(const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 EXAMINE \"%2\"\r\n")
 		.arg(tag())
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iCreate(const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 CREATE \"%2\"\r\n")
 		.arg(tag())
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iDelete(const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 DELETE \"%2\"\r\n")
 		.arg(tag())
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iRename(const QString &mailbox, const QString &newMailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 RENAME \"%2\" \"%3\"\r\n")
 		.arg(tag())
 		.arg(escape(mailbox))
 		.arg(escape(newMailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iSubscribe(const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 SUBSCRIBE \"%2\"\r\n")
 		.arg(tag())
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iUnsubscribe(const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 UNSUBSCRIBE \"%2\"\r\n")
 		.arg(tag())
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iList(const QString &reference, const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 LIST \"%2\" \"%3\"\r\n")
 		.arg(tag())
 		.arg(escape(reference))
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iLsub(const QString &reference, const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 LSUB \"%2\" \"%3\"\r\n")
 		.arg(tag())
 		.arg(escape(reference))
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iStatus(const QString &mailbox, const QString &items)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 STATUS \"%2\" (%3)\r\n")
 		.arg(tag())
 		.arg(escape(mailbox))
 		.arg(escape(items)));
 	return tag(false);
 }
 
 QString IMAPHandler::iAppend(const QString &mailbox, const QString &literal, const QString &flags, const QString &datetime)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 APPEND \"%2\" (%3) \"%4\" {%5}\r\n%6\r\n")
 		.arg(tag())
 		.arg(escape(mailbox))
 		.arg(flags)
 		.arg(escape(datetime))
 		.arg(literal.length())
 		.arg(literal));
 	return tag(false);
 }
 
 QString IMAPHandler::iCheck()
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 CHECK\r\n")
 		.arg(tag()));
 	return tag(false);
 }
 
 QString IMAPHandler::iClose()
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 CLOSE\r\n")
 		.arg(tag()));
 	return tag(false);
 }
 
 QString IMAPHandler::iExpunge()
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 EXPUNGE\r\n")
 		.arg(tag()));
 	return tag(false);
 }
 
 QString IMAPHandler::iSearch(const QString &search, const QString &charset)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 SEARCH %2 %3\r\n")
 		.arg(tag())
 		.arg(charset.isEmpty() ? QString(0) : escape(charset))
 		.arg(search));
 	return tag(false);
 }
 
 QString IMAPHandler::iFetch(const QString &message, const QString &items)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 FETCH %2 (%3)\r\n")
 		.arg(tag())
 		.arg(message)
 		.arg(items));
 	return tag(false);
 }
 
 QString IMAPHandler::iStore(const QString &message, const QString &items)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 STORE %2 %3\r\n")
 		.arg(tag())
 		.arg(message)
 		.arg(items));
 	return tag(false);
 }
 
 QString IMAPHandler::iCopy(const QString &message, const QString &mailbox)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 COPY %2 \"%3\"\r\n")
 		.arg(tag())
 		.arg(message)
 		.arg(escape(mailbox)));
 	return tag(false);
 }
 
 QString IMAPHandler::iUid(const QString &command, const QString &arguments)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 UID %2 %3\r\n")
 		.arg(tag())
 		.arg(command)
 		.arg(arguments));
 	return tag(false);
 }
 
 QString IMAPHandler::iX(const QString &commandAtom, const QString &arguments)
 {
 	doLogin();
 
 	_ibase->sendCommand(QString("%1 X%2 %3\r\n")
 		.arg(tag())
 		.arg(commandAtom)
 		.arg(arguments));
 	return tag(false);
 }
 
 QString IMAPHandler::escape(const QString &in)
 {
 	QString in_ = in;
 	return in_.replace(QRegExp("\""), "\\\"");
 }
 
 QString IMAPHandler::tag(bool count)
 {
 	return QString("a%1").arg(count ? _tag++ : _tag);
 }
 
 void IMAPHandler::slotDataReceived(const QString &data)
 {
 	if (!_ready) {
 		// The first data is always the greeting string.
 		// We can ignore it.
 		_ready = true;
 		return;
 	}
 
 
-	IMAPResponseParser parser(data);
+	IMAPResponseParser parser;
+//	connect ( &parser, SIGNAL( needMoreData ( QString & )), _ibase, SLOT( tryRead ( QString & )));
+	parser. parse ( data );
 	IMAPResponse response = parser.response();
+//	disconnect ( &parser, SIGNAL( needMoreData ( QString & )), _ibase, SLOT( tryRead ( QString & )));
 	response.setImapHandler(this);
 
-	if (!_loggingin) emit gotResponse(response);
+	if (!_loggingin) { qDebug("Emitting gotResponse!\n" ); emit gotResponse(response); }
 	else {
 		if (response.statusResponse().status() == IMAPResponseEnums::OK) {
 			_loggingin = false;
 			_loggedin = true;
 			qWarning("OK. Logged in. Leaving loggingin state.");
 		} else {
 			_loggingin = false;
 			emit IMAPError(IMAPBase::IMAPErrLoginFailed);
 		}
 	}
 }
 
 void IMAPHandler::slotLookingUpHost()
 {
 	emit IMAPLookingUpHost();
 }
 
 void IMAPHandler::slotHostFound()
 {
 	emit IMAPHostFound();
 }
 
 void IMAPHandler::slotConnected()
 {
 	emit IMAPConnected();
 }
 
 void IMAPHandler::slotDisconnected()
 {
 	_loggedin = false;
 	emit IMAPDisconnected();
 }
 
 void IMAPHandler::slotError(int err)
 {
 	emit IMAPError(err);
 }
 
diff --git a/noncore/unsupported/mail2/libmail/imapresponse.cpp b/noncore/unsupported/mail2/libmail/imapresponse.cpp
index 06dca33..ce5b18b 100644
--- a/noncore/unsupported/mail2/libmail/imapresponse.cpp
+++ b/noncore/unsupported/mail2/libmail/imapresponse.cpp
@@ -1,448 +1,526 @@
 #include "imapresponse.h"
 
-static QString _previousData;
-static unsigned int _neededData;
 
-IMAPResponseParser::IMAPResponseParser(const QString &data)
+IMAPResponseParser::IMAPResponseParser()
+{
+}
+
+void IMAPResponseParser::parse ( const QString &_data )
 {	
-	QString _data = data, more;
-	_data.replace((QString)"\r\n", "\n");
-
-	QStringList lines = QStringList::split('\n', _data);
-	QStringList::Iterator it;
-	for (it = lines.begin(); it != lines.end(); it++) {
-		QString tag, lineData; 
-
-		if (!_previousData.isNull()) {
-			qDebug(QString("IMAPResponseParser: got additional data. (%1/%2)").arg(_previousData.length()).arg(_neededData));
-			_previousData += *it + "\n";
-			if (_previousData.length() >= _neededData) {
-				_previousData += ")";
-				qDebug("IMAPResponseParser: got ALL additional data.");
-				qDebug("Data is: " + _previousData);
-				parseResponse(_previousData);
-				_previousData = QString(0);
-				_neededData = 0;
-			}
-		} else {
-			splitTagData(*it, tag, lineData);
-			if (tag == "*") {
-				int pos;
-				if ((pos = data.find(QRegExp("\\{\\d*\\}"))) != -1) {
-					qDebug("IMAPResponseParser: waiting for additional data...");
-					_previousData = lineData + "\n";
-
-					QString tmp = data.right(data.length() - pos - 1).stripWhiteSpace();
-					tmp.truncate(tmp.length() - 1);
-
-					_neededData = tmp.toUInt();
-					if (_previousData.length() >= _neededData) {
-						qDebug("IMAPResponseParser: got ALL additional data. (1st)");
-						parseResponse(_previousData);
-						_previousData = QString(0);
-						_neededData = 0;
-					} else {
+	QString data = _data;
+
+	int pos = 0;
+	int len = data. length ( );
+	
+	
+	while ( pos < len ) {
+		pos = data. find ( QRegExp ( "[^\\s]" ), pos );
+		
+		if (( pos < 0 ) ||  ( pos >= len ))
+			break;
+	
+		switch ( data [pos]. latin1 ( )) {
+			case '*': {
+				qDebug ( "* ASTERIX\n" );
+			
+				int eol = data. find ( '\n', pos );
+				int bracket = data. findRev ( '{', eol );
+				int rest = data. find ( QRegExp ( "[^\\s]" ), pos + 1 );
+				
+				qDebug ( "pos=%d, rest=%d, bracket=%d, eol=%d\n", pos, rest, bracket, eol );
+				
+				if ( bracket > pos ) {
+					uint needdata = data. mid ( bracket + 1, data. find ( '}', bracket + 1 ) - bracket - 1 ). toUInt ( );
+					
+					if ( needdata ) {
+						qDebug ( "nd=%d - hd=%d\n", needdata, ( len - eol - 1 ));
+					
+						while ( needdata > ( len - eol - 1 )) {
+							qDebug ( "emitting need more...\n" );
+							emit needMoreData ( data );
+							len = data. length ( );
+						}
+						qDebug ( "Got all data...\n" );
+					
+						QString tmp = data. mid ( rest, eol - rest + 1 + needdata );
+						
+						int tail = 0;	
+						
+						while ( data [eol - rest + 1 + needdata + tail] != ')' )
+							tail++;
+						tmp. append ( data. mid ( eol - rest + 1 + needdata, tail + 1 ));
+							
+					
+						qDebug ( "Complete parse = |%s|\n", tmp.latin1());
+					
+						parseResponse ( tmp );
+						
+						pos = rest + needdata + tail + 1;
 						break;
-					}
-				} else {
-					parseResponse(lineData);
+					}									
 				}
-			} else if (tag == "+") {
-				emit needMoreData(_data);
-			} else {
-				_iresponse.setTag(tag);
-				parseResponse(_data, true);
+				
+				parseResponse ( data. mid ( rest, eol - rest + 1 ). stripWhiteSpace ( ));				
+				break;
+			}          
+			case '+': {
+				qDebug ( "+ PLUS\n" );
+				
+				emit needMoreData ( data );
+				len = data. length ( );
+				break;
+			}			          
+			default : {
+				qDebug ( "OTHER: '%s...'\n", data. mid ( pos, 20 ). latin1 ( ));
+			
+				uint rest = data. find ( ' ', pos + 1 );
+				rest = data. find ( QRegExp ( "[^\\s]" ), rest + 1 );
+				_iresponse. setTag ( data. mid ( pos, rest - pos ). stripWhiteSpace ( ));
+				parseResponse ( data. mid ( rest, data. find ( '\n', rest )). stripWhiteSpace ( ), true );
+				break;
 			}
 		}
+
+		// skip to end-of-line
+		while (( pos < len ) && ( data [pos] != '\n' ))
+			pos++;
 	}
 }
 
+
 IMAPResponse IMAPResponseParser::response()
 {
 	return _iresponse;
 }
 
 void IMAPResponseParser::parseResponse(const QString &data, bool tagged)
 {
 	QString response, line;
 	int pos;
 	bool isNum = false;
+
+
+//	qDebug ( "\n\n#### PRD #### : #%s#\n\n", data.latin1());
+
 	if ((pos = data.find(' ')) != -1) {
 		response = data.left(pos).upper();
 		response.toInt(&isNum);
 		line = data.right(data.length() - pos - 1);
 	} else {
-		qWarning("IMAPResponseParser: parseResponse: No response found."); 
+		qWarning("IMAPResponseParser: parseResponse: No response found.");
 		return;
 	}
 
 	if (response == "OK" && tagged) {
 		IMAPResponseStatusResponse status(OK, line);
 		status.setResponseCode(getResponseCode(status.comment()));
 		_iresponse.setStatusResponse(status);
 	} else if (response == "OK" && !tagged) {
 		IMAPResponseOK ok(line, getResponseCode(line));
 		_iresponse.addOK(ok);
 	} else if (response == "NO" && tagged) {
 		IMAPResponseStatusResponse status(NO, line);
 		status.setResponseCode(getResponseCode(status.comment()));
 		_iresponse.setStatusResponse(status);
 	} else if (response == "NO" && !tagged) {
 		IMAPResponseNO no(line, getResponseCode(line));
 		_iresponse.addNO(no);
 	} else if (response == "BAD" && tagged) {
 		IMAPResponseStatusResponse status(BAD, line);
 		status.setResponseCode(getResponseCode(status.comment()));
 		_iresponse.setStatusResponse(status);
 	} else if (response == "BAD" && !tagged) {
 		IMAPResponseBAD bad(line, getResponseCode(line));
 		_iresponse.addBAD(bad);
 	} else if (response == "PREAUTH" && tagged) {
 		IMAPResponseStatusResponse status(PREAUTH, line);
 		_iresponse.setStatusResponse(status);
 	} else if (response == "PREAUTH" && !tagged) {
 		qDebug("IMAPResponseParser: responseParser: got untagged PREAUTH response.");
 		// XXX
 	} else if (response == "BYE") {
 		IMAPResponseStatusResponse status(BYE, line);
 		if (!tagged) status.setExitedUnexpected(true);
 		_iresponse.setStatusResponse(status);
 	} else if (response == "CAPABILITY") {
 		IMAPResponseCAPABILITY capability(QStringList::split(' ', line));
 		_iresponse.addCAPABILITY(capability);
 	} else if (response == "LIST") {
 		QStringList list = splitData(line, true);
 
 		QStringList flags;
 		parseParenthesizedList(list[0], flags);
 
 		removeLimiters(list[1]);
 		removeLimiters(list[2]);		
 		IMAPResponseLIST rlist(parseFlagList(flags), list[1], list[2]);
 		_iresponse.addLIST(rlist);
 	} else if (response == "LSUB") {
 		QStringList list = splitData(line, true);
 
 		QStringList flags;
 		parseParenthesizedList(list[0], flags);
 
 		removeLimiters(list[1]);
 		removeLimiters(list[2]);
 		IMAPResponseLSUB lsub(parseFlagList(flags), list[1], list[2]);
 		_iresponse.addLSUB(lsub);
 	} else if (response == "STATUS") {
 		QStringList list = splitData(line, true);
 
 		removeLimiters(list[0]);
 		IMAPResponseSTATUS status(list[0]);
 
 		QStringList flags;
 		parseParenthesizedList(list[1], flags);
 		QStringList::Iterator it;
 		for (it = flags.begin(); it != flags.end(); it++) {
 			if (*it == "MESSAGES") status.setMessages(*(++it));
 			else if (*it == "RECENT") status.setRecent(*(++it));
 			else if (*it == "UIDNEXT") status.setUidnext(*(++it));
 			else if (*it == "UIDVALIDITY") status.setUidvalidity(*(++it));
 			else if (*it == "UNSEEN") status.setUnseen(*(++it));
-			else qWarning("IMAPResponseParser: parseResponse: Unknown status data: " + *(it++) + "|");
+			else qWarning((QString("IMAPResponseParser: parseResponse: Unknown status data: " )+ *(it++) + "|").latin1());
 		}
 		_iresponse.addSTATUS(status);
 	} else if (response == "SEARCH") {
 		IMAPResponseSEARCH search(QStringList::split(' ', line));
 		_iresponse.addSEARCH(search);
 	} else if (response == "FLAGS") {
 		QStringList list;
 		parseParenthesizedList(line, list);
 
 		IMAPResponseFLAGS flags(parseFlagList(list));
 		_iresponse.addFLAGS(flags);
 	} else if (isNum) {
 		QStringList list = QStringList::split(' ', line);
 		if (list[0] == "EXISTS") {
 			IMAPResponseEXISTS exists(response);
 			_iresponse.addEXISTS(exists);
 		} else if (list[0] == "RECENT") {
 			IMAPResponseRECENT recent(response);
 			_iresponse.addRECENT(recent);
 		} else if (list[0] == "EXPUNGE") {
 			IMAPResponseEXPUNGE expunge(response);
 			_iresponse.addEXPUNGE(expunge);
 		} else if (list[0] == "FETCH") {
 			IMAPResponseFETCH fetch;
 			QStringList::Iterator it;
 
+			qDebug ( "Got FETCH\n" );
+
 			QStringList fetchList = splitData(line, true);
 			QStringList list;
+			
+			qDebug ( "fl [0]=%s, fl [1]=%s, fl[2]=%s\n", fetchList[0].latin1(),fetchList[1].latin1(),fetchList[2].latin1());
+			
 			parseParenthesizedList(fetchList[1], list);
 
 			for (it = list.begin(); it != list.end(); it++) {
+				qDebug ( "Checking list[] == %s\n", (*it).latin1());
+			
 				if (*it == "BODY") {
 					qDebug("IMAPResponseParser: responseParser: got FETCH::BODY");
 					// XXX
-				} else if ((*it).find(QRegExp("BODY\\[\\d+\\]")) != -1) {
-					QString bodydata = *(++it);
+				} else if ((*it).find(QRegExp("^BODY\\[\\d+\\]")) != -1) {
 					qDebug("IMAPResponseParser: responseParser: got FETCH::BODY[x]");
 
-					QStringList blist;
-					parseParenthesizedList(bodydata, blist);
+					QString number = ( *it ). mid ( 5, ( *it ). length ( ) - 6 );
+					QString bodydata = *(++it);
+
+//					QStringList blist;
+//					parseParenthesizedList(bodydata, blist);
 
 					IMAPResponseBodyPart bodypart;
-					QString tmp;
-					for (unsigned int i = 2; i < blist.count(); i++) {
-						if (i != 2) tmp += " " + blist[i];
-						else tmp += blist[i];
-					}
-					bodypart.setData(tmp);
+//					QString tmp;
+//					for (unsigned int i = 2; i < blist.count(); i++) {
+//						if (i != 2) tmp += " " + blist[i];
+//						else tmp += blist[i];
+//					}
+					bodypart.setData(bodydata);
+
+//					QString tmp = list[0];
+//					tmp.replace(0, 5, "");
+//					tmp.truncate(blist[0].length() - 1);
+					bodypart.setPart(number);
 
-					tmp = list[0];
-					tmp.replace(0, 5, "");
-					tmp.truncate(blist[0].length() - 1);
-					bodypart.setPart(tmp);
+					qDebug("added bodypart [%s]: '%s'\n\n", number.latin1(), bodydata.latin1());
 
 					fetch.addBodyPart(bodypart);
 				} else if (*it == "BODYSTRUCTURE") {
 					qDebug("IMAPResponseParser: responseParser: got FETCH::BODYSTRUCTURE");
 /*
 					QString bsdata = *(++it);
 					QStringList bsList;
 					parseParenthesizedList(bsdata, bsList);
 
 					IMAPResponseBodystructure bodystructure;
 					QStringList attachml;
 
 					for (int i = 0; i < bsList.count() - 1; i++) {
 						parseParenthesizedList(bsList[0], attachml);
 
 						IMAPResponseBodypart bodypart;
 						bodypart.setMimeTypeMain(attachml[0] == "NIL" ? QString(0) : attachml[0]);
 						bodypart.setMimeTypeSub(attachml[1] == "NIL" ? QString(0) : attachml[1]);
 						bodypart.setAddData(attachml[2] == "NIL" ? QString(0) : attachml[2]);
 						// 3 (NIL)
 						// 4 (NIL)
 						bodypart.setEncoding(attachml[5] == "NIL" ? QString(0) : attachml[5]);
 						bodypart.setSize(attachml[6] == "NIL" ? QString(0) : attachml[6]);
 						bodypart.setLength(attachml[7] == "NIL" ? QString(0) : attachml[7]);
 						bodypart.setAttachInfo(attachml[8] == "NIL" ? QString(0) : attachml[8]);
 						// 9 (NIL)
 						// 10 (NIL)
 
 						bodystructure.addBodyPart(bodypart);
 					}
 */
 				} else if (*it == "ENVELOPE") {
 					QString envdata = *(++it);
 					QStringList envList;
 					parseParenthesizedList(envdata, envList);
 
 					IMAPResponseEnvelope envelope;
 					envelope.setMailDate(envList[0] == "NIL" ? QString(0) : removeLimiters(envList[0]));
 					envelope.setSubject(envList[1] == "NIL" ? QString(0) : removeLimiters(envList[1]));
 
 					QStringList froml, senderl, replytol, tol, ccl, bccl;
 					QStringList froma, sendera, replytoa, toa, cca, bcca;
 					parseParenthesizedList(envList[2], froml);
 					parseParenthesizedList(envList[3], senderl);
 					parseParenthesizedList(envList[4], replytol);
 					parseParenthesizedList(envList[5], tol);
 					parseParenthesizedList(envList[6], ccl);
 					parseParenthesizedList(envList[7], bccl);
 
 					QStringList::Iterator it;
 					for (it = froml.begin(); it != froml.end(); it++) {
 						parseParenthesizedList(*it, froma);
 						if (froml[0] != "NIL")
 							envelope.addFrom(IMAPResponseAddress(
 								removeLimiters(froma[0]),
 								removeLimiters(froma[1]),
 								removeLimiters(froma[2]),
 								removeLimiters(froma[3])));
 					}
 
 					for (it = senderl.begin(); it != senderl.end(); it++) {
 						parseParenthesizedList(*it, sendera);
 						if (senderl[0] != "NIL")
 							envelope.addSender(IMAPResponseAddress(
 								removeLimiters(sendera[0]), 
 								removeLimiters(sendera[1]), 
 								removeLimiters(sendera[2]), 
 								removeLimiters(sendera[3])));
 					}
 
 					for (it = replytol.begin(); it != replytol.end(); it++) {
 						parseParenthesizedList(*it, replytoa);				
 						if (replytol[0] != "NIL")
 							envelope.addReplyTo(IMAPResponseAddress(
 								removeLimiters(replytoa[0]),
 								removeLimiters(replytoa[1]),
 								removeLimiters(replytoa[2]), 
 								removeLimiters(replytoa[3])));
 					}
 
 					for (it = tol.begin(); it != tol.end(); it++) {
 						parseParenthesizedList(*it, toa);
 						if (tol[0] != "NIL") 
 							envelope.addTo(IMAPResponseAddress(
 								removeLimiters(toa[0]),
 								removeLimiters(toa[1]),
 								removeLimiters(toa[2]),
 								removeLimiters(toa[3])));
 					}
 
 					for (it = ccl.begin(); it != ccl.end(); it++) {
 						parseParenthesizedList(*it, cca);
 						if (ccl[0] != "NIL")
 							envelope.addCc(IMAPResponseAddress(
 								removeLimiters(cca[0]),
 								removeLimiters(cca[1]),
 								removeLimiters(cca[2]),
 								removeLimiters(cca[3])));
 					}
 
 					for (it = bccl.begin(); it != bccl.end(); it++) {
 						parseParenthesizedList(*it, bcca);
 						if (bccl[0] != "NIL")
 							envelope.addBcc(IMAPResponseAddress(
 								removeLimiters(bcca[0]),
 								removeLimiters(bcca[1]),
 								removeLimiters(bcca[2]),
 								removeLimiters(bcca[3])));
 					}
 
 					envelope.setInReplyTo(envList[7] == "NIL" ? QString(0) : removeLimiters(envList[7]));
 					envelope.setMessageId(envList[8] == "NIL" ? QString(0) : removeLimiters(envList[8]));
 				
 					fetch.setEnvelope(envelope);
 				} else if (*it == "FLAGS") {
 					QString flagdata = *(++it);
 					QStringList flags;
 					parseParenthesizedList(flagdata, flags);
 					fetch.setFlags(parseFlagList(flags));
 				} else if (*it == "INTERNALDATE") {
 					fetch.setInternalDate(removeLimiters(*(++it)));
 				} else if (*it == "RFC822" || *it == "BODY[]") {
 					qDebug("IMAPResponseParser: responseParser: got FETCH::RFC822");
 					// XXX
 				} else if (*it == "RFC822.HEADER" || *it == "BODY.PEEK[HEADER]") {
 					qDebug("IMAPResponseParser: responseParser: got FETCH::RFC822.HEADER");
 					// XXX
 				} else if (*it == "RFC822.SIZE") {
 					fetch.setRFC822Size(*(++it));
 				} else if (*it == "RFC822.TEXT" || *it == "BODY[TEXT]") {
 					qDebug("IMAPResponseParser: responseParser: got FETCH::RFC822.TEXT");
 					// XXX
 				} else if (*it == "UID") {
 					fetch.setUid(*(++it));
 				}	
 			}
 			_iresponse.addFETCH(fetch);
 		}
-	} else qWarning("IMAPResponseParser: parseResponse: Unknown response: " + response + "|");
+	} else qWarning((QString("IMAPResponseParser: parseResponse: Unknown response: ") + response + "|").latin1());
+	
 }
 
 QStringList IMAPResponseParser::splitData(const QString &data, bool withBrackets)
 {
 	int b = 0;
 	bool a = false, noappend = false, escaped = false;	 
 	QString temp;
 	QStringList list;
 
+	qDebug ( "sd: '%s'\n", data.latin1());
+
 	for (unsigned int i = 0; i <= data.length(); i++) {
 		if (withBrackets && data[i] == '(' && !a) b++;
 		else if (withBrackets && data[i] == ')' && !a) b--;
 
-		if (data[i] == '"' && !escaped) a = !a;
+		if (data[i] == '{' && !escaped && !a ) {
+			qDebug ( "sd: found a {\n" );
+		
+			int p = data. find ( '}', i + 1 );
+			int eol = data. find ( '\n', i + 1 );
+
+			if ( p > int( i )) {
+				int len = data. mid ( i + 1, p - i - 1 ). toInt ( );
+		
+				qDebug ( "sd: skipping %d bytes\n", len );
+			
+				if ( b == 0 ) {			
+					temp = data. mid ( eol + 1, len );
+					noappend = false;
+					i = eol + len;
+					continue;
+				}
+				else {
+					temp. append ( '{' );
+					temp. append ( QString::number ( len ));
+					temp. append ( "}\r\n" );
+					temp. append ( data. mid ( eol + 1, len ));
+					i = eol + len;
+					continue;
+				}
+			}
+		}
+
+		if (data[i] == '\"' && !escaped) a = !a;
 		else escaped = false;
 
-		if (data[i] == '\\' && data[i + 1] == '"') escaped = true;
+		if (data[i] == '\\' && data[i + 1] == '\"') escaped = true;
 
 		if ((data[i] == ' ' || i == data.length()) && b == 0 && !a) {
 			list.append(temp);
-			temp = QString(0);
+			temp = QString::null;
 			if (data[i] == ' ') noappend = true;
 		}
 
 		if (!noappend) temp += data[i];
 		noappend = false;
 	}
 
 	return list;
 }
 
 void IMAPResponseParser::parseParenthesizedList(const QString &data, QStringList &parsed)
 {
 	QString data_(data);
 	removeLimiters(data_, '(', ')');
 	parsed = splitData(data_, true);
 }
 
 void IMAPResponseParser::splitTagData(const QString &line, QString &tag, QString &data)
 {
 	int pos;
 	if ((pos = line.find(' ')) != -1) {
 		tag = line.left(pos);
 		data = line.right(line.length() - pos - 1);
-	} else qWarning("IMAPResponseParser: splitTagData: tag not found. Line was " + line + "|");
+	} else qWarning((QString("IMAPResponseParser: splitTagData: tag not found. Line was ") + line + "|").latin1());
 }
 
 QString IMAPResponseParser::removeLimiters(QString &string, const QChar &sl, const QChar &el)
 {
 	QString tmpString;
+	string = string. stripWhiteSpace ( );
+	
 	if (string[0] == sl && string[string.length() - 1] == el) {
 		string.truncate(string.length() - 1);
 		string.replace(0, 1, "");
 
 		for (unsigned int i = 1; i <= string.length(); i++) {
-			if (string[i - 1] == '\\' && sl == '"') ++i;
+			if (string[i - 1] == '\\' && sl == '\"') ++i;
 			tmpString += string[i - 1];
 		}
 	}
-
 	return tmpString;
 }
 
 IMAPResponseEnums::IMAPResponseCode IMAPResponseParser::getResponseCode(const QString &line)
 {
 	if (line.find(QRegExp((QString) "^\\[.*\\]" + ' ' + ".*")) != -1) {
 		int pos = line.find("] ");
 		QString code = line.left(pos + 1).upper();
 
 		if (code.find(QRegExp("[ALERT]")) != -1) return ALERT;
 		else if (code.find(QRegExp("[NEWNAME .* .*]")) != -1) return NEWNAME; // XXX
 		else if (code.find(QRegExp("[PARSE]")) != -1) return PARSE;
 		else if (code.find(QRegExp("[PERMANENTFLAGS \\d*]")) != -1) return PERMANENTFLAGS; // XXX
 		else if (code.find(QRegExp("[READ-ONLY]")) != -1) return READONLY;
 		else if (code.find(QRegExp("[READ-WRITE]")) != -1) return READWRITE;
 		else if (code.find(QRegExp("[TRYCREATE]")) != -1) return TRYCREATE;
 		else if (code.find(QRegExp("[UIDVALIDITY \\d*]")) != -1) return UIDVALIDITY; // XXX
 		else if (code.find(QRegExp("[UNSEEN \\d*]")) != -1) return UNSEEN; // XXX
 		else {
-			qWarning("IMAPResponseParser: getResponseCode: Unknown code: " + code + "|");
+			qWarning((QString("IMAPResponseParser: getResponseCode: Unknown code: ") + code + "|").latin1());
 			return UnknownCode;
 		}
 	}
 	return NoCode;
 }
 
 QValueList<IMAPResponseEnums::IMAPResponseFlags> IMAPResponseParser::parseFlagList(const QStringList &flagList)
 {
 	QValueList<IMAPResponseFlags> flags;
 	QStringList::ConstIterator it;
 	for (it = flagList.begin(); it != flagList.end(); it++) {
 		QString flag = (*it).lower();
 		if (flag == "\\seen") flags.append(Seen);
 		else if (flag == "\\answered") flags.append(Answered);
 		else if (flag == "\\flagged") flags.append(Flagged);
 		else if (flag == "\\deleted") flags.append(Deleted);
 		else if (flag == "\\draft") flags.append(Draft);
 		else if (flag == "\\recent") flags.append(Recent);
 		else if (flag == "\\noinferiors") flags.append(Noinferiors);
 		else if (flag == "\\noselect") flags.append(Noselect);
 		else if (flag == "\\marked") flags.append(Marked);
 		else if (flag == "\\unmarked") flags.append(Unmarked);
 		else if (flag.isEmpty()) { }
-		else qWarning("IMAPResponseParser: parseFlagList: Unknown flag: " + *it + "|");
+		else qWarning((QString("IMAPResponseParser: parseFlagList: Unknown flag: ") + *it + "|").latin1());
 	}
 	return flags;
 }
 
diff --git a/noncore/unsupported/mail2/libmail/imapresponse.h b/noncore/unsupported/mail2/libmail/imapresponse.h
index 73435ee..5a19b96 100644
--- a/noncore/unsupported/mail2/libmail/imapresponse.h
+++ b/noncore/unsupported/mail2/libmail/imapresponse.h
@@ -1,531 +1,532 @@
 #ifndef IMAPRESPONSE_H
 #define IMAPRESPONSE_H
 
 #include <qobject.h>
 
 #define MAX_BODYPARTS 		50
 
 class IMAPHandler;
 
 class IMAPResponseEnums
 {
 public:
 	enum IMAPResponseStatus {
 		OK, NO, BAD, PREAUTH, BYE, UnknownStatus = 0
 	};
 
 	enum IMAPResponseFlags {
 		Seen, Answered, Flagged, Deleted, Draft, Recent,
 		Noinferiors, Noselect, Marked, Unmarked, UnknownFlag = 0
 	};
 
 	enum IMAPResponseCode {
 		ALERT, NEWNAME, PARSE, PERMANENTFLAGS, READONLY, READWRITE,
 		TRYCREATE, UIDVALIDITY, UNSEEN, NoCode, UnknownCode = 0
 	};
 
 };
 
 class IMAPResponseAddress
 {
 public:
 	IMAPResponseAddress(QString name = 0, QString adl = 0, QString mailbox = 0, QString host = 0)
 	{
 		_name = name;
 		_adl = adl;
 		_mailbox = mailbox;
 		_host = host;
 	}
 
 	void setName(QString name) { _name = name; }
 	QString name() { return _name; }
 	void setAdl(QString adl) { _adl = adl; }
 	QString adl() { return _adl; }
 	void setMailbox(QString mailbox) { _mailbox = mailbox; }
 	QString mailbox() { return _mailbox; }
 	void setHost(QString host) { _host = host; }
 	QString host() { return _host; }
 
 	QString toString() 
 	{
 		if (_name.isNull() && _mailbox.isNull() && _host.isNull())
 			return QString(0);
 		if (_name != _mailbox + "@" + _host) 
 			return _name + " <" + _mailbox + "@" + _host + ">";
 		else
 			return _name;
 	}
 
 	QString email() 
 	{
 		if (_host.isEmpty()) return _mailbox;
 		else return _mailbox + "@" + _host;
 	}
 
 private:
 	QString _name, _adl, _mailbox, _host;
 
 };
 
 class IMAPResponseAddressList : public QValueList<IMAPResponseAddress>
 {
 public:
 	IMAPResponseAddressList()
 		: QValueList<IMAPResponseAddress>()
 	{
 
 	}
 
 	QString toString()
 	{
 		QString string;
 		IMAPResponseAddressList::Iterator it;
 		for (it = this->begin(); it != this->end(); it++) {
 			QString tmp = (*it).toString();
 			if (!tmp.isNull() && string.isEmpty()) string = tmp;
 			else if (!tmp.isNull()) string += ", " + tmp;
 		}
 		return string;
 	}
 
 };
 
 class IMAPResponseBody
 {
 public:
 	void setData(QString data) { _data = data; }
 	QString data() { return _data; }
 
 private:
 	QString _data;
 
 };
 
 class IMAPResponseBodyPart : public IMAPResponseBody
 {
 public:
 	void setPart(QString part) { _part = part; }
 	QString part() { return _part; }
 
 private:
 	QString _part;
 
 };
 
 class IMAPResponseEnvelope
 {
 public:
 	void setMailDate(QString date) { _date = date; }
 	QString mailDate() { return _date; }
 	void setSubject(QString subject) { _subject = subject; }
 	QString subject() { return _subject; }
 	void addFrom(IMAPResponseAddress from) { _from.append(from); }
 	IMAPResponseAddressList from() { return _from; }
 	void addSender(IMAPResponseAddress sender) { _sender.append(sender); }
 	IMAPResponseAddressList sender() { return _sender; }
 	void addReplyTo(IMAPResponseAddress replyTo) { _replyTo.append(replyTo); }
 	IMAPResponseAddressList replyTo() { return _replyTo; }
 	void addTo(IMAPResponseAddress to) { _to.append(to); }
 	IMAPResponseAddressList to() { return _to; }
 	void addCc(IMAPResponseAddress cc) { _cc.append(cc); }
 	IMAPResponseAddressList cc() { return _cc; }
 	void addBcc(IMAPResponseAddress bcc) { _bcc.append(bcc); }
 	IMAPResponseAddressList bcc() { return _bcc; }
 	void setInReplyTo(QString inReplyTo) { _inReplyTo = inReplyTo; }
 	QString inReplyTo() { return _inReplyTo; }
 	void setMessageId(QString messageId) { _messageId = messageId; }
 	QString messageId() { return _messageId; }
 
 private:
 	QString _date, _subject, _inReplyTo, _messageId;
 	IMAPResponseAddressList _from, _sender, _replyTo, _to, _cc, _bcc;
 
 };
 
 class IMAPResponseStatusResponse : public IMAPResponseEnums
 {
 public:
 	IMAPResponseStatusResponse(IMAPResponseStatus status = (IMAPResponseStatus)0, QString comment = 0, IMAPResponseCode code = (IMAPResponseCode)0)
 	{
 		_status = status;
 		_comment = comment;
 		_code = code;
 	}
 
 	void setStatus(IMAPResponseStatus status) { _status = status; }
 	IMAPResponseStatus status() { return _status; }
 	void setComment(QString comment) { _comment = comment; }
 	QString comment() { return _comment; }
 	void setResponseCode(IMAPResponseCode code) { _code = code; }
 	IMAPResponseCode responseCode() { return _code; }
 
 	void setExitedUnexpected(bool exitu) { _exitu = exitu; }
 	bool exitedUnexpected() { return _exitu; }
 
 private:
 	IMAPResponseStatus _status;
 	QString _comment;
 	IMAPResponseCode _code;
 	bool _exitu;
 
 };
 
 class IMAPResponseOK : public IMAPResponseEnums
 {
 public:
 	IMAPResponseOK(QString comment = 0, IMAPResponseCode code = (IMAPResponseCode)0)
 	{
 		_comment = comment;
 		_code = code;
 	}
 
 	void setComment(QString comment) { _comment = comment; }
 	QString comment() { return _comment; }
 	void setResponseCode(IMAPResponseCode code) { _code = code; }
 	IMAPResponseCode responseCode() { return _code; }
 
 private:
 	QString _comment;
 	IMAPResponseCode _code;
 
 };
 
 class IMAPResponseNO : public IMAPResponseEnums
 {
 public:
 	IMAPResponseNO(QString comment = 0, IMAPResponseCode code = (IMAPResponseCode)0)
 	{
 		_comment = comment;
 		_code = code;
 	}
 
 	void setComment(QString comment) { _comment = comment; }
 	QString comment() { return _comment; }
 	void setResponseCode(IMAPResponseCode code) { _code = code; }
 	IMAPResponseCode responseCode() { return _code; }
 
 private:
 	QString _comment;
 	IMAPResponseCode _code;
 
 };
 
 class IMAPResponseBAD : public IMAPResponseEnums
 {
 public:
 	IMAPResponseBAD(QString comment = 0, IMAPResponseCode code = (IMAPResponseCode)0)
 	{
 		_comment = comment;
 		_code = code;
 	}
 
 	void setComment(QString comment) { _comment = comment; }
 	QString comment() { return _comment; }
 	void setResponseCode(IMAPResponseCode code) { _code = code; }
 	IMAPResponseCode responseCode() { return _code; }
 
 private:
 	QString _comment;
 	IMAPResponseCode _code;
 
 };
 
 class IMAPResponseCAPABILITY
 {
 public:
 	IMAPResponseCAPABILITY(QStringList capabilities = 0)
 	{
 		_capabilities = capabilities;
 	}
 
 	void setCapabilities(QStringList capabilities) { _capabilities = capabilities; }
 	QStringList capabilities() { return _capabilities; }
 
 private:
 	QStringList _capabilities;
 
 };
 
 class IMAPResponseLIST : public IMAPResponseEnums
 {
 public:
 	IMAPResponseLIST(QValueList<IMAPResponseFlags> flags = QValueList<IMAPResponseFlags>(), QString folderSeparator = 0, QString folder = 0)
 	{
 		_flags = flags;
 		_folderSeparator = folderSeparator;
 		_folder = folder;
 	}
 
 	void setFlags(QValueList<IMAPResponseFlags> flags) { _flags = flags; }
 	QValueList<IMAPResponseFlags> flags() { return _flags; }
 	void setFolderSeparator(QString folderSeparator) { _folderSeparator = folderSeparator; }
 	QString folderSeparator() { return _folderSeparator; }
 	void setFolder(QString folder) { _folder = folder; }
 	QString folder() { return _folder; }
 
 private:
 	QValueList<IMAPResponseFlags> _flags;
 	QString _folderSeparator, _folder;
 
 };
 
 class IMAPResponseLSUB : public IMAPResponseEnums
 {
 public:
 	IMAPResponseLSUB(QValueList<IMAPResponseFlags> flags = QValueList<IMAPResponseFlags>(), QString folderSeperator = 0, QString folder = 0)
 	{
 		_flags = flags;
 		_folderSeperator = folderSeperator;
 		_folder = folder;
 	}
 
 	void setFlags(QValueList<IMAPResponseFlags> flags) { _flags = flags; }
 	QValueList<IMAPResponseFlags> flags() { return _flags; }
 	void setFolderSeperator(QString folderSeperator) { _folderSeperator = folderSeperator; }
 	QString folderSeperator() { return _folderSeperator; }
 	void setFolder(QString folder) { _folder = folder; }
 	QString folder() { return _folder; }
 
 private:
 	QValueList<IMAPResponseFlags> _flags;
 	QString _folderSeperator, _folder;
 
 };
 
 class IMAPResponseSTATUS
 {
 public:
 	IMAPResponseSTATUS(QString mailbox = 0, QString messages = 0, QString recent = 0, QString uidnext = 0, QString uidvalidity = 0, QString unseen = 0)
 	{
 		_mailbox = mailbox;
 		_messages = messages;
 		_recent = recent;
 		_uidnext = uidnext;
 		_uidvalidity = uidvalidity;
 		_unseen = unseen;
 	}
 
 	void setMailbox(QString &mailbox) { _mailbox = mailbox; }
 	QString mailbox() { return _mailbox; }
 	void setMessages(QString &messages) { _messages = messages; }
 	QString messages() { return _messages; }
 	void setRecent(QString &recent) { _recent = recent; }
 	QString recent() { return _recent; }
 	void setUidnext(QString &uidnext) { _uidnext = uidnext; }
 	QString uidnext() { return _uidnext; }
 	void setUidvalidity(QString &uidvalidity) { _uidvalidity = uidvalidity; }
 	QString uidvalidity() { return _uidvalidity; }
 	void setUnseen(QString &unseen) { _unseen = unseen; }
 	QString unseen() { return _unseen; }
 
 private:
 	QString _mailbox, _messages, _recent, _uidnext, _uidvalidity, _unseen;
 
 };
 
 class IMAPResponseSEARCH
 {
 public:
 	IMAPResponseSEARCH(QStringList mails = 0)
 	{
 		_mails = mails;
 	}
 
 	void setMails(QStringList mails) { _mails = mails; }
 	QStringList mails() { return _mails; }
 
 private:
 	QStringList _mails;
 
 };
 
 class IMAPResponseFLAGS : public IMAPResponseEnums
 {
 public:
 	IMAPResponseFLAGS(QValueList<IMAPResponseFlags> flags = QValueList<IMAPResponseFlags>())
 	{
 		_flags = flags;
 	}
 
 	void setFlags(QValueList<IMAPResponseFlags> flags) { _flags = flags; }
 	QValueList<IMAPResponseFlags> flags() { return _flags; }
 
 private:
 	QValueList<IMAPResponseFlags> _flags;
 
 };
 
 class IMAPResponseEXISTS
 {
 public:
 	IMAPResponseEXISTS(QString mails = 0)
 	{
 		_mails = mails;
 	}
 
 	void setMails(QString mails) { _mails = mails; }
 	QString mails() { return _mails; }
 
 private:
 	QString _mails;
 
 };
 
 class IMAPResponseRECENT
 {
 public:
 	IMAPResponseRECENT(QString mails = 0)
 	{
 		_mails = mails;
 	}
 
 	void setMails(QString mails) { _mails = mails; }
 	QString mails() { return _mails; }
 
 private:
 	QString _mails;
 
 };
 
 class IMAPResponseEXPUNGE 
 {
 public:
 	IMAPResponseEXPUNGE(QString mails = 0)
 	{
 		_mails = mails;
 	}
 
 	void setMails(QString mails) { _mails = mails; }
 	QString mails() { return _mails; }
 
 private:
 	QString _mails;
 
 };
 
 class IMAPResponseFETCH : public IMAPResponseEnums
 {
 public:
 	void setEnvelope(IMAPResponseEnvelope envelope) { _envelope = envelope; }
 	IMAPResponseEnvelope envelope() { return _envelope; }
 	void setFlags(QValueList<IMAPResponseFlags> flags) { _flags = flags; }
 	QValueList<IMAPResponseFlags> flags() { return _flags; }
 	void setInternalDate(QString idate) { _idate = idate; }
 	QString internalDate() { return _idate; }
 	void setRFC822Size(QString rfc822size) { _rfc822size = rfc822size; }
 	QString RFC822Size() { return _rfc822size; }
 	void setUid(QString uid) { _uid = uid; }
 	QString uid() { return _uid; }
 
 	void setBody(QString body) { _body = body; }
 	QString body() { return _body; }
 	void addBodyPart(IMAPResponseBodyPart part) { _bodyParts.append(part); }
 	void setBodyParts(QValueList<IMAPResponseBodyPart> parts) { _bodyParts = parts; }
 	QValueList<IMAPResponseBodyPart> bodyParts() { return _bodyParts; }
 	IMAPResponseBodyPart bodyPart(int part) { return _bodyParts[part]; }
 	void setRfc822(QString rfc822) { _rfc822 = rfc822; }
 	QString rfc822() { return _rfc822; }
 	void setRfc822Header(QString rfc822Header) { _rfc822Header = rfc822Header; }
 	QString rfc822Header() { return _rfc822Header; }
 	void setRfc822Text(QString rfc822Text) { _rfc822Text = rfc822Text; }
 	QString rfc822Text() { return _rfc822Text; }
 
 private:
 	IMAPResponseEnvelope _envelope;
 	QValueList<IMAPResponseFlags> _flags;
 	QString _idate, _rfc822size, _uid, _body, _rfc822, _rfc822Header, _rfc822Text;
 	QValueList<IMAPResponseBodyPart> _bodyParts;
 
 };
 
 class IMAPResponse : public IMAPResponseEnums
 {
 public:
 	void setTag(QString tag) { _tag = tag; }
 	QString tag() { return _tag; }
 
 	void setImapHandler(IMAPHandler *handler) { _handler = handler; }
 	IMAPHandler *imapHandler() { return _handler; }
 
 	void setStatusResponse(IMAPResponseStatusResponse response) { _response = response; }
 	IMAPResponseStatusResponse statusResponse() { return _response; }
 
 	void addOK(IMAPResponseOK ok) { _okl.append(ok); }
 	void addNO(IMAPResponseNO no) { _nol.append(no); }
 	void addBAD(IMAPResponseBAD bad) { _badl.append(bad); }
 	void addCAPABILITY(IMAPResponseCAPABILITY capability) { _capabilityl.append(capability); }
 	void addLIST(IMAPResponseLIST list) { _listl.append(list); }
 	void addLSUB(IMAPResponseLSUB lsub) { _lsubl.append(lsub); }
 	void addSTATUS(IMAPResponseSTATUS status) { _statusl.append(status); }
 	void addSEARCH(IMAPResponseSEARCH search) { _searchl.append(search); }
 	void addFLAGS(IMAPResponseFLAGS flags) { _flagsl.append(flags); }
 	void addEXISTS(IMAPResponseEXISTS exists) { _existsl.append(exists); }
 	void addRECENT(IMAPResponseRECENT recent) { _recentl.append(recent); }
 	void addEXPUNGE(IMAPResponseEXPUNGE expunge) { _expungel.append(expunge); }
 	void addFETCH(IMAPResponseFETCH fetch) { _fetchl.append(fetch); }
 
 	QValueList<IMAPResponseOK> OK() { return _okl; }
 	QValueList<IMAPResponseNO> NO() { return _nol; }
 	QValueList<IMAPResponseBAD> BAD() { return _badl; }
 	QValueList<IMAPResponseCAPABILITY> CAPABILITY() { return _capabilityl; }
 	QValueList<IMAPResponseLIST> LIST() { return _listl; }
 	QValueList<IMAPResponseLSUB> LSUB() { return _lsubl; }
 	QValueList<IMAPResponseSTATUS> STATUS() { return _statusl; }
 	QValueList<IMAPResponseSEARCH> SEARCH() { return _searchl; }
 	QValueList<IMAPResponseFLAGS> FLAGS() { return _flagsl; }
 	QValueList<IMAPResponseEXISTS> EXISTS() { return _existsl; }
 	QValueList<IMAPResponseRECENT> RECENT() { return _recentl; }
 	QValueList<IMAPResponseEXPUNGE> EXPUNGE() { return _expungel; }
 	QValueList<IMAPResponseFETCH> FETCH() { return _fetchl; }
 
 private:
 	QString _tag;
 	IMAPResponseStatusResponse _response;
 
 	IMAPHandler *_handler;
 
 	QValueList<IMAPResponseOK> _okl;
 	QValueList<IMAPResponseNO> _nol;
 	QValueList<IMAPResponseBAD> _badl;
 	QValueList<IMAPResponseCAPABILITY> _capabilityl;
 	QValueList<IMAPResponseLIST> _listl;
 	QValueList<IMAPResponseLSUB> _lsubl;
 	QValueList<IMAPResponseSTATUS> _statusl;
 	QValueList<IMAPResponseSEARCH> _searchl;
 	QValueList<IMAPResponseFLAGS> _flagsl;
 	QValueList<IMAPResponseEXISTS> _existsl;
 	QValueList<IMAPResponseRECENT> _recentl;
 	QValueList<IMAPResponseEXPUNGE> _expungel;
 	QValueList<IMAPResponseFETCH> _fetchl;
 
 };
 
 class IMAPResponseParser : public QObject, public IMAPResponseEnums 
 {
 	Q_OBJECT
 
 public:
-	IMAPResponseParser(const QString &data);
+	IMAPResponseParser();
+	void parse ( const QString &data);
 
 	IMAPResponse response();
 
 signals:
-	void needMoreData(const QString &comment);
+	void needMoreData(QString &data);
 
 protected:
 	void parseResponse(const QString &data, bool tagged = false);
 
 	QStringList splitData(const QString &data, bool withBrackets);
 	void parseParenthesizedList(const QString &data, QStringList &parsed);
 	void splitTagData(const QString &line, QString &tag, QString &data);
 	QString removeLimiters(QString &string, const QChar &sl = '"', const QChar &el = '"');
 	IMAPResponseCode getResponseCode(const QString &line);
 	QValueList<IMAPResponseFlags> parseFlagList(const QStringList &flags);
 
 private:
 	IMAPResponse _iresponse;
 
 };
 
 #endif
 
diff --git a/noncore/unsupported/mail2/viewmail.cpp b/noncore/unsupported/mail2/viewmail.cpp
index 3c88d99..da6924d 100644
--- a/noncore/unsupported/mail2/viewmail.cpp
+++ b/noncore/unsupported/mail2/viewmail.cpp
@@ -1,198 +1,198 @@
 #include <qtextbrowser.h>
 #include <qmessagebox.h>
 #include <qaction.h>
 #include <qapplication.h>
 
 #include "mailfactory.h"
 #include "composer.h"
 #include "viewmail.h"
 
 AttachItem::AttachItem(QListView *parent, AttachItemStore &attachItemStore)
 	: QListViewItem(parent), _attachItemStore(attachItemStore)
 {
 	setText(0, _attachItemStore.mimeType());
 	setText(1, _attachItemStore.fileName());
 	setText(2, _attachItemStore.description());
 }
 
 AttachItem::AttachItem(QListViewItem *parent, AttachItemStore &attachItemStore)
 	: QListViewItem(parent), _attachItemStore(attachItemStore)
 {
 	setText(0, _attachItemStore.mimeType());
 	setText(1, _attachItemStore.fileName());
 	setText(2, _attachItemStore.description());
 }
 
 ViewMail::ViewMail(IMAPResponseFETCH &mail, IMAPHandler *handler, QWidget *parent, const char *name, WFlags fl)
 	: ViewMailBase(parent, name, fl), _inLoop(false), _mail(mail), _handler(handler)
 {
 	setCaption(caption().arg(mail.envelope().from()[0].name()));
 
 	_gotBody = false;
 	_mailHtml = tr(
 		"<html><body>"
 		"<div align=center><b>%1</b></div>"
 		"<b>From:</b> %2<br>"
 		"<b>To:</b> %3<br>"
 		"%4"
 		"%5"
 		"<b>Date:</b> %6<hr>"
 		"<font face=fixed>%7</font>")
 		.arg(deHtml(mail.envelope().subject().isNull() ? tr("(no subject)") 
 			: deHtml(mail.envelope().subject())))
 		.arg(deHtml(mail.envelope().from().toString().isNull() ? tr("(no from)") 
 			: mail.envelope().from().toString()))
 		.arg(deHtml(mail.envelope().to().toString().isNull() ? tr("(no recipient)")
 			: mail.envelope().to().toString()))
 		.arg(mail.envelope().cc().toString().isNull() ? QString(0) 
 			: tr("<b>Cc:</b> %1<br>").arg(deHtml(mail.envelope().cc().toString())))
 		.arg(mail.envelope().bcc().toString().isNull() ? QString(0)
 			: tr("<b>Bcc:</b> %1<br>").arg(deHtml(mail.envelope().bcc().toString())))
 		.arg(mail.envelope().mailDate().isNull() ? tr("(no date)") 
 			: mail.envelope().mailDate())
 		.arg("%1");
 
 	connect(reply, SIGNAL(activated()), SLOT(slotReply()));
 	connect(forward, SIGNAL(activated()), SLOT(slotForward()));
 
 	attachments->setEnabled(_gotBody);
 	browser->setText(QString(_mailHtml).arg(tr("Getting mail body from server. Please wait...")));
 
 	_handler->iUid("FETCH", QString("%1 (BODY[1])").arg(mail.uid()));
 	connect(_handler, SIGNAL(gotResponse(IMAPResponse &)), SLOT(slotIMAPUid(IMAPResponse &)));
 }
 
 ViewMail::~ViewMail()
 {
 	hide();
 }
 
 void ViewMail::hide()
 {
 	QWidget::hide();
 
 	if (_inLoop) {
 		_inLoop = false;
 		qApp->exit_loop();
 	}
 }
 
 void ViewMail::exec()
 {
 	show();
 
 	if (!_inLoop) {
 		_inLoop = true;
 		qApp->enter_loop();
 	}
 }
 
 QString ViewMail::deHtml(const QString &string)
 {
 	QString string_ = string;
 	string_.replace(QRegExp("&"), "&amp;");
 	string_.replace(QRegExp("<"), "&lt;");
 	string_.replace(QRegExp(">"), "&gt;");
 	string_.replace(QRegExp("\\n"), "<br>");
 	return string_;
 }
 
 void ViewMail::slotReply()
 {
 	if (!_gotBody) {
 		QMessageBox::information(this, tr("Error"), tr("<p>The mail body is not yet downloaded, so you cannot reply yet."), tr("Ok"));
 		return;
 	}
 
 	QString rtext;
 	rtext += QString("* %1 wrote on %2:\n")		// no i18n on purpose
 		.arg(_mail.envelope().from()[0].toString())
 		.arg(_mail.envelope().mailDate());
 
 	QString text = _mail.bodyPart(1).data();
 	QStringList lines = QStringList::split(QRegExp("\\n"), text);
 	QStringList::Iterator it;
 	for (it = lines.begin(); it != lines.end(); it++) {
 		rtext += "> " + *it + "\n";
 	}
 	rtext += "\n";
 
 	QString prefix;
 	if (_mail.envelope().subject().find(QRegExp("^Re: *$")) != -1) prefix = "";
 	else prefix = "Re: ";				// no i18n on purpose
 
 	SendMail sendMail;
 	sendMail.setTo(_mail.envelope().from()[0].toString());
 	sendMail.setSubject(prefix + _mail.envelope().subject());
 	sendMail.setInReplyTo(_mail.envelope().messageId());
 	sendMail.setMessage(rtext);
 
 	Composer composer(this, 0, true);
 	composer.setSendMail(sendMail);
 	composer.showMaximized();
 	composer.exec();
 }
 
 void ViewMail::slotForward()
 {
 	if (!_gotBody) {
 		QMessageBox::information(this, tr("Error"), tr("<p>The mail body is not yet downloaded, so you cannot forward yet."), tr("Ok"));
 		return;
 	}
 
 	QString ftext;
 	ftext += QString("\n----- Forwarded message from %1 -----\n\n")
 		.arg(_mail.envelope().from()[0].toString());
 	if (!_mail.envelope().mailDate().isNull())
 		ftext += QString("Date: %1\n")
 			.arg(_mail.envelope().mailDate());
 	if (!_mail.envelope().from()[0].toString().isNull())
 		ftext += QString("From: %1\n")
 			.arg(_mail.envelope().from()[0].toString());
 	if (!_mail.envelope().to().toString().isNull())
 		ftext += QString("To: %1\n")
 			.arg(_mail.envelope().to().toString());
 	if (!_mail.envelope().cc().toString().isNull())
 		ftext += QString("Cc: %1\n")
 			.arg(_mail.envelope().cc().toString());
 	if (!_mail.envelope().bcc().toString().isNull())
 		ftext += QString("Bcc: %1\n")
 			.arg(_mail.envelope().bcc().toString());
 	if (!_mail.envelope().subject().isNull())
 		ftext += QString("Subject: %1\n")
 			.arg(_mail.envelope().subject());
 
 	ftext += QString("\n%1\n")
 		.arg(_mail.bodyPart(1).data());
 
 	ftext += QString("----- End forwarded message -----\n");
 
 	SendMail sendMail;
 	sendMail.setSubject("Fwd: " + _mail.envelope().subject());
 	sendMail.setMessage(ftext);
 
 	Composer composer(this, 0, true);
 	composer.setSendMail(sendMail);
 	composer.showMaximized();
 	composer.exec();
 }
 
 void ViewMail::slotIMAPUid(IMAPResponse &response)
 {
 	disconnect(_handler, SIGNAL(gotResponse(IMAPResponse &)), this, SLOT(slotIMAPUid(IMAPResponse &)));
 
 	if (response.statusResponse().status() == IMAPResponseEnums::OK) {
 		QValueList<IMAPResponseBodyPart> bodyParts;
-		bodyParts.append(response.FETCH()[0].bodyPart(1));
+		bodyParts.append(response.FETCH()[0].bodyPart(0));
 		_mail.setBodyParts(bodyParts);
 
-		browser->setText(QString(_mailHtml).arg(deHtml(response.FETCH()[0].bodyPart(1).data())));
+		browser->setText(QString(_mailHtml).arg(deHtml(response.FETCH()[0].bodyPart(0).data())));
 
 //		fillList(response.FETCH()[0].bodyStructure());
 
 		_gotBody = true;
 	} else {
 		QMessageBox::warning(this, tr("Error"), tr("<p>I was unable to retrieve the mail from the server. You can try again later or give up.</p>"), tr("Ok"));
 	}
 }