{

d->unlock();

}

it = begin + len + from;

}

const char* restart = it;

// See if the remainder matches

const char* searchIt = it;

const char* matchIt = matchBegin + 1;

if (matchIt == matchEnd)

return ((it - 1) - begin);

while (haystack <= end) {

hashHaystack += *(haystack + ol_minus_1);

if (hashHaystack == hashNeedle && *needle == *haystack

return haystack - source.data();

}

REHASH(*haystack);

}

}

if (!buffer || !fileMap.contains(filename))

return false;

template void LongString::deserialize<QDataStream>(QDataStream&);

template void LongString::serialize(QDBusArgument&) const;

template void LongString::deserialize(const QDBusArgument&);

}

#endif

}

#endif

{

d->_sinks.append(sink);

}

{

d->_modified = set;

}

#include "qmailaccountkey.h"

#include "mailkeyimpl_p.h"

class QMailAccountKeyPrivate : public MailKeyImpl<QMailAccountKey>

{

public:

QMailAccountKeyPrivate(const ListType &ids, QMailAccountKey::Property p, QMailKey::Comparator c) : Impl(ids, p, c) {}

};

#endif

};

LessThanFunctorA::LessThanFunctorA(const QMailAccountSortKey& sortKey)

{

}

QMailAccountKey secondKey(QMailAccountKey::id(second));

QMailAccountIdList results = QMailStore::instance()->queryAccounts(firstKey | secondKey, mSortKey);

mInvalidatedList = true;

return false;

}

QMailAccountListModelPrivate::QMailAccountListModelPrivate(const QMailAccountKey& key,

const QMailAccountSortKey& sortKey,

bool synchronizeEnabled)

{

}

*/

QMailAccountListModel::QMailAccountListModel(QObject* parent)

{

connect(QMailStore::instance(),

SIGNAL(accountsAdded(QMailAccountIdList)),

continue;

d->deletionId = id;

d->idList.removeAt(index);

endRemoveRows();

d->deletionId = QMailAccountId();

d->populated = false;

endResetModel();

}

}

Q_IMPLEMENT_USER_METATYPE(QMailAccountSortKey)

Q_DECLARE_USER_METATYPE(QMailAccountSortKey)

#endif

Q_IMPLEMENT_USER_METATYPE_ENUM(QMailServerRequestType)

Q_IMPLEMENT_USER_METATYPE(QMailActionData)

Q_IMPLEMENT_USER_METATYPE_TYPEDEF(QMailActionDataList, QMailActionDataList)

namespace {

{

QRegularExpression specials(QLatin1String("[<>\\[\\]:;@\\\\,.]"));

Q_UNUSED(escaped)

}

{

Decommentor decommentor(classifier, acceptedResult);

decommentor.processCharacters(input);

return _result;

}

{

AddressListGenerator generator;

generator.processCharacters(list);

return generator.result();

}

{

// There is no shortcut; we have to parse the addresses

AddressListGenerator generator;

return _listTerminator;

}

{

GroupDetector detector;

detector.processCharacters(input);

_result.append(character);

}

{

WhitespaceRemover remover;

remover.processCharacters(input);

}

}

{

QuoteDisplayName quoteDisplayName;

quoteDisplayName.processCharacters(input);

{

// See if there is a trailing suffix

int pos = input.indexOf(QLatin1String("/TYPE="));

suffix = input.mid(pos + 6);

input = input.left(pos);

}

// Separate the email address from the name

QPair<int, int> delimiters = findDelimiters(input);

name = address = input.trimmed();

// Unmatched '>'

address = input.left( delimiters.second );

name = input.left( delimiters.first );

if (delimiters.second == -1)

: _group(false),

_searchCompleted(false)

{

QString input = addressText.trimmed();

// See whether this address is a group

QRegularExpressionMatch match = QRegularExpression(QLatin1String("(.*):(.*);")).match(input);

_name = match.captured(1).trimmed();

_address = match.captured(2).trimmed();

_group = true;

}

parseMailbox(input, _name, _address, _suffix);

setComponents(_name, _address);

}

_searchCompleted(false)

{

// See whether the address part contains a group

_name = name;

_address = address;

_group = true;

setComponents(name, address);

}

}

{

QString result;

return _name;

if ( _group ) {

result.append( _name ).append( QLatin1String(": ") ).append( _address ).append( QChar::fromLatin1(';') );

} else {

// If there are any 'special' characters in the name it needs to be quoted

result = ::quoteIfNecessary(_name);

}

result = _address;

} else {

result.append( QChar::fromLatin1('<') ).append( _address ).append( QChar::fromLatin1('>') );

}

}

Q_IMPLEMENT_USER_METATYPE_TYPEDEF(QMailAddressList, QMailAddressList)

//Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(QList<QMailAddress>)

{

static bool enumerated = false;

qCDebug(lcMessaging) << "Available codecs:";

foreach (const QByteArray& codec, QTextCodec::availableCodecs())

qCDebug(lcMessaging) << " " << codec;

*/

void QMailCodec::encode(QDataStream& out, QTextStream& in, const QByteArray& charset)

{

QTextEncoder *encoder = codec->makeEncoder(QTextCodec::IgnoreHeader);

QString chunk = in.read(MaxCharacters);

QByteArray charsetEncoded = encoder->fromUnicode(chunk);

QDataStream decodedStream(&decoded, QIODevice::WriteOnly);

char* buffer = new char[MaxCharacters];

int length = in.readRawData(buffer, MaxCharacters);

// Allow for decoded data to be twice the size without reallocation

void QMailCodec::encode(QDataStream& out, QDataStream& in)

{

char* buffer = new char[MaxCharacters];

int length = in.readRawData(buffer, MaxCharacters);

encodeChunk(out, reinterpret_cast<unsigned char*>(buffer), length, in.atEnd());

void QMailCodec::decode(QDataStream& out, QDataStream& in)

{

char* buffer = new char[MaxCharacters];

int length = in.readRawData(buffer, MaxCharacters);

if (length > 0 && in.status() == QDataStream::ReadPastEnd) {

// work around QTBUG-69474

if (!encoding.isEmpty()) {

QTextCodec* codec = QTextCodec::codecForName(encoding);

qCWarning(lcMessaging) << "QMailCodec::codecForName - Unable to find codec for charset" << encoding;

enumerateCodecs();

}

void QMailCodec::copy(QDataStream& out, QDataStream& in)

{

char* buffer = new char[MaxCharacters];

int length = in.readRawData(buffer, MaxCharacters);

out.writeRawData(buffer, length);

}

QTextDecoder *decoder = codec->makeDecoder();

char* buffer = new char[MaxCharacters];

int length = in.readRawData(buffer, MaxCharacters);

out << decoder->toUnicode(buffer, length);

}

const unsigned char* lineEnd = it + _encodeLineCharsRemaining;

const unsigned char* const end = it + length;

bool trailingLF = false;

const unsigned char input = *it++;

// We have already encoded this character-sequence

// We can accept one more input character than accounted for

lineEnd += 1;

// We must replace this character with ASCII CRLF

*_encodeBufferOut++ = CarriageReturn;

*_encodeBufferOut++ = LineFeed;

trailingLF = true;

}

}

_lastChar = input;

*_encodeBufferOut++ = input;

// We have buffered 3 input bytes - write them out as four output bytes

out << Base64Values[(_encodeBuffer[0] >> 2) & 0x3f];

out << Base64Values[(((_encodeBuffer[0] & 0x03) << 4) | (_encodeBuffer[1] >> 4)) & 0x3f];

out << Base64Values[_encodeBuffer[2] & 0x3f];

_encodeBufferOut = _encodeBuffer;

// Insert an ASCII CRLF sequence

out << static_cast<unsigned char>(CarriageReturn) << static_cast<unsigned char>(LineFeed);

lineEnd += (_maximumLineLength / 4 * 3);

}

}

*_encodeBufferOut++ = LineFeed;

}

}

int bufferedBytesRemaining = _encodeBufferOut - _encodeBuffer;

// We have some data still buffered - pad buffer with zero bits

*_encodeBufferOut = 0;

out << Base64Values[(((_encodeBuffer[0] & 0x03) << 4) | (_encodeBuffer[1] >> 4)) & 0x3f];

// Indicate unused bytes with the padding character

out << Base64PaddingByte;

out << Base64PaddingByte;

out << Base64Values[(((_encodeBuffer[1] & 0x0f) << 2) | (_encodeBuffer[2] >> 6)) & 0x3f];

out << Base64PaddingByte;

}

}

// Leave the buffer intact, and adjust the line char count

_encodeLineCharsRemaining = (lineEnd - it);

}

unsigned char* bufferEnd = _decodeBuffer + 4;

const char* const end = it + length;

// Convert each character to the index value

*_decodeBufferOut = base64Index(*it++);

if (*_decodeBufferOut == 64)

if (*_decodeBufferOut <= 64)

++_decodeBufferOut;

// We have buffered 4 input characters - write them out as three output bytes

// unless some of them are padding

decoded[2] = static_cast<unsigned char>(((_decodeBuffer[2] & 0x03) << 6) | (_decodeBuffer[3] & 0x3f));

int remainingChars = (3 - _decodePaddingCount);

// We have already processed this sequence

// We should output the local newline sequence, but we can't

// because we don't know what it is, and C++ translation-from-\n will

// only work if the stream is a file...

}

_lastChar = decoded[i];

out << decoded[i];

}

_decodeBufferOut = _decodeBuffer;

}

}

// There should always be an even multiple of 4 input bytes

int bufferedBytesRemaining = _decodeBufferOut - _decodeBuffer;

qCWarning(lcMessaging) << "Huh? bytes remaining:" << bufferedBytesRemaining;

}

}

// For RFC 2047, we need to escape '?', '_', ' ' & '\t'

// In fact, since the output may be used in a header field 'word', then the only characters

// that can be used un-escaped are: alphanumerics, '!', '*', '+' '-', '/' and '_'

// We can also ignore space, since it will become an underscore

escape = !isalnum(input);

}

}

// The (potentially) last whitespace character on a line must be escaped

if (charsRemaining <= 3)

escape = true;

// Set the input pointers relative to this input

const unsigned char* const end = it + length;

unsigned char input = *it++;

// We have already encoded this character-sequence

// We must replace this character with ascii CRLF

out << CarriageReturn << LineFeed;

}

int charsRequired = (escape ? 3 : 1);

// If we can't fit this character on the line, insert a line break

lineBreak(out, &_encodeLineCharsRemaining, _maximumLineLength);

// We may no longer need the encoding after the line break

charsRequired = 1;

}

if (input == Space && _conformance == Rfc2047) // output space as '_'

out << static_cast<unsigned char>(Underscore);

else

out << input;

encodeCharacter(out, input);

_encodeLineCharsRemaining -= charsRequired;

// The variable _decodePrecedingInput holds any unprocessed input from a previous call:

// If '=', we've parsed only that char, otherwise, it is the hex value of the first parsed character

unsigned char value = 0;

// Get the first escaped char

unsigned char input = *it++;

// This is only a soft-line break

_decodePrecedingInput = NilPreceding;

value = decodeCharacter(input);

_decodePrecedingInput = value;

}

_decodeLastChar = input;

// We already have partial escaped input

value = _decodePrecedingInput;

}

out << static_cast<unsigned char>((value << 4) | decodeCharacter(*it++));

_decodePrecedingInput = NilPreceding;

}

}

unsigned char input = *it++;

// We are in an escape sequence

_decodePrecedingInput = Equals;

input = *it++;

// This is a soft-line break - move on

// This is an encoded character

unsigned char value = decodeCharacter(input);

_decodePrecedingInput = value;

out << static_cast<unsigned char>((value << 4) | decodeCharacter(*it++));

}

}

}

// We have already processed this sequence

// We should output the local newline sequence, but we can't

// because we don't know what it is, and C++ translation-from-\n will

// only work if the stream is a file...

out << static_cast<unsigned char>('\n');

}

out << static_cast<unsigned char>(Space);

out << input;

}

_decodeLastChar = input;

}

qCWarning(lcMessaging) << "Huh? unfinished escape sequence...";

}

}

static void writeStream(QDataStream& out, const char* it, int length)

{

int totalWritten = 0;

int bytesWritten = out.writeRawData(it + totalWritten, length - totalWritten);

if (bytesWritten == -1)

return;

const unsigned char* const end = it + length;

const unsigned char* begin = it;

const unsigned char input = *it;

// We have already encoded this character-sequence; skip the input

begin = (it + 1);

// Write the preceding characters

if (it > begin)

writeStream(out, reinterpret_cast<const char*>(begin), (it - begin));

++it;

}

// Write the remaining characters

writeStream(out, reinterpret_cast<const char*>(begin), (it - begin));

}

const char* const end = it + length;

const char* begin = it;

const char input = *it;

// We have already processed this sequence

begin = (it + 1);

// Write the preceding characters

if (it > begin)

writeStream(out, begin, (it - begin));

++it;

}

// Write the remaining characters

writeStream(out, begin, (it - begin));

}

static QString decodeModifiedBase64(QString in)

{

//remove & -

if (in.isEmpty())

return QLatin1String("&");

//chars to numeric

QByteArray latinChars = in.toLatin1();

for (int x = 0; x < in.length(); x++) {

int c = latinChars[x];

buf[x] = c - 'A';

buf[x] = c - 'a' + 26;

buf[x] = c - '0' + 52;

buf[x] = 62;

buf[x] = 63;

}

endIndex++;

// encode non-US-ASCII part

QString mbase64 = encodeModifiedBase64(unicodeString);

// insert the encoded string

in.insert(startIndex, mbase64);

// set start index to the end of the encoded part

return out;

}

QMailStore::ErrorCode QMailContentManager::remove(const QList<QString> &identifiers)

{

QMailStore::ErrorCode returnError(QMailStore::NoError);

QMailStore::ErrorCode err(remove(identifier));

if (returnError == QMailStore::NoError) // report the first failure, but continue.

returnError = err;

return returnError;

}

/*!

Directs the content manager to perform any initialization tasks required.

The content manager should return false if unable to perform initialization tasks; otherwise return true.

{

return StorageRole;

}

};

#endif

\value Present Tests whether the specified property is present in the QMailStore object.

\value Absent Tests whether the specified property is absent in the QMailStore object.

*/

}

// undo moves

QMailMessageMetaData mail(id);

mail.setParentFolderId(mail.previousParentFolderId());

mail.setPreviousParentFolderId(QMailFolderId());

{

QList<QMailMessageMetaData *> messages; // Using this for efficient update

QMailMessageMetaData *msg = new QMailMessageMetaData(id);

QMailFolderId folderId(QMailAccount(msg->parentAccountId()).standardFolder(standardFolder)); // will be cached

QMailFolder folder;

{

QMailAccountIdList allAccounts = QMailStore::instance()->queryAccounts();

QMailAccount account(id);

QMailFolderId standardFolderId = account.standardFolder(standardFolder);

if (standardFolderId.isValid())

}

}

copy.setParentAccountId(mail.parentAccountId());

copy.setSize(mail.size());

copy.setStatus(mail.status());

syncStatusWithFolder(copy);

QMailStore::instance()->addMessage(&copy);

}

if (!messages.empty()) {

QMailStore::instance()->updateMessages(messages);

}

}

};

#endif

{

return QMailFolderKey(Custom, QStringList() << QMailKey::stringValue(name) << QMailKey::stringValue(value), QMailKey::comparator(cmp));

}

return QMailFolderSortKey(Status, order, mask);

}

Q_IMPLEMENT_USER_METATYPE(QMailFolderSortKey)

{

return qHash(id.toULongLong());

}

Q_IMPLEMENT_USER_METATYPE_ENUM(QMailRetrievalAction::RetrievalSpecification)

Q_IMPLEMENT_USER_METATYPE_ENUM(QMailSearchAction::SearchSpecification)

Reads the contents of a QMailKeyArgument from \a stream.

*/

};

#endif

const char* const end = begin + container.length() - (content.length() - 1);

const char* it = begin + from;

const char* restart = it;

// See if the remainder matches

const char* searchIt = it;

const char* matchIt = matchBegin + 1;

if (matchIt == matchEnd)

return ((it - 1) - begin);

// We may find the next place to search in our scan

if ((restart == it) && (*searchIt == *(it - 1)))

restart = searchIt;

// No match

it = restart;

const QChar* it = input.constData();

const QChar* const end = it + input.length();

// Multi-byte characters included - we need to use UTF-8

return QByteArray("UTF-8");

// We need encoding from latin-1

latin1 = true;

}

static QByteArray fromUnicode(const QString& input, const QByteArray& charset)

{

// See if we can convert using the nominated charset

if (QTextCodec* textCodec = QMailCodec::codecForName(charset))

return textCodec->fromUnicode(input);

static const char* nameForEncoding(QMailMessageBody::TransferEncoding te)

{

}

}

static QMailCodec* codecForEncoding(QMailMessageBody::TransferEncoding te, bool textualData)

{

}

}

static QMailCodec* codecForEncoding(QMailMessageBody::TransferEncoding te, const QMailMessageContentType& content)

// Find the parts of the input

index[0] = encodedWord.indexOf("=?");

index[1] = encodedWord.indexOf('?', index[0] + 2);

index[2] = encodedWord.indexOf('?', index[1] + 1);

index[3] = encodedWord.lastIndexOf("?=");

QByteArray charset = QMail::unquoteString(encodedWord.mid(index[0] + 2, (index[1] - index[0] - 2)));

QByteArray encoding = encodedWord.mid(index[1] + 1, (index[2] - index[1] - 1)).toUpper();

QByteArray encoded = encodedWord.mid(index[2] + 1, (index[3] - index[2] - 1));

QMailQuotedPrintableCodec codec(QMailQuotedPrintableCodec::Text, QMailQuotedPrintableCodec::Rfc2047);

result = qMakePair(codec.decode(encoded), charset);

QMailBase64Codec codec(QMailBase64Codec::Binary);

result = qMakePair(codec.decode(encoded), charset);

}

{

QByteArray result;

if (!result.isEmpty())

result.append(' ');

int index = -1;

int lastIndex = -1;

lastIndex = index;

index = input.indexOf(separator, lastIndex + 1);

int maximumEncoded = 75 - 7 - charset.length();

// If this is an encodedWord, we need to include any whitespace that we don't want to lose

QList<QByteArray> listEnc;

QList<QByteArray> list = splitUtf8(text.toUtf8(), maximumEncoded);

foreach (const QByteArray &item, list) {

}

return generateEncodedWord(charset, 'B', listEnc);

QMailQuotedPrintableCodec codec(QMailQuotedPrintableCodec::Text, QMailQuotedPrintableCodec::Rfc2047, maximumEncoded);

QByteArray encoded = codec.encode(text, charset);

return generateEncodedWord(charset, 'Q', split(encoded, "=\r\n"));

const QChar* it = input.constData();

const QChar* const end = it + input.length();

const QChar* token = it;

EncodingTokenType state = ((*it) == QChar::fromLatin1('"') ? Quote : ((*it).isSpace() ? Whitespace : Word));

escaped = true;

continue;

}

// This quotation mark is a token by itself

result.append(makeToken(state, token, it, escaped));

state = ((*it) == QChar::fromLatin1('"') && !escaped ? Quote : ((*it).isSpace() ? Whitespace : Word));

token = it;

// We have passed the end of this whitespace-sequence

result.append(makeToken(state, token, it, escaped));

state = ((*it) == QChar::fromLatin1('"') && !escaped ? Quote : Word);

token = it;

}

// We have passed the end of this word

result.append(makeToken(state, token, it, escaped));

QString quotedText;

QString heldWhitespace;

QString chars = QString::fromRawData(token.second.first, token.second.second);

// See if we're processing some quoted words

// We have reached the end of a quote sequence

quotedText.append(chars);

if (lastEncoded && tokenEncoded)

result.append(' ');

result.append(output);

quotedText.append(chars);

}

// This token begins a quoted sequence

quotedText = chars;

quoted = true;

bool lastEncoded = tokenEncoded;

// See if this token needs encoding

if (lastEncoded && tokenEncoded)

result.append(' ');

result.append(output);

// If the last token was an encoded-word, we may need to include this

// whitespace into the next token

if (tokenEncoded)

}

// Process trailing text after unmatched double quote character

bool lastEncoded = tokenEncoded;

QByteArray output = encodeWord(heldWhitespace + quotedText, charset, &tokenEncoded);

// Decode any encoded bytes in the data

const char* it = text.constData();

if ((end - it) > 2)

decoded.append(hexValue(it + 1));

it += 2;

decoded.append(*it);

}

// Decoded contains a bytestream - decode to unicode text if possible

// If the charset contains a language part, extract it

int index = result.indexOf('*');

// If no language is specified, use the extracted part

if (lang.isEmpty())

lang = result.mid(index + 1);

disposition.setParameter("filename*", QMailMessageContentDisposition::encodeParameter(input, "UTF-8"));

}

QMailMessageBody::RequiresEncoding));

addedSome = true;

}

// Extensions according to RFC 2231:

QRegularExpressionMatch extensionFormat =

QRegularExpression(QLatin1String("^(?:\\*(\\d+))?(\\*?)$")).match(QLatin1String(trailer));

if (number)

*number = extensionFormat.captured(1).toInt();

if (encoded)

if (index == -1)

return false;

// Ensure that every preceding character is whitespace

QByteArray leader(other.left(index).trimmed());

if (!leader.isEmpty())

index = other.length();

// Ensure that there is only whitespace between the matched name and the end of the name

QByteArray trailer(other.mid(lastIndex + 1, (index - lastIndex)).trimmed());

if (!trailer.isEmpty())

return validExtension(trailer, 0, encoded);

const char* token = begin;

const char* it = begin;

const char* separator = 0;

if (*it == '"') {

quoted = !quoted;

}

if (separator == 0) {

// This is a parameter separator

separator = it;

// It would be nice to identify extra '=' chars, but it's too hard

// to separate them from encoded-word formations...

//malformed = true;

}

// This is the end of a token

if (_content.isEmpty()) {

_content = QByteArray(token, (it - token)).trimmed();

QByteArray name = QByteArray(token, (separator - token)).trimmed();

QByteArray value = QByteArray(separator + 1, (it - separator - 1)).trimmed();

if (!name.isEmpty() && !value.isEmpty())

addParameter(name, value);

malformed = true;

}

if (token != end) {

if (_id.isEmpty()) {

_id = QByteArray(token, (end - token)).trimmed();

_content = QByteArray(token, (end - token)).trimmed();

QByteArray name = QByteArray(token, (separator - token)).trimmed();

QByteArray value = QByteArray(separator + 1, (end - separator - 1)).trimmed();

if (!name.isEmpty() && !value.isEmpty())

addParameter(name, value);

malformed = true;

}

}

// We have multiple pieces to insert

QList<QByteArray> pieces;

QByteArray input(value);

int splitPoint = maxInputLength;

if (encoded && input.length() > maxInputLength) {

int percentPosition = input.indexOf("%", maxInputLength - 2);

result += _content;

}

foreach (const QMailMessageContentType::ParameterType& parameter, (presentable ? parameters() : _parameters))

result.append("; ").append(parameter.first).append('=').append(protectedParameter(parameter.second));

}

{

QString result(QMailMessageHeaderField::decodeContent(_content));

foreach (const QMailMessageContentType::ParameterType& parameter, _parameters) {

QString decoded;

if (parameterEncoded(parameter.first))

// Although a conforming CT must be: <type> "/" <subtype> without whitespace,

// we'll be a bit more accepting

int index = type.indexOf('/');

content = type.trimmed();

QByteArray primaryType = type.left(index).trimmed();

QByteArray secondaryType = type.mid(index + 1).trimmed();

void QMailMessageContentType::setSubType(const QByteArray& subType)

{

QByteArray primaryType(type());

if (!subType.isEmpty())

primaryType.append('/').append(subType);

if (index == -1)

return false;

// Ensure that every preceding character is whitespace

QByteArray leader(other.left(index).trimmed());

if (!leader.isEmpty())

index = other.length() - 1;

// Ensure that there is only whitespace between the matched ID and the end of the ID

QByteArray trailer(other.mid(lastIndex + 1, (index - lastIndex)).trimmed());

if (!trailer.isEmpty())

return false;

} else {

autoCharset = QMailCodec::autoDetectEncoding(data).toLatin1();

}

if (!autoCharset.isEmpty() && (insensitiveIndexOf("ISO-8859-", autoCharset) == -1)) {

QByteArray best(QMailCodec::bestCompatibleCharset(autoCharset, true));

if (!best.isEmpty()) {

te = QMailMessageBody::SevenBit;

QMailCodec* codec = codecForEncoding(te, content);

// Stream to the buffer, encoding as required

QByteArray encoded;

{

_bodyData = LongString();

QMailCodec* codec = codecForEncoding(te, content);

QByteArray encoded;

{

QDataStream out(&encoded, QIODevice::WriteOnly);

static bool unicodeConvertingCharset(const QByteArray& charset)

{

// See if this is a unicode-capable codec

const QChar multiByteChar = static_cast<char16_t>(0x1234);

return textCodec->canEncode(multiByteChar);

qCWarning(lcMessaging) << "unicodeConvertingCharset: unable to find codec for charset:" << charset;

}

QByteArray charset;

// Find the charset for this data, if it is text data

charset = type.charset();

// If the codec can't handle multi-byte characters, don't extract to/from unicode

if (!unicodeConvertingCharset(charset))

charset = QByteArray();

bool QMailMessageBodyPrivate::toFile(const QString& file, QMailMessageBody::EncodingFormat format) const

{

QFile outFile(file);

qCWarning(lcMessaging) << "Unable to open for write:" << file;

return false;

}

te = QMailMessageBody::Binary;

QMailCodec* codec = codecForEncoding(te, _type);

bool result = false;

// Find the charset for this data, if it is text data

QDataStream* in = _bodyData.dataStream();

// Empty charset indicates no unicode encoding; encoded return data means binary streams

// We are dealing with binary data

QDataStream out(&outFile);

if (encodeOutput)

codec->encode(out, *in);

else

codec->decode(out, *in);

// We are dealing with unicode text data, which we want in unencoded form

QTextStream out(&outFile);

te = QMailMessageBody::Binary;

QMailCodec* codec = codecForEncoding(te, _type);

bool result = false;

QByteArray charset(extractionCharset(_type));

// This data must be unicode in the file

QTextStream* in = _bodyData.textStream();

codec->encode(out, *in, charset);

result = (in->status() == QTextStream::Ok);

delete in;

QDataStream* in = _bodyData.dataStream();

if (encodeOutput)

codec->encode(out, *in);

te = QMailMessageBody::Binary;

QMailCodec* codec = codecForEncoding(te, _type);

bool result = false;

QDataStream* in = _bodyData.dataStream();

defaultContentType(parent);

QByteArray contentType = headerField("Content-Type");

// Extract the stored parts from the supplied field

QMailMessageContentType type(contentType);

_multipartType = QMailMessagePartContainer::multipartTypeForName(type.content());

QByteArray contentType = headerField("Content-Type");

bool useDefault = contentType.isEmpty();

type = QMailMessageContentType(contentType);

useDefault = true;

// Sender's client might not know what type, but maybe we do. Try...

QByteArray contentDisposition = headerField("Content-Disposition");

QMailMessageContentDisposition disposition(contentDisposition);

QList<QMimeType> mimeTypes = QMimeDatabase().mimeTypesForFileName(QString::fromUtf8(disposition.filename()));

}

}

// Note that the default is 'message/rfc822' when the parent is 'multipart/digest'

QMailMessageContentType parentType = parent->contentType();

type.setType("message");

type.setSubType("rfc822");

updateHeaderField(type.id(), type.toString(false, false));

}

}

type.setType("text");

type.setSubType("plain");

type.setCharset("us-ascii");

if (_multipartType == QMailMessagePartContainer::MultipartNone) {

removeHeaderField("Content-Type");

QMailMessageContentType contentType = updateContentType(headerField("Content-Type"), _multipartType, _boundary);

foreach (const QMailMessageHeaderField::ParameterType& param, parameters)

contentType.setParameter(param.first, param.second);

_header.update(id, content);

setDirty();

// Extract the stored parts from the supplied field

QMailMessageContentType type(content);

_multipartType = QMailMessagePartContainer::multipartTypeForName(type.content());

_header.append( id, content );

setDirty();

// Extract the stored parts from the supplied field

QMailMessageContentType type(content);

_multipartType = QMailMessagePartContainer::multipartTypeForName(type.content());

_header.remove(id);

setDirty();

// Extract the stored parts from the supplied field

_multipartType = QMailMessagePartContainer::MultipartNone;

_boundary = QByteArray();

if (endPos == -1)

endPos = body.length() - 1;

// Skip the boundary line

startPos = body.indexOf(lineFeed, startPos);

if (startPos > 0 && body.mid(startPos - 1, 1).indexOf(QByteArray(1, QMailMessage::CarriageReturn)) != -1)

startPos--;

// Parse the section up to the next boundary marker

int nextPos = body.indexOf(partDelimiter, startPos);

*/

QByteArray QMailMessagePartContainer::nameForMultipartType(QMailMessagePartContainer::MultipartType type)

{

return "multipart/signed";

}

return QByteArray();

/*! \reimp */

QString QMailMessage::preview() const

{

const_cast<QMailMessage*>(this)->refreshPreview();

}

};

#endif

This type defines a single chunk in a sequence of partitioned output data.

*/

QMailMessageKeyPrivate(const ListType &valueList, QMailMessageKey::Property p, QMailKey::Comparator c) : Impl(valueList, p, c) {}

};

#endif

{

return d;

}

text += QLatin1String(", ...");

return text;

return qApp->translate("QMailMessageModelBase", "Draft message");

}

}

{

case Qt::DisplayRole:

case MessageAddressTextRole:

case MessageSizeTextRole:

return messageSizeText(message);

return message.subject();

case MessageFilterTextRole:

case MessageBodyTextRole:

{

#include "qmailmessagekey.h"

#include "qmailmessagesortkey.h"

class QMailMessageModelImplementation

{

public:

{

d->parentFolderId = parentFolderId;

}

*/

#include "qmailmessageserver.moc"

synchronizeChildren();

//update our folder name

i->_name.clear();

{

const ImplementationType *i = impl(this);

//update our account name

i->_name.clear();

update(this);

: QAbstractItemModel(parent),

QMailMessageSetContainer(new QMailMessageSetModelPrivate)

{

}

/*! \internal */

\sa messagesAdded(), messagesRemoved()

*/

QModelIndex parentIndex(QMailMessageSet *item, int column) const;

};

#endif

};

#endif

return QMailMessageSortKey(Status, order, mask);

}

Q_IMPLEMENT_USER_METATYPE(QMailMessageSortKey)

{

return d;

}

{

if (_pendingActions.count())

disconnectSubAction(_pendingActions.first().action);

// Don't delete QObject while it's emitting a signal

a.action->deleteLater();

}

#include <QDataStream>

template<typename PropertyType>

class QMailSortKeyArgument

{

};

#endif

Q_IMPLEMENT_USER_METATYPE_ENUM(QMailStore::MessageRemovalOption)

Q_IMPLEMENT_USER_METATYPE_ENUM(QMailStore::ChangeType)

QPair<QString, QString> uriElements;

foreach (QMailMessageKey::Property p, messagePropertyList()) {

case QMailMessageKey::Id:

metaData->setId(values.id());

break;

++highIt;

if (highIt == end) {

ascend = false;

if (!messageCache.contains(*highIt)) {

idBatch.append(*highIt);

++count;

++highIt;

if (highIt == end) {

ascend = false;

if (!threadCache.contains(*highIt)) {

idBatch.append(*highIt);

++count;

QMailMessageIdList ids;

messageCache.insert(metaData);

uidCache.insert(qMakePair(metaData.parentAccountId(), metaData.serverUid()), metaData.id());

{

Q_ASSERT(!ids.contains(QMailMessageId()));

if (messageCache.contains(id)) {

QMailMessageMetaData metaData = messageCache.lookup(id);

metaData.setCustomFields(data.customFields());

}

foreach (QMailMessageKey::Property p, messagePropertyList()) {

case QMailMessageKey::Id:

metaData.setId(data.id());

break;

{

Q_ASSERT(!ids.contains(QMailMessageId()));

if (messageCache.contains(id)) {

QMailMessageMetaData metaData = messageCache.lookup(id);

void clear();

private:

};

template <typename ID, typename T>

template <typename KeyType, typename T>

void QMailStorePrivate::Cache<KeyType, T>::insert(const KeyType& key, const T& item)

{

}

template <typename KeyType, typename T>

{

return false;

}

{

const MessageKeyArgumentExtractor extractor(a);

case QMailMessageKey::Id:

if (a.valueList.count() < IdLookupThreshold) {

values += extractor.id();

{

const AccountKeyArgumentExtractor extractor(a);

case QMailAccountKey::Id:

values += extractor.id();

break;

{

const FolderKeyArgumentExtractor extractor(a);

case QMailFolderKey::Id:

values += extractor.id();

break;

{

const ThreadKeyArgumentExtractor extractor(a);

case QMailThreadKey::Id:

values += extractor.id();

break;

QString operatorString(QMailKey::Comparator op, bool multipleArgs = false, bool patternMatch = false, bool bitwiseMultiples = false)

{

case Equal:

return QLatin1String(multipleArgs ? " IN " : (patternMatch ? " LIKE " : " = "));

QString combineOperatorString(QMailKey::Combiner op)

{

case And:

return QLatin1String(" AND ");

QString expression = columnExpression(columnName, a.op, a.valueList, patternMatching, bitwise, noCase);

case QMailAccountKey::Id:

if (a.valueList.first().canConvert<QMailAccountKey>()) {

QMailAccountKey subKey = a.valueList.first().value<QMailAccountKey>();

QString expression = columnExpression(columnName, a.op, a.valueList, patternMatching, bitwise, noCase);

case QMailMessageKey::Id:

if (a.valueList.count() >= IdLookupThreshold) {

q << baseExpression(columnName, a.op, true) << "( SELECT id FROM " << QMailStoreSql::temporaryTableName(a) << ")";

QString expression = columnExpression(columnName, a.op, a.valueList, false, bitwise, noCase);

case QMailFolderKey::Id:

if (a.valueList.first().canConvert<QMailFolderKey>()) {

QMailFolderKey subKey = a.valueList.first().value<QMailFolderKey>();

QString expression = columnExpression(columnName, a.op, a.valueList, false, false, noCase);

case QMailThreadKey::Id:

if (a.valueList.first().canConvert<QMailThreadKey>()) {

QMailThreadKey subKey = a.valueList.first().value<QMailThreadKey>();

const MessageRecord messageRecord(r, recordProperties);

foreach (QMailMessageKey::Property p, messagePropertyList()) {

case QMailMessageKey::Id:

metaData->setId(messageRecord.id());

break;

properties &= ~QMailMessageKey::ContentIdentifier;

foreach (QMailMessageKey::Property p, messagePropertyList()) {

case QMailMessageKey::Id:

values.append(extractor.id());

break;

QMailThreadKey::Properties properties(prop);

foreach (QMailThreadKey::Property p, threadPropertyList()) {

case QMailThreadKey::Id:

values.append(thread.id().toULongLong());

break;

qCDebug(lcMailStore) << Q_FUNC_INFO << "Time stamp for " << allMessageIds.count() << " will be updated ";

QMailMessageKey::Properties updateDateProperties = QMailMessageKey::TimeStamp | QMailMessageKey::ReceptionTimeStamp;

const QMailMessageMetaData m(updateId);

const MessageValueExtractor<QMailMessageMetaData> extractor(m);

QVariantList bindValues;

uriElements[extractUriElements(contentUri).first].append(extractUriElements(contentUri).second);

}

QStringList schemes(QStringList() << QMailContentManagerFactory::defaultFilterScheme()

<< it.key()

<< QMailContentManagerFactory::defaultIndexerScheme());

if (!scheme.isEmpty()) {

QMailContentManager *manager(QMailContentManagerFactory::create(scheme));

if (!manager)

foreach (const QString& contentUri, contentUris) {

uriElements[extractUriElements(contentUri).first].append(extractUriElements(contentUri).second);

QStringList schemes(QStringList() << QMailContentManagerFactory::defaultFilterScheme()

<< it.key()

<< QMailContentManagerFactory::defaultIndexerScheme());

if (!scheme.isEmpty()) {

QMailContentManager *manager(QMailContentManagerFactory::create(scheme));

if (!manager)

QList<QMailContentManager*> contentManagers;

<< QMailContentManagerFactory::defaultFilterScheme()

<< message->contentScheme()

<< QMailContentManagerFactory::defaultIndexerScheme())

}

QMailStore::ErrorCode code = manager->add(message, durability(commitOnSuccess));

if (code != QMailStore::NoError) {

setLastError(code);

AttemptResult result = attemptAddMessage(static_cast<QMailMessageMetaData*>(message), identifier, references, out, t, commitOnSuccess);

if (result != Success) {

bool obsoleted(false);

// Try to remove the content file we added

QMailStore::ErrorCode code = manager->remove(message->contentIdentifier());

if (code != QMailStore::NoError && !obsoleted) {

<< metaData->contentScheme()

<< QMailContentManagerFactory::defaultIndexerScheme());

if (!scheme.isEmpty()) {

if (QMailContentManager *contentManager = QMailContentManagerFactory::create(scheme)) {

QString contentUri(::contentUri(*metaData));

// Check NB#294937. Sometimes metaData contains 0 as a parentThreadId

// and that is really bad for a thread mode.

//Dirty hack to fix NB#297007, but at least it is better then nothing

QMailMessageMetaData data(metaData->id());

if (data.parentThreadId().isValid())

while (!bindMessagesIds.isEmpty()) {

bindMessagesIdsBatch.clear();

if (bindMessagesIds.count() > 500) {

bindMessagesIds = bindMessagesIds.mid(500);

} else {

QMap<quint64, quint64> predecessor;

{

// Find the predecessor message for every message in the same thread as us or the thread of any potential predecessor of us

QVariantList vl;

vl << messageId;

vl << p;

}

QSqlQuery query(simpleQuery(QString::fromLatin1("SELECT id,responseid FROM mailmessages WHERE parentaccountid = %1 AND parentthreadid IN (SELECT parentthreadid FROM mailmessages WHERE id IN %2)")

//if the parent is valid, check that it exists

//if the account is valid, check that is exists

qCWarning(lcMailStore) << "Folder exists, use update instead of add.";

return false;

}

qCWarning(lcMailStore) << "Folder does not exist, use add instead of update.";

return false;

}

qCWarning(lcMailStore) << "A folder cannot be a child to itself";

return false;

}

}

qCWarning(lcMailStore) << "Parent folder does not exist!";

return false;

}

}

if ((withAccountTables

? !idExists(folder.parentAccountId())

qCWarning(lcMailStore) << "Parent account does not exist!";

return false;

}

{

QVariantList bindValues;

QVariantList bindValuesBatch;

bindValues << threadId.toULongLong();

}

}

}

// if all thread's messages were deleted we should delete thread as well.

if (!existedMessagesMap.keys().contains(threadId)) {

deletedThreads.append(threadId);

quint64 status = 0;

QStringList senders;

const QMailMessageMetaDataList &threadsMessagesList = existedMessagesMap.value(threadId);

// Messages moved to Draft or Trash folder should not being counted.

QMailAccount account(data.parentAccountId());

QMailFolderId trashFolderId = account.standardFolder(QMailFolder::TrashFolder);

}

Q_ASSERT(messageIdList.size() == newResponseIdList.size());

// Link any descendants of the messages to the deleted messages' predecessor

QSqlQuery query(batchQuery(QLatin1String("UPDATE mailmessages SET responseid=? WHERE id=?"),

QVariantList() << QVariant(newResponseIdList) << QVariant(messageIdList),

d->lastDate = value;

}

QMailTimeStamp QMailThread::startedDate() const

{

return d->startedDate;

d->startedDate = value;

}

quint64 QMailThread::status() const

{

return d->status;

quint64 status;

};

#endif // QMAILTHREAD_P_H

using namespace QMailKey;

Q_IMPLEMENT_USER_METATYPE(QMailThreadKey)

/*!

\class QMailThreadKey

QMailThreadKeyPrivate(const ListType &valueList, QMailThreadKey::Property p, QMailKey::Comparator c) : Impl(valueList, p, c) {}

};

#endif

};

LessThanFunctorT::LessThanFunctorT(const QMailThreadSortKey& sortKey)

{

}

QMailThreadKey secondKey(QMailThreadKey::id(second));

QMailThreadIdList results = QMailStore::instance()->queryThreads(firstKey | secondKey, mSortKey);

mInvalidatedList = true;

return false;

}

void QMailThreadListModelPrivate::initialize() const

{

init = true;

needSynchronize = false;

}

QMailThreadListModel::QMailThreadListModel(QObject* parent)

:

QAbstractListModel(parent),

{

connect(QMailStore::instance(),

SIGNAL(threadsAdded(QMailThreadIdList)),

QMailThread thread(id);

case Qt::DisplayRole:

return thread.subject();

case ThreadIdRole:

if (results.isEmpty())

return;

LessThanFunctorT lessThan(d->sortKey);

//if sorting the list fails, then resort to a complete refresh

fullRefresh();

QMailThreadIdList::iterator itr = d->lowerBound(id, lessThan);

int newIndex = (itr - d->idList.begin());

d->idList.insert(itr, id);

endInsertRows();

}

}

int index = d->idList.count();

d->idList.append(id);

endInsertRows();

}

QMailThreadIdList validIds = QMailStore::instance()->queryThreads(idKey & d->key);

//if the key is empty the id's will be returned valid and invalid

QMailThreadIdList invalidIds = QMailStore::instance()->queryThreads(idKey & ~d->key);

//get the index

int index = d->idList.indexOf(id);

if (index == -1)

continue;

d->deletionId = id;

d->idList.removeAt(index);

endRemoveRows();

d->deletionId = QMailThreadId();

LessThanFunctorT lessThan(d->sortKey);

int index = d->idList.indexOf(id);

fullRefresh();

QMailThreadIdList::iterator itr = d->lowerBound(id, lessThan);

int newIndex = (itr - d->idList.begin());

d->idList.insert(itr, id);

endInsertRows();

}

fullRefresh();

QMailThreadIdList::iterator itr = d->lowerBound(id, lessThan);

int newIndex = (itr - d->idList.begin());

// This item would be inserted either immediately before or after itself

d->deletionId = id;

d->idList.removeAt(index);

endRemoveRows();

d->deletionId = QMailThreadId();

if (newIndex > index)

--newIndex;

d->idList.insert(newIndex, id);

endInsertRows();

}

if (!d->init)

d->initialize();

int index = d->indexOf(id);

if (index == -1)

continue;

d->deletionId = id;

d->idList.removeAt(index);

endRemoveRows();

d->deletionId = QMailThreadId();

//if the id does not exist return null

int index = d->indexOf(id);

if (index != -1) {

}

return QModelIndex();

endResetModel();

emit modelChanged();

}

return QMailThreadSortKey(Status, order, mask);

}

Q_IMPLEMENT_USER_METATYPE(QMailThreadSortKey)

{

return d->operator>=(*other.d);

}

}

#endif // QMF_QMFLIST_H

if (ref_count.deref() == 0 && delete_function && self) {

(*delete_function)(self);

return true;

return false;

}

}

// ksc5601.1987-0 cp949 Big5-HKSCS big5-0 big5hkscs-0

QStringList availableCodecsQt;

availableCodecsQt << QString::fromLatin1(ba);

// Charsets detectable by libicu 4.4.2:

uenum_close(en);

// remove all charsets not supported by QTextCodec and all duplicates:

if (availableCodecsQt.contains(cs) && !d->_allDetectableCharsets.contains(cs))

d->_allDetectableCharsets << cs;

}

Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(TYPE)

#endif //QMAILIPC_H

{

QList<StandardFolderInfo> standardFoldersList;

if (!folderTranslations.empty()) {

standardFoldersList << StandardFolderInfo(QLatin1String("\\Inbox"), QMailFolder::Incoming, QMailFolder::InboxFolder, QMailMessage::Incoming, folderTranslations.value("inbox"))

if (folderId.isValid()) {

qCDebug(lcMailStore) << "Setting folder: " << QMailFolder(folderId).displayName();

QMailFolder folder(folderId);

account.setStandardFolder(standardFolder, folderId);

if (!QMailStore::instance()->updateAccount(&account)) {

qCWarning(lcMailStore) << "Unable to update account" << account.id() << "to set standard folder" << QMailFolder(folderId).displayName();

// If a string has double-quote as the first and last characters, return the string

// between those characters

int length = src.length();

typename StringType::const_iterator const begin = src.constData();

typename StringType::const_iterator const last = begin + length - 1;

// Return the input string surrounded by double-quotes, which are added if not present

int length = src.length();

result.reserve(length + 2);

typename StringType::const_iterator begin = src.constData();

~QMailPluginManagerPrivate();

public:

};

QMailPluginManagerPrivate::QMailPluginManagerPrivate(const QString& path)

QStringList coreLibraryPaths = QCoreApplication::libraryPaths();

libraryPaths.append(coreLibraryPaths);

QDir dir(libraryPath);

//Change into the sub directory, and make sure it's readable

if (!dir.cd(path) || !dir.isReadable())

continue;

QString libfile = dir.absoluteFilePath(libname);

if (pluginMap.contains(libname))

pluginMap[libname]->setFileName(libfile);

{

public:

LongStream();

void reset();

QString detach();

void append(QString str);

void resetStatus();

void setStatus( Status );

void updateStatus();

static QString outOfSpaceMessage();

static void cleanupTempFiles();

};

#endif

messageFlush();

}

return d->waitingForFlush.size();

}

return 1024*900;

}

if (messagePending() >= d->maxPending) {

return true;

}

}

}

}

return false;

}

reservedPushConnections -= connections;

}

}

_config->setValue(name, value);

}

}

QMailAccountConfiguration::ServiceConfiguration *_config;

};

#endif

*/

#include <qmailstoreaccountfilter.moc>

#include <qmailglobal.h>

#include <qmailstore.h>

class QMailStoreAccountFilterPrivate;

class QMailStoreEvents;

*/

void QMailTransport::open(const QString& url, int port, EncryptType encryptionType)

{

qCWarning(lcMessaging) << "Failed to open connection - already open!";

return;

}

This signal is emitted when a change in status is reported. The new status is described by \a status.

*/

#include "qmailtransport.moc"

QSize FolderDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const

{

// Ensure that we use the full width for our item

return QSize(qMax(base.width(), option.rect.width()), base.height());

}

if (topLeft == currentIndex() || bottomRight == currentIndex())

emit selectionUpdated();

}

namespace {

#include <qmaillog.h>

#include <QMap>

static QIcon loadIcon(const char *themeIdentifier, const char *resourceFallback)

{

m_okButton = new QPushButton(QLatin1String("Ok"), this);

buttonsLayout->addWidget(m_okButton);

QPushButton* cancelButton = new QPushButton(QLatin1String("Cancel"), this);

buttonsLayout->addWidget(cancelButton);

top->addLayout(buttonsLayout,1,0);

}

if (durability == QMailContentManager::NoDurability)

return true; // Don't sync parts, they should be sync'd later

syncLater(part);

}

};

#endif

Q_D(const IdleNetworkSession);

return d->error();

}

{

return QMailAuthenticator::getResponse(svcCfg, challenge, credentials);

}

};

#endif

mail = new QMailMessage(uid, _accountId);

}

if (mail->id().isValid()) {

if (section.isEmpty()) {

mail = new QMailMessage(uid, _accountId);

}

if (mail->id().isValid() && !section.isEmpty()) {

// This is data for a sub-part of the message

QMailFolderIdList folderIds;

if (!imapCfg.pushEnabled())

return folderIds;

QMailFolderId idleFolderId(mailboxId(folderName));

if (idleFolderId.isValid()) {

folderIds.append(idleFolderId);

_idleTimer.stop();

}

if (!mailboxIds.contains(id)) {

qCDebug(lcIMAP) << "stop monitoring folder" << id;

IdleProtocol *protocol = _monitored.take(id);

return;

}

if (!_monitored.contains(id)) {

qCDebug(lcIMAP) << "start monitoring folder" << id;

++count;

QVector<QMailMessage*> _bufferedMessages;

int _pushConnectionsReserved;

QMailCredentialsInterface *_credentials;

};

flags = token(str, '(', ')', &index);

delimiter = token(str, ' ', ' ', &index);

if (delimiter == "NIL") {

c->protocol()->setFlatHierarchy(true);

} else {

FetchParameters &fp(mParameters[mCurrentIndex]);

IntegerRegion missingUids = fp.mExpectedMessages.subtract(fp.mReceivedMessages);

qCWarning(lcIMAP) << "Message not found " << uid;

emit nonexistentUid(messageUid(c->mailbox().id, uid));

}

void ImapProtocol::sendCreate(const QMailFolderId &parentFolderId, const QString &name)

{

QString mailboxPath;

if (delimiterUnknown()) {

sendDiscoverDelimiter();

}

bool pendingDisconnectedOperations = false;

_service->_client->strategyContext()->moveMessagesStrategy.clearSelection();

if (!folderId.isValid())

continue;

_actionQueue.append(new ExportUpdatesCommand(_service->accountId())); // Convenient for user to export pending changes also

QMailFolderIdList ids(_service->_client->configurationIdleFolderIds());

if (ids.count()) {

// Check for flag changes and new mail

_service->_source->queueFlagsChangedCheck(id);

}

_establishingPushEmail = true;

setPersistentConnectionStatus(true);

// Check for flag changes and new mail

_source->queueFlagsChangedCheck(id);

}

// Fail after 10 sec if no network reply is received

_networkSessionTimer->setSingleShot(true);

_networkSessionTimer->setInterval(10000);

openIdleSession();

}

QMailMessageServiceConfigurator *createServiceConfigurator() override;

};

#endif

void PushFolderList::setHasFolders(bool hasFolders)

{

_hasFolders = hasFolders;

widget->setEnabled(_hasFolders && _pushEnabled);

}

void PushFolderList::setPushEnabled(int pushEnabled)

{

_pushEnabled = (pushEnabled != Qt::Unchecked);

widget->setEnabled(_hasFolders && _pushEnabled);

}

void PushFolderList::populate(const QStringList &pushFolderNames)

{

_items = 0;

_parentLayout->removeWidget(widget);

delete widget;

}

_parentLayout->removeItem(layout);

delete layout;

}

_dirButtons.clear();

QStringList folderNames(pushFolderNames);

folderNames.append("");

addRow(s);

}

}

QStringList PushFolderList::folderNames()

{

QStringList result;

if (!edit->text().isEmpty())

result.append(edit->text());

}

}

#include "imapsettings.moc"

};

#endif

QStringList stripFolderPrefix(const QStringList &list)

{

QStringList result;

result.append(stripFolderPrefix(uid));

}

return result;

{

bool result(true);

QStringList vanishedIds;

const QString &uid(r.serverUid());

// We might have a deletion record for this UID

vanishedIds << uid;

qCWarning(lcMailStore) << "Unable to update un-removed message metadata for account:" << context->accountId();

}

const QString &uid(r.serverUid());

// We might have a deletion record for this UID

if (!QMailStore::instance()->purgeMessageRemovalRecords(context->accountId(), QStringList() << uid)) {

QSet<QMailFolderId> & included = isNegated ? r.second : r.first;

QSet<QMailFolderId> & excluded = isNegated ? r.first : r.second;

case QMailMessageKey::ParentFolderId:

if (arg.op == QMailKey::Equal || arg.op == QMailKey::Includes) {

Q_ASSERT(arg.valueList.count() == 1);

QMailMessageBuffer::instance()->flush();

// Update the status on any folders we modified

QMailFolder folder(*it);

_client->updateFolderCountStatus(&folder);

if (op != OpOk)

qCWarning(lcIMAP) << "IMAP Response to cmd:" << cmd << " is not ok: " << op;

case IMAP_Login:

handleLogin(context);

break;

if (op != OpOk)

qCWarning(lcIMAP) << "IMAP Response to cmd:" << cmd << " is not ok: " << op;

case IMAP_Login:

handleLogin(context);

break;

QMailFolderKey childKey(QMailFolderKey::parentFolderId(folderId));

QMailFolderIdList childrenList = QMailStore::instance()->queryFolders(childKey);

deleteFolder(fid, context);

}

if (op != OpOk)

qCWarning(lcIMAP) << "IMAP Response to cmd:" << cmd << " is not ok: " << op;

case IMAP_Login:

handleLogin(context);

break;

if (op != OpOk)

qCWarning(lcIMAP) << "IMAP Response to cmd:" << cmd << " is not ok: " << op;

case IMAP_Login:

handleLogin(context);

break;

void ImapPrepareMessagesStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus)

{

}

}

void ImapMessageListStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus)

{

}

}

{

QMailAccountConfiguration accountCfg(context->accountId());

ImapConfiguration imapCfg(accountCfg);

switch (spec) {

case QMailRetrievalAction::Auto:

}

break;

case QMailRetrievalAction::Content:

void ImapFetchSelectedMessagesStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

return;

}

QMailMessageIdList ids(QMailStore::instance()->queryMessages(QMailMessageKey::serverUid(uidString) & QMailMessageKey::parentAccountId(context->accountId())));

Q_ASSERT(ids.size() == 1 || ids.size() == 0);

if (ids.size())

void ImapFolderListStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

if (!_newUids.isEmpty() || _outstandingPreviews) {

while (!_newUids.isEmpty()) {

QStringList uidList;

uidList << ImapProtocol::uid(s);

}

void ImapSynchronizeAllStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

{

const ImapMailboxProperties &properties(context->mailbox());

case Seen:

_seenUids = properties.uidList;

// The Unseen search command was pipelined

_searchState = Unseen;

context->protocol().sendUidSearch(MFlag_Unseen);

break;

case Unseen:

_unseenUids = properties.uidList;

// The Flagged search command was pipelined

_searchState = Flagged;

context->protocol().sendUidSearch(MFlag_Flagged);

break;

case Flagged:

_flaggedUids = properties.uidList;

if (static_cast<quint32>((_unseenUids.count() + _seenUids.count())) == properties.exists) {

// We have a consistent set of search results

context->protocol().sendUidSearch(MFlag_All);

}

break;

case All:

_unseenUids = properties.uidList;

if (static_cast<quint32>(_unseenUids.count()) != properties.exists) {

qCWarning(lcIMAP) << "Inconsistent UID SEARCH result";

processUidSearchResults(context);

break;

default:

qCWarning(lcIMAP) << "Unknown search status in transition";

}

if (!_readUids.isEmpty()) {

QStringList msgUidl = _readUids.mid(0, batchSize);

QString msg = QObject::tr("Marking message as read");

_readUids.removeAll(uid);

_storedReadUids.append(uid);

}

if (!_unreadUids.isEmpty()) {

QStringList msgUidl = _unreadUids.mid(0, batchSize);

QString msg = QObject::tr("Marking message as unread");

_unreadUids.removeAll(uid);

_storedUnreadUids.append(uid);

}

if (!_importantUids.isEmpty()) {

QStringList msgUidl = _importantUids.mid(0, batchSize);

QString msg = QObject::tr("Marking message as important");

_importantUids.removeAll(uid);

_storedImportantUids.append(uid);

}

if (!_unimportantUids.isEmpty()) {

QStringList msgUidl = _unimportantUids.mid(0, batchSize);

QString msg = QObject::tr("Marking message as unimportant");

_unimportantUids.removeAll(uid);

_storedUnimportantUids.append(uid);

}

if (!_removedUids.isEmpty()) {

QStringList msgUidl = _removedUids.mid(0, batchSize);

QString msg = QObject::tr("Deleting message");

_removedUids.removeAll(uid);

_storedRemovedUids.append(uid);

}

void ImapUpdateMessagesFlagsStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

{

const ImapMailboxProperties &properties(context->mailbox());

case Unseen:

_unseenUids = properties.uidList;

_searchState = Seen;

context->protocol().sendUidSearch(MFlag_Seen, "UID " + _filter);

break;

case Seen:

_seenUids = properties.uidList;

_searchState = Flagged;

context->protocol().sendUidSearch(MFlag_Flagged, "UID " + _filter);

break;

case Flagged:

_flaggedUids = properties.uidList;

processUidSearchResults(context);

break;

default:

qCWarning(lcIMAP) << "Unknown search status in transition";

Q_ASSERT(0);

void ImapRetrieveMessageListStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

return;

QStringList uidList;

uidList.append(QString::number(folderId.toULongLong()) + UID_SEPARATOR + uid);

}

QMailMessageKey uidKey(QMailMessageKey::serverUid(uidList) & QMailMessageKey::status(flag, set ? QMailDataComparator::Excludes : QMailDataComparator::Includes));

IntegerRegion undeleted;

IntegerRegion replied;

IntegerRegion forwarded;

bool ok;

QString uidStr(stripFolderPrefix(change.first));

MessageFlags flags(change.second);

// The set of messages to fetch needs to be adjusted based on the number of such messages

IntegerRegion rawServerRegion;

processFlagChanges(properties.flagChanges, properties.id, &_error);

bool ok;

uint number = stripFolderPrefix(uid).toUInt(&ok);

if (ok)

}

QStringList removedList;

removedList.append(QString::number(folder.id().toULongLong()) + UID_SEPARATOR + uid);

}

IntegerRegion clientRegionWithinServerRange(serverRange.intersect(trueClientRegion));

IntegerRegion clientRemovedRegion(clientRegionWithinServerRange.subtract(rawServerRegion).toStringList());

QStringList removed;

removed.append(QString::number(folder.id().toULongLong()) + UID_SEPARATOR + uid);

}

{

// Add the listed uids to the retrieve list

const ImapMailboxProperties &properties(context->mailbox());

bool ok;

uint number = stripFolderPrefix(uid).toUInt(&ok);

if (ok) {

IntegerRegion vanishedOnClient(vanished.intersect(IntegerRegion(clientMin, INT_MAX)));

_qresyncVanished = vanishedOnClient.cardinality();

QStringList removedList;

removedList.append(QString::number(folder.id().toULongLong()) + UID_SEPARATOR + uid);

}

if (!removedList.isEmpty()) {

void ImapCopyMessagesStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

void ImapMoveMessagesStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

void ImapExternalizeMessagesStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

void ImapFlagMessagesStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

void ImapDeleteMessagesStrategy::transition(ImapStrategyContextBase *context, ImapCommand command, OperationStatus status)

{

}

}

_strategy(0)

{

}

TransferState _transferState;

QString _baseFolder;

bool _error;

};

class ImapCreateFolderStrategy : public ImapStrategy

QStringList _createdUids;

int _messagesAdded;

QStringList _obsoleteDestinationUids;

};

class ImapMoveMessagesStrategy : public ImapCopyMessagesStrategy

return QStringList();

}

{

// Performance note currently O(n^2), n = uids.count()

// TODO: sort uids if they are not already sorted

bool ok(false);

uint number = uid.toUInt(&ok);

if (ok)

// Performance note currently O(n^2), n = uids.count()

// TODO: sort uids in uidString if they are not already sorted

QStringList rangeList = uidString.split(",", Qt::SkipEmptyParts);

bool ok = false;

int index = s.indexOf(":");

if (index == -1) {

{

uint result(0);

result += range.second - range.first + 1;

return result;

QStringList IntegerRegion::toStringList() const

{

QStringList result;

result += QString::number(range.first);

for (int i = range.first + 1; i <= range.second; ++i)

result += QString::number(i);

{

QString result;

bool first(true);

if (!first)

result += ",";

result += QString::number(range.first);

*/

bool IntegerRegion::isIntegerRegion(QStringList uids)

{

bool ok(false);

uid.toUInt(&ok);

if (!ok)

{

QString result;

int last(0);

bool ok;

int value = s.toInt(&ok);

for (int i = last; i < value; ++i)

{

return QMailAuthenticator::getResponse(svcCfg, challenge, credentials);

}

};

#endif

if (msgNum != -1) {

if (!selected) {

if (messageCount == 1) {

}

if (lastStatusTimer.elapsed() > 1000) {

lastStatusTimer.start();

{

setValue("intervalCheckRoamingEnabled", QString::number(b ? 1 : 0));

}

Source *_source;

};

class PopServicePlugin : public QMailMessageServicePlugin

{

Q_OBJECT

QMailMessageServiceConfigurator *createServiceConfigurator() override;

};

#endif

return true;

}

};

#endif

};

#endif

if (responseCode == 220) {

// Switch into encrypted mode

transport->switchToEncrypted();

operationFailed(QMailServiceAction::Status::ErrUnknownResponse, response);

}

break;

sendCommand("RCPT TO:<" + *it + ">");

status = MRcv;

}

operationFailed(QMailServiceAction::Status::ErrUnknownResponse, response);

}

break;

void SmtpClient::stopTransferring()

{

if (transport->isEncrypted())

disconnect(&(transport->socket()), SIGNAL(encryptedBytesWritten(qint64)), this, SLOT(sendMoreData(qint64)));

else

void SmtpConfigurationEditor::setUserName(const QString& str)

{

}

void SmtpConfigurationEditor::setEmailAddress(const QString &str)

}

#include "smtpservice.moc"

QMailMessageServiceConfigurator *createServiceConfigurator() override;

};

#endif

connect(setSignatureButton, SIGNAL(clicked()), this, SLOT(sigPressed()));

connect(authentication, SIGNAL(currentIndexChanged(int)), this, SLOT(authChanged(int)));

connect(emailInput, SIGNAL(textChanged(QString)), this, SLOT(emailModified()));

const QString uncapitalised("email noautocapitalization");

return true;

}

#include "smtpsettings.moc"

};

#endif

return exitCode;

}

if (it.value() != messageCounts[type]) {

// This type's count has changed since last reported

actionType[action] = type;

connect(action, SIGNAL(response(bool)), this, SLOT(response(bool)));

//stub for alternate handling, currently does nothing

NewCountNotifier::NewCountNotifier(QMailMessage::MessageType, int)

{

}

void NewCountNotifier::notify(QMailMessage::MessageType, int)

{

}

void prepareAccounts()

{

}