FCL/sf/mw/qtmobility: comparison src/messaging/winhelpers.cpp

equal deleted inserted replaced

--1:000000000000
+:876b1a06bc25
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef _UNICODE
+#define _UNICODE
+#endif
+#ifndef MDB_ONLINE
+#define MDB_ONLINE ((ULONG) 0x00000100)
+#endif
+#ifndef DELETE_HARD_DELETE
+#define DELETE_HARD_DELETE ((ULONG) 0x00000010)
+#endif
+#ifndef STORE_HTML_OK
+#define STORE_HTML_OK ((ULONG)0x00010000)
+#endif
+#ifndef PR_IS_NEWSGROUP
+#define PR_IS_NEWSGROUP PROP_TAG( PT_BOOLEAN, 0x6697 )
+#endif
+#ifndef PR_IS_NEWSGROUP_ANCHOR
+#define PR_IS_NEWSGROUP_ANCHOR PROP_TAG( PT_BOOLEAN, 0x6696 )
+#endif
+#ifndef PR_EXTENDED_FOLDER_FLAGS
+#define PR_EXTENDED_FOLDER_FLAGS PROP_TAG( PT_BINARY, 0x36DA )
+#endif
+#include "winhelpers_p.h"
+#include "qmessageid_p.h"
+#include "qmessagefolderid_p.h"
+#include "qmessageaccountid_p.h"
+#include "qmessage_p.h"
+#include "qmessagecontentcontainer_p.h"
+#include "qmessagefilter_p.h"
+#include "qmessagesortorder_p.h"
+#include "qmessagefolder_p.h"
+#include "qmessagefolderfilter_p.h"
+#include "qmessagefoldersortorder_p.h"
+#include "qmessageaccount_p.h"
+#include "qmessageaccountfilter_p.h"
+#include "qmessageaccountsortorder_p.h"
+#include "qmessagestore_p.h"
+#include "messagingutil_p.h"
+#include <QCoreApplication>
+#include <QDebug>
+#include <QFile>
+#include <QTextCodec>
+#include <QThreadStorage>
+#include <QTimer>
+#include <QMutexLocker>
+#include <shlwapi.h>
+#include <shlguid.h>
+#include <tchar.h>
+#ifdef _WIN32_WCE
+#include "win32wce/qmailmessage.h"
+#include <cemapi.h>
+#endif
+//unexported before Windows 7, include manually
+#ifndef IID_PPV_ARGS
+extern "C++"
+{
+template<typename T> void** IID_PPV_ARGS_Helper(T** pp)
+{
+// make sure everyone derives from IUnknown
+static_cast<IUnknown*>(*pp);
+return reinterpret_cast<void**>(pp);
+}
+}
+#define IID_PPV_ARGS(ppType) __uuidof(**(ppType)), IID_PPV_ARGS_Helper(ppType)
+#endif //IID_PPV_ARGSA
+QTM_BEGIN_NAMESPACE
+namespace WinHelpers
+{
+bool setMapiProperty(IMAPIProp *object, ULONG tag, const QString &value)
+{
+SPropValue prop = { 0 };
+prop.ulPropTag = tag;
+prop.Value.LPSZ = reinterpret_cast<LPWSTR>(const_cast<quint16*>(value.utf16()));
+return HR_SUCCEEDED(HrSetOneProp(object, &prop));
+}
+bool setMapiProperty(IMAPIProp *object, ULONG tag, LONG value)
+{
+SPropValue prop = { 0 };
+prop.ulPropTag = tag;
+prop.Value.l = value;
+return HR_SUCCEEDED(HrSetOneProp(object, &prop));
+}
+bool setMapiProperty(IMAPIProp *object, ULONG tag, ULONG value)
+{
+SPropValue prop = { 0 };
+prop.ulPropTag = tag;
+prop.Value.ul = value;
+return HR_SUCCEEDED(HrSetOneProp(object, &prop));
+}
+bool setMapiProperty(IMAPIProp *object, ULONG tag, bool value)
+{
+SPropValue prop = { 0 };
+prop.ulPropTag = tag;
+prop.Value.b = value;
+return HR_SUCCEEDED(HrSetOneProp(object, &prop));
+}
+bool setMapiProperty(IMAPIProp *object, ULONG tag, FILETIME value)
+{
+SPropValue prop = { 0 };
+prop.ulPropTag = tag;
+prop.Value.ft = value;
+return HR_SUCCEEDED(HrSetOneProp(object, &prop));
+}
+bool setMapiProperty(IMAPIProp *object, ULONG tag, MapiEntryId value)
+{
+SBinary s;
+s.cb = value.count();
+s.lpb = reinterpret_cast<LPBYTE>(value.data());
+SPropValue prop = { 0 };
+prop.ulPropTag = tag;
+prop.Value.bin = s;
+return HR_SUCCEEDED(HrSetOneProp(object, &prop));
+}
+bool getMapiProperty(IMAPIProp *object, ULONG tag, ULONG *value)
+{
+bool result(false);
+SPropValue *prop;
+HRESULT rv = HrGetOneProp(object, tag, &prop);
+if (HR_SUCCEEDED(rv)) {
+if (prop->ulPropTag == tag) {
+*value = prop->Value.ul;
+result = true;
+}
+MAPIFreeBuffer(prop);
+}
+return result;
+}
+bool getMapiProperty(IMAPIProp *object, ULONG tag, LONG *value)
+{
+bool result(false);
+SPropValue *prop;
+HRESULT rv = HrGetOneProp(object, tag, &prop);
+if (HR_SUCCEEDED(rv)) {
+if (prop->ulPropTag == tag) {
+*value = prop->Value.l;
+result = true;
+}
+MAPIFreeBuffer(prop);
+}
+return result;
+}
+bool getMapiProperty(IMAPIProp *object, ULONG tag, QByteArray *value)
+{
+bool result(false);
+SPropValue *prop;
+HRESULT rv = HrGetOneProp(object, tag, &prop);
+if (HR_SUCCEEDED(rv)) {
+if (prop->ulPropTag == tag) {
+*value = QByteArray(reinterpret_cast<const char*>(prop->Value.bin.lpb), prop->Value.bin.cb);
+result = true;
+}
+MAPIFreeBuffer(prop);
+}
+return result;
+}
+bool getMapiProperty(IMAPIProp *object, ULONG tag, QString *value)
+{
+bool result(false);
+SPropValue *prop;
+HRESULT rv = HrGetOneProp(object, tag, &prop);
+if (HR_SUCCEEDED(rv)) {
+if (prop->ulPropTag == tag) {
+*value = QStringFromLpctstr(prop->Value.lpszW);
+result = true;
+}
+MAPIFreeBuffer(prop);
+}
+return result;
+}
+}
+using namespace WinHelpers;
+namespace {
+typedef QWeakPointer<WinHelpers::MapiInitializer> InitRecord;
+typedef InitRecord *InitRecordPtr;
+QThreadStorage<InitRecordPtr> initializer;
+GUID GuidPublicStrings = { 0x00020329, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 };
+FILETIME toFileTime(const QDateTime &dt)
+{
+FILETIME ft = {0};
+QDate date(dt.date());
+QTime time(dt.time());
+SYSTEMTIME st = {0};
+st.wYear = date.year();
+st.wMonth = date.month();
+st.wDay = date.day();
+st.wHour = time.hour();
+st.wMinute = time.minute();
+st.wSecond = time.second();
+st.wMilliseconds = time.msec();
+SystemTimeToFileTime(&st, &ft);
+return ft;
+}
+QDateTime fromFileTime(const FILETIME &ft)
+{
+SYSTEMTIME st = {0};
+FileTimeToSystemTime(&ft, &st);
+QString dateStr(QString("yyyy%1M%2d%3h%4m%5s%6z%7").arg(st.wYear).arg(st.wMonth).arg(st.wDay).arg(st.wHour).arg(st.wMinute).arg(st.wSecond).arg(st.wMilliseconds));
+QDateTime dt(QDateTime::fromString(dateStr, "'yyyy'yyyy'M'M'd'd'h'h'm'm's's'z'z"));
+dt.setTimeSpec(Qt::UTC);
+return dt;
+}
+struct AccountFilterPredicate
+{
+const QMessageAccountFilter &_filter;
+AccountFilterPredicate(const QMessageAccountFilter &filter) : _filter(filter) {}
+bool operator()(const MapiStorePtr &store) const
+{
+return QMessageAccountFilterPrivate::matchesStore(_filter, store);
+}
+};
+//used in preference to HrQueryAllRows
+//as per: http://blogs.msdn.com/stephen_griffin/archive/2009/03/23/try-not-to-query-all-rows.aspx
+class QueryAllRows
+{
+static const int BatchSize = 20;
+public:
+QueryAllRows(LPMAPITABLE ptable,
+LPSPropTagArray ptaga,
+LPSRestriction pres,
+LPSSortOrderSet psos,
+bool setPosition = true);
+~QueryAllRows();
+LONG rowCount();
+bool query();
+LPSRowSet rows() const;
+QMessageManager::Error error() const;
+private:
+LPMAPITABLE m_table;
+LPSPropTagArray m_tagArray;
+LPSRestriction m_restriction;
+LPSSortOrderSet m_sortOrderSet;
+LPSRowSet m_rows;
+QMessageManager::Error m_error;
+};
+QueryAllRows::QueryAllRows(LPMAPITABLE ptable,
+LPSPropTagArray ptaga,
+LPSRestriction pres,
+LPSSortOrderSet psos,
+bool setPosition)
+:
+m_table(ptable),
+m_tagArray(ptaga),
+m_restriction(pres),
+m_sortOrderSet(psos),
+m_rows(0),
+m_error(QMessageManager::NoError)
+{
+bool initFailed = false;
+#ifndef _WIN32_WCE
+unsigned long flags = TBL_BATCH;
+#else
+unsigned long flags = 0;
+#endif
+if(m_tagArray)
+initFailed |= FAILED(m_table->SetColumns(m_tagArray, flags));
+if(m_restriction)
+initFailed |= FAILED(m_table->Restrict(m_restriction, flags));
+if(m_sortOrderSet)
+initFailed |= FAILED(m_table->SortTable(m_sortOrderSet, flags));
+if(setPosition) {
+if(initFailed |= FAILED(m_table->SeekRow(BOOKMARK_BEGINNING,0, NULL)))
+qWarning() << "SeekRow function failed. Ensure it's not being called on hierarchy tables or message stores tables";
+}
+if(initFailed)
+m_error = QMessageManager::ContentInaccessible;
+}
+QueryAllRows::~QueryAllRows()
+{
+FreeProws(m_rows);
+m_rows = 0;
+}
+LONG QueryAllRows::rowCount()
+{
+if (m_error != QMessageManager::NoError)
+return -1;
+ULONG count(0);
+HRESULT rv = m_table->GetRowCount(0, &count);
+if (HR_FAILED(rv)) {
+m_error = QMessageManager::ContentInaccessible;
+return -1;
+}
+return count;
+}
+bool QueryAllRows::query()
+{
+if (m_error != QMessageManager::NoError)
+return false;
+FreeProws(m_rows);
+m_rows = 0;
+m_error = QMessageManager::NoError;
+HRESULT rv = m_table->QueryRows( QueryAllRows::BatchSize, NULL, &m_rows);
+if (HR_FAILED(rv)) {
+m_error = QMessageManager::ContentInaccessible;
+return false;
+}
+return (m_rows && m_rows->cRows);
+}
+LPSRowSet QueryAllRows::rows() const
+{
+return m_rows;
+}
+QMessageManager::Error QueryAllRows::error() const
+{
+return m_error;
+}
+ADRLIST *createAddressList(int count, int propertyCount)
+{
+ADRLIST *list(0);
+uint size = CbNewADRLIST(count);
+MAPIAllocateBuffer(size, reinterpret_cast<LPVOID*>(&list));
+if (list) {
+memset(list, 0, size);
+list->cEntries = count;
+for (int i = 0; i < count; ++i) {
+list->aEntries[i].cValues = propertyCount;
+MAPIAllocateBuffer(propertyCount * sizeof(SPropValue), reinterpret_cast<LPVOID*>(&list->aEntries[i].rgPropVals));
+}
+}
+return list;
+}
+void fillAddressEntry(ADRENTRY &entry, const QMessageAddress &addr, LONG type, QList<LPTSTR> &addresses)
+{
+entry.rgPropVals[0].ulPropTag = PR_RECIPIENT_TYPE;
+entry.rgPropVals[0].Value.l = type;
+#ifdef _WIN32_WCE
+QString addressStr = addr.addressee();
+#else
+QString addressStr("[%1:%2]");
+addressStr = addressStr.arg(addr.type() == QMessageAddress::Phone ? "SMS" : "SMTP");
+addressStr = addressStr.arg(addr.addressee());
+#endif
+// TODO: Escape illegal characters, as per: http://msdn.microsoft.com/en-us/library/cc842281.aspx
+uint len = addressStr.length();
+LPTSTR address = new TCHAR[len + 1];
+memcpy(address, addressStr.utf16(), len * sizeof(TCHAR));
+address[len] = 0;
+#ifdef _WIN32_WCE
+entry.rgPropVals[1].ulPropTag = PR_EMAIL_ADDRESS;
+entry.rgPropVals[1].Value.LPSZ = address;
+if(addr.type() == QMessageAddress::Email)
+{
+//Set the address type(SMTP is the only type currently supported)
+entry.rgPropVals[2].ulPropTag = PR_ADDRTYPE;
+entry.rgPropVals[2].Value.LPSZ = L"SMTP";
+}
+else if(addr.type() == QMessageAddress::Phone)
+{
+//Set the address type(SMTP is the only type currently supported)
+entry.rgPropVals[2].ulPropTag = PR_ADDRTYPE;
+entry.rgPropVals[2].Value.LPSZ = L"SMS";
+}
+else
+qWarning() << "Unrecognized address type";
+#else
+entry.rgPropVals[1].ulPropTag = PR_DISPLAY_NAME;
+entry.rgPropVals[1].Value.LPSZ = address;
+#endif
+addresses.append(address);
+}
+bool resolveAddressList(ADRLIST *list, IMAPISession *session)
+{
+bool result(false);
+if (session) {
+IAddrBook *book(0);
+HRESULT rv = session->OpenAddressBook(0, 0, AB_NO_DIALOG, &book);
+if (HR_SUCCEEDED(rv)) {
+rv = book->ResolveName(0, MAPI_UNICODE, 0, list);
+if (HR_SUCCEEDED(rv)) {
+result = true;
+} else {
+qWarning() << "Unable to resolve addresses.";
+}
+book->Release();
+} else {
+qWarning() << "Unable to open address book.";
+}
+}
+return result;
+}
+void destroyAddressList(ADRLIST *list, QList<LPTSTR> &addresses)
+{
+foreach (LPTSTR address, addresses) {
+delete [] address;
+}
+addresses.clear();
+for (uint i = 0; i < list->cEntries; ++i) {
+MAPIFreeBuffer(list->aEntries[i].rgPropVals);
+}
+MAPIFreeBuffer(list);
+}
+ULONG addAttachment(IMessage* message, const QMessageContentContainer& attachmentContainer)
+{
+IAttach *attachment(0);
+ULONG attachmentNumber(0);
+if (HR_SUCCEEDED(message->CreateAttach(NULL, 0, &attachmentNumber, &attachment))) {
+QString fileName(attachmentContainer.suggestedFileName());
+QString extension;
+int index = fileName.lastIndexOf(".");
+if (index != -1) {
+extension = fileName.mid(index);
+}
+WinHelpers::Lptstr suggestedFileNameLptstr(WinHelpers::LptstrFromQString(fileName));
+WinHelpers::Lptstr extensionLptstr(WinHelpers::LptstrFromQString(extension));
+const int nProperties = 5;
+SPropValue prop[nProperties] = { 0 };
+prop[0].ulPropTag = PR_ATTACH_METHOD;
+prop[0].Value.ul = ATTACH_BY_VALUE;
+prop[1].ulPropTag = PR_RENDERING_POSITION;
+prop[1].Value.l = -1;
+prop[2].ulPropTag = PR_ATTACH_LONG_FILENAME;
+prop[2].Value.LPSZ = suggestedFileNameLptstr;
+prop[3].ulPropTag = PR_ATTACH_FILENAME;
+prop[3].Value.LPSZ = suggestedFileNameLptstr;
+prop[4].ulPropTag = PR_ATTACH_EXTENSION;
+prop[4].Value.LPSZ = extensionLptstr;
+if (HR_SUCCEEDED(attachment->SetProps(nProperties, prop, NULL))) {
+IStream *os(0);
+if (HR_SUCCEEDED(attachment->OpenProperty(PR_ATTACH_DATA_BIN, &IID_IStream, 0, MAPI_MODIFY | MAPI_CREATE, (LPUNKNOWN*)&os))) {
+const int BUF_SIZE=4096;
+char pData[BUF_SIZE];
+ULONG ulSize=0,ulRead,ulWritten, ulTotalWritten=0;
+QDataStream attachmentStream(attachmentContainer.content());
+ulRead=attachmentStream.readRawData(static_cast<char*>(pData), BUF_SIZE);
+while (ulRead) {
+os->Write(pData,ulRead, &ulWritten);
+ulTotalWritten += ulWritten;
+ulSize += ulRead;
+ulRead = attachmentStream.readRawData(static_cast<char*>(pData), BUF_SIZE);
+}
+ULARGE_INTEGER uli = { 0 };
+uli.LowPart = ulTotalWritten;
+os->SetSize(uli);
+os->Commit(STGC_DEFAULT);
+mapiRelease(os);
+prop[0].ulPropTag=PR_ATTACH_SIZE;
+prop[0].Value.ul=ulSize;
+attachment->SetProps(1, prop, NULL);
+#ifndef _WIN32_WCE //unsupported
+attachment->SaveChanges(KEEP_OPEN_READONLY);
+#endif
+} else {
+qWarning() << "Could not open MAPI attachment data stream";
+}
+} else {
+qWarning() << "Could not set MAPI attachment properties";
+}
+mapiRelease(attachment);
+} else {
+qWarning() << "Could not create MAPI attachment";
+}
+return attachmentNumber;
+}
+template<typename T> QString getLastError(T& mapiType, HRESULT hr)
+{
+LPMAPIERROR err;
+HRESULT thisResult = mapiType.GetLastError(hr,MAPI_UNICODE,&err);
+if(thisResult != S_OK || !err)
+{
+qWarning() << "Could not get last MAPI error string";
+return QString();
+}
+QString mapiErrorMsg = QStringFromLpctstr(err->lpszError);
+QString mapiComponent = QStringFromLpctstr(err->lpszComponent);
+QString result = QString("MAPI Error: %1 ; MAPI Component: %2").arg(mapiErrorMsg).arg(mapiComponent);
+MAPIFreeBuffer(err);
+return result;
+}
+typedef QPair<QString, QString> StringPair;
+QList<StringPair> decomposeHeaders(const QString &headers)
+{
+QList<StringPair> result;
+if (!headers.isEmpty()) {
+int lastIndex = 0;
+int index = -2;
+do {
+index += 2;
+lastIndex = index;
+// Find CRLF not followed by whitespace
+QRegExp lineSeparator("\r\n(?!\\s)");
+index = headers.indexOf(lineSeparator, lastIndex);
+QString line = headers.mid(lastIndex, (index == -1 ? -1 : (index - lastIndex)));
+// Split the current line
+QRegExp headerIdentifier("\\s*(\\w+)\\s*:");
+if (line.indexOf(headerIdentifier) == 0) {
+result.append(qMakePair(headerIdentifier.cap(1), line.mid(headerIdentifier.cap(0).length()).trimmed()));
+} else {
+// Assume the whole line is an identifier
+result.append(qMakePair(line, QString()));
+}
+} while (index != -1);
+}
+return result;
+}
+QMessageAddress createAddress(const QString &name, const QString &address)
+{
+QMessageAddress result;
+if (!name.isEmpty() || !address.isEmpty()) {
+QString from;
+if (!name.isEmpty() && !address.isEmpty() && (name != address)) {
+from = name + " <" + address + ">";
+} else {
+from = (!name.isEmpty() ? name : address);
+}
+result = QMessageAddress(QMessageAddress::Email, from);
+}
+return result;
+}
+ULONG streamSize(QMessageManager::Error* error, IStream* is)
+{
+ULONG size = 0;
+STATSTG stg = { 0 };
+HRESULT rv = is->Stat(&stg, STATFLAG_NONAME);
+if (HR_SUCCEEDED(rv)) {
+size = stg.cbSize.LowPart;
+} else {
+*error = QMessageManager::ContentInaccessible;
+}
+return size;
+}
+QByteArray readStream(QMessageManager::Error *error, IStream *is)
+{
+QByteArray result;
+STATSTG stg = { 0 };
+HRESULT rv = is->Stat(&stg, STATFLAG_NONAME);
+if (HR_SUCCEEDED(rv)) {
+ULONG sz = stg.cbSize.LowPart;
+result.resize(sz);
+ULONG bytes = 0;
+rv = is->Read(result.data(), sz, &bytes);
+if (HR_FAILED(rv)) {
+*error = QMessageManager::ContentInaccessible;
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+}
+return result;
+}
+bool writeStream(QMessageManager::Error *error, IStream *os, const void *address, ULONG bytes, bool truncate)
+{
+ULONG existingSize = truncate ? streamSize(error, os) : 0;
+if (*error == QMessageManager::NoError) {
+HRESULT rv = S_OK;
+if (existingSize > bytes) {
+ULARGE_INTEGER uli = { 0 };
+uli.LowPart = bytes;
+rv = os->SetSize(uli);
+}
+if (HR_SUCCEEDED(rv)) {
+ULONG written(0);
+rv = os->Write(address, bytes, &written);
+if (HR_SUCCEEDED(rv)) {
+if (written < bytes) {
+qWarning() << "Only wrote partial data to output stream.";
+} else {
+rv = os->Commit(STGC_DEFAULT);
+if (HR_SUCCEEDED(rv)) {
+return true;
+} else {
+qWarning() << "Unable to commit write to output stream.";
+}
+}
+} else {
+qWarning() << "Unable to write data to output stream.";
+}
+} else {
+qWarning() << "Unable to resize output stream.";
+}
+}
+*error = QMessageManager::FrameworkFault;
+return false;
+}
+QString decodeContent(const QByteArray &data, const QByteArray &charset, int length = -1)
+{
+QString result;
+QTextCodec *codec = QTextCodec::codecForName(charset);
+if (codec) {
+if (length == -1) {
+// Convert the entirety
+result = codec->toUnicode(data);
+} else {
+// Convert only the first length bytes
+QTextCodec::ConverterState state;
+result = codec->toUnicode(data, length, &state);
+}
+} else {
+qWarning() << "No codec for charset:" << charset;
+}
+return result;
+}
+#ifndef _WIN32_WCE
+QByteArray extractPlainText(const QByteArray &rtf)
+{
+// Attempt to extract the HTML from the RTF
+// as per CMapiEx, http://www.codeproject.com/KB/IP/CMapiEx.aspx
+QByteArray text;
+const QByteArray startTag("\\fs20");
+int index = rtf.indexOf(startTag);
+if (index != -1) {
+const QByteArray par("\\par");
+const QByteArray tab("\\tab");
+const QByteArray li("\\li");
+const QByteArray fi("\\fi-");
+const QByteArray pntext("\\pntext");
+const char zero = '\0';
+const char space = ' ';
+const char openingBrace = '{';
+const char closingBrace = '}';
+const char ignore[] = { openingBrace, closingBrace, '\r', '\n' };
+QByteArray::const_iterator rit = rtf.constBegin() + index, rend = rtf.constEnd();
+while ((rit != rend) && (*rit != zero)) {
+if (*rit == ignore[0] || *rit == ignore[1] || *rit == ignore[2] || *rit == ignore[3]) {
+++rit;
+} else {
+bool skipSection(false);
+bool skipDigits(false);
+bool skipSpace(false);
+const QByteArray remainder(QByteArray::fromRawData(rit, (rend - rit)));
+if (remainder.startsWith(par)) {
+rit += par.length();
+text += "\r\n";
+skipSpace = true;
+} else if (remainder.startsWith(tab)) {
+rit += tab.length();
+text += "\t";
+skipSpace = true;
+} else if (remainder.startsWith(li)) {
+rit += li.length();
+skipDigits = true;
+skipSpace = true;
+} else if (remainder.startsWith(fi)) {
+rit += fi.length();
+skipDigits = true;
+skipSpace = true;
+} else if (remainder.startsWith(QByteArray("\\'"))) {
+rit += 2;
+QByteArray encodedChar(QByteArray::fromRawData(rit, 2));
+rit += 2;
+text += char(encodedChar.toUInt(0, 16));
+} else if (remainder.startsWith(pntext)) {
+rit += pntext.length();
+skipSection = true;
+} else if (remainder.startsWith(QByteArray("\\{"))) {
+rit += 2;
+text += "{";
+} else if (remainder.startsWith(QByteArray("\\}"))) {
+rit += 2;
+text += "}";
+} else {
+text += *rit;
+++rit;
+}
+if (skipSection) {
+while ((rit != rend) && (*rit != closingBrace)) {
+++rit;
+}
+}
+if (skipDigits) {
+while ((rit != rend) && isdigit(*rit)) {
+++rit;
+}
+}
+if (skipSpace) {
+if ((rit != rend) && (*rit == space)) {
+++rit;
+}
+}
+}
+}
+}
+return text;
+}
+int digitValue(char n)
+{
+if (n >= '0' && n <= '9') {
+return (n - '0');
+}
+return 0;
+}
+QByteArray extractHtml(const QByteArray &rtf)
+{
+// Attempt to extract the HTML from the RTF
+// as per CMapiEx, http://www.codeproject.com/KB/IP/CMapiEx.aspx
+QByteArray html;
+const QByteArray htmltag("\\*\\htmltag");
+int index = rtf.indexOf("<html", Qt::CaseInsensitive);
+if (index == -1) {
+index = rtf.indexOf(htmltag, Qt::CaseInsensitive);
+}
+if (index != -1) {
+const QByteArray mhtmltag("\\*\\mhtmltag");
+const QByteArray par("\\par");
+const QByteArray tab("\\tab");
+const QByteArray li("\\li");
+const QByteArray fi("\\fi-");
+const QByteArray pntext("\\pntext");
+const QByteArray htmlrtf("\\htmlrtf");
+const char zero = '\0';
+const char space = ' ';
+const char openingBrace = '{';
+const char closingBrace = '}';
+const char ignore[] = { openingBrace, closingBrace, '\r', '\n' };
+int tagIgnored = -1;
+QByteArray::const_iterator rit = rtf.constBegin() + index, rend = rtf.constEnd();
+while ((rit != rend) && (*rit != zero)) {
+if (*rit == ignore[0] || *rit == ignore[1] || *rit == ignore[2] || *rit == ignore[3]) {
+++rit;
+} else {
+bool skipSection(false);
+bool skipDigits(false);
+bool skipSpace(false);
+const QByteArray remainder(QByteArray::fromRawData(rit, (rend - rit)));
+if (remainder.startsWith(htmltag)) {
+rit += htmltag.length();
+int tagNumber = 0;
+while (isdigit(*rit)) {
+tagNumber = (tagNumber * 10) + digitValue(*rit);
+++rit;
+}
+skipSpace = true;
+if (tagNumber == tagIgnored) {
+skipSection = true;
+tagIgnored = -1;
+}
+} else if (remainder.startsWith(mhtmltag)) {
+rit += mhtmltag.length();
+int tagNumber = 0;
+while (isdigit(*rit)) {
+tagNumber = (tagNumber * 10) + digitValue(*rit);
+++rit;
+}
+skipSpace = true;
+tagIgnored = tagNumber;
+} else if (remainder.startsWith(par)) {
+rit += par.length();
+html += char('\r');
+html += char('\n');
+skipSpace = true;
+} else if (remainder.startsWith(tab)) {
+rit += tab.length();
+html += char('\t');
+skipSpace = true;
+} else if (remainder.startsWith(li)) {
+rit += li.length();
+skipDigits = true;
+skipSpace = true;
+} else if (remainder.startsWith(fi)) {
+rit += fi.length();
+skipDigits = true;
+skipSpace = true;
+} else if (remainder.startsWith(QByteArray("\\'"))) {
+rit += 2;
+QByteArray encodedChar(QByteArray::fromRawData(rit, 2));
+rit += 2;
+html += char(encodedChar.toUInt(0, 16));
+} else if (remainder.startsWith(pntext)) {
+rit += pntext.length();
+skipSection = true;
+} else if (remainder.startsWith(htmlrtf)) {
+rit += htmlrtf.length();
+// Find the terminating tag
+const QByteArray terminator("\\htmlrtf0");
+int index = remainder.indexOf(terminator, htmlrtf.length());
+if (index == -1) {
+rit = rend;
+} else {
+rit += (index + terminator.length() - htmlrtf.length());
+skipSpace = true;
+}
+} else if (remainder.startsWith(QByteArray("\\{"))) {
+rit += 2;
+html += openingBrace;
+} else if (remainder.startsWith(QByteArray("\\}"))) {
+rit += 2;
+html += closingBrace;
+} else {
+html += *rit;
+++rit;
+}
+if (skipSection) {
+while ((rit != rend) && (*rit != closingBrace)) {
+++rit;
+}
+}
+if (skipDigits) {
+while ((rit != rend) && isdigit(*rit)) {
+++rit;
+}
+}
+if (skipSpace) {
+if ((rit != rend) && (*rit == space)) {
+++rit;
+}
+}
+}
+}
+}
+return html;
+}
+#endif
+void storeMessageProperties(QMessageManager::Error *error, const QMessage &source, IMessage *message)
+{
+if (!setMapiProperty(message, PR_SUBJECT, source.subject())) {
+qWarning() << "Unable to set subject in message.";
+*error = QMessageManager::FrameworkFault;
+} else {
+QString emailAddress = source.from().addressee();
+if (!setMapiProperty(message, PR_SENDER_EMAIL_ADDRESS, emailAddress)) {
+qWarning() << "Unable to set sender address in message.";
+*error = QMessageManager::FrameworkFault;
+} else {
+#ifdef _WIN32_WCE
+unsigned long msgType  = 0;
+if(source.type() == QMessage::Email)
+msgType = MSGSTATUS_RECTYPE_SMTP;
+else if(source.type() == QMessage::Sms)
+msgType = MSGSTATUS_RECTYPE_SMS;
+else
+qWarning() << "Unrecognized message type";
+if(msgType && !setMapiProperty(message, PR_MSG_STATUS, static_cast<long>(msgType)))
+{
+qWarning() << "Unable to set type of message.";
+*error = QMessageManager::FrameworkFault;
+}
+else
+{
+#endif
+if (!setMapiProperty(message, PR_CLIENT_SUBMIT_TIME, toFileTime(source.date()))) {
+qWarning() << "Unable to set submit time in message.";
+*error = QMessageManager::FrameworkFault;
+} else {
+QDateTime receivedDate(source.receivedDate());
+if (receivedDate.isValid()) {
+if (!setMapiProperty(message, PR_MESSAGE_DELIVERY_TIME, toFileTime(receivedDate))) {
+qWarning() << "Unable to set delivery time in message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+if (*error == QMessageManager::NoError) {
+// Mark this message as read/unread
+#ifndef _WIN32_WCE
+LONG flags = (source.status() & QMessage::Read ? 0 : CLEAR_READ_FLAG);
+HRESULT rv = message->SetReadFlag(flags);
+if (HR_FAILED(rv)) {
+qWarning() << "Unable to set flags in message.";
+*error = QMessageManager::FrameworkFault;
+}
+#else
+LONG flags = (source.status() & QMessage::Read ? MSGFLAG_READ : 0);
+if (!setMapiProperty(message, PR_MESSAGE_FLAGS, flags)) {
+qWarning() << "Unable to set flags in message.";
+*error = QMessageManager::FrameworkFault;
+}
+#endif
+}
+if (*error == QMessageManager::NoError) {
+LONG priority = (source.priority() == QMessage::HighPriority ? PRIO_URGENT : (source.priority() == QMessage::NormalPriority ? PRIO_NORMAL : PRIO_NONURGENT));
+if (!setMapiProperty(message, PR_PRIORITY, priority)) {
+qWarning() << "Unable to set priority in message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+if (*error == QMessageManager::NoError) {
+QStringList headers;
+foreach (const QByteArray &name, source.headerFields()) {
+foreach (const QString &value, source.headerFieldValues(name)) {
+// TODO: Do we need soft line-breaks?
+headers.append(QString("%1: %2").arg(QString(name)).arg(value));
+}
+}
+if (!headers.isEmpty()) {
+QString transportHeaders = headers.join("\r\n").append("\r\n\r\n");
+if (!setMapiProperty(message, PR_TRANSPORT_MESSAGE_HEADERS, transportHeaders)) {
+qWarning() << "Unable to set transport headers in message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+}
+}
+}
+#ifdef _WIN32_WCE
+}
+#endif
+}
+}
+void replaceMessageRecipients(QMessageManager::Error *error, const QMessage &source, IMessage *message, IMAPISession *session)
+{
+#ifdef _WIN32_WCE
+Q_UNUSED(session)
+// For CE, the only available option is to replace the existing list
+HRESULT rv;
+#else
+// Find any existing recipients and remove them
+IMAPITable *recipientsTable(0);
+HRESULT rv = message->GetRecipientTable(MAPI_UNICODE, &recipientsTable);
+if (HR_SUCCEEDED(rv)) {
+ULONG count(0);
+rv = recipientsTable->GetRowCount(0, &count);
+if (HR_SUCCEEDED(rv)) {
+if (count > 0) {
+ADRLIST *list = createAddressList(count, 1);
+if (list) {
+int index = 0;
+SizedSPropTagArray(1, columns) = {1, {PR_ROWID}};
+QueryAllRows qar(recipientsTable, reinterpret_cast<LPSPropTagArray>(&columns), 0, 0);
+while (qar.query()) {
+for (uint n = 0; n < qar.rows()->cRows; ++n) {
+ULONG rowId = qar.rows()->aRow[n].lpProps[0].Value.l;
+if (rowId) {
+// Add this row's ID to the removal list
+ADRENTRY &entry(list->aEntries[index]);
+entry.rgPropVals[0].ulPropTag = PR_ROWID;
+entry.rgPropVals[0].Value.l = rowId;
+++index;
+}
+}
+}
+if (qar.error() != QMessageManager::NoError) {
+*error = qar.error();
+} else {
+rv = message->ModifyRecipients(MODRECIP_REMOVE, list);
+if (HR_FAILED(rv)) {
+qWarning() << "Unable to clear address list for message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+destroyAddressList(list, QList<LPTSTR>());
+} else {
+qWarning() << "Unable to allocate address list for message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+} else {
+qWarning() << "Unable to get row count for recipients table.";
+*error = QMessageManager::ContentInaccessible;
+}
+mapiRelease(recipientsTable);
+} else {
+if (rv != MAPI_E_NO_RECIPIENTS) {
+*error = QMessageManager::FrameworkFault;
+qWarning() << "Unable to get recipients table from message.";
+}
+}
+#endif
+if (*error == QMessageManager::NoError) {
+// Add the current message recipients
+uint recipientCount(source.to().count() + source.cc().count() + source.bcc().count());
+if (recipientCount) {
+#ifdef _WIN32_WCE
+unsigned int propertyCount = 3;
+#else
+unsigned int propertyCount = 2;
+#endif
+ADRLIST *list = createAddressList(recipientCount, propertyCount);
+if (list) {
+int index = 0;
+QList<LPTSTR> addresses;
+foreach (const QMessageAddress &addr, source.to()) {
+ADRENTRY &entry(list->aEntries[index]);
+fillAddressEntry(entry, addr, MAPI_TO, addresses);
+++index;
+}
+foreach (const QMessageAddress &addr, source.cc()) {
+ADRENTRY &entry(list->aEntries[index]);
+fillAddressEntry(entry, addr, MAPI_CC, addresses);
+++index;
+}
+foreach (const QMessageAddress &addr, source.bcc()) {
+ADRENTRY &entry(list->aEntries[index]);
+fillAddressEntry(entry, addr, MAPI_BCC, addresses);
+++index;
+}
+#ifndef _WIN32_WCE
+if (resolveAddressList(list, session)) {
+#endif
+rv = message->ModifyRecipients(MODRECIP_ADD, list);
+if (HR_FAILED(rv)) {
+qWarning() << "Unable to store address list for message.";
+*error = QMessageManager::FrameworkFault;
+}
+#ifndef _WIN32_WCE
+} else {
+qWarning() << "Unable to resolve address list for message.";
+*error = QMessageManager::FrameworkFault;
+}
+#endif
+destroyAddressList(list, addresses);
+} else {
+qWarning() << "Unable to allocate address list for message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+}
+}
+void replaceMessageBody(QMessageManager::Error *error, const QMessage &source, IMessage *message, const MapiStorePtr &store)
+{
+Q_UNUSED(store);
+// Remove any preexisting body elements
+#ifndef _WIN32_WCE
+SizedSPropTagArray(2, props) = {2, {PR_BODY, PR_RTF_COMPRESSED}};
+#elif(_WIN32_WCE > 0x501)
+SizedSPropTagArray(2, props) = {2, {PR_BODY_HTML_A, PR_BODY_W}};
+#else
+SizedSPropTagArray(2, props) = {2, {PR_BODY, PR_BODY_W}};
+#endif
+HRESULT rv = message->DeleteProps(reinterpret_cast<LPSPropTagArray>(&props), 0);
+#ifdef _WIN32_WCE
+if (rv == E_FAIL) {
+// On CE, deleting nonexisting properties fails... assume that they're not present
+rv = S_OK;
+}
+#endif
+if (HR_SUCCEEDED(rv)) {
+// Insert the current body data
+QMessageContentContainerId bodyId(source.bodyId());
+if (bodyId.isValid()) {
+QMessageContentContainer bodyContent(source.find(bodyId));
+QByteArray subType(bodyContent.contentSubType().toLower());
+#ifdef _WIN32_WCE
+if (subType == "rtf") {
+// CE does not support RTF; just store it as plain text
+subType = "plain";
+} else if (subType == "html") {
+// If the store doesn't support HTML then fallback to text
+if (!store->supports(STORE_HTML_OK)) {
+subType = "plain";
+qWarning() << "Store does not support HTML.";
+}
+}
+if (subType == "html") {
+IStream *os(0);
+#if(_WIN32_WCE > 0x501)
+HRESULT rv = message->OpenProperty(PR_BODY_HTML_A, 0, STGM_WRITE, MAPI_MODIFY | MAPI_CREATE,(LPUNKNOWN*)&os);
+#else
+// TODO: If we store the HTML in the body property, how do we know that it is HTML on extraction?
+HRESULT rv = message->OpenProperty(PR_BODY, 0, STGM_WRITE, MAPI_MODIFY | MAPI_CREATE,(LPUNKNOWN*)&os);
+#endif
+if (HR_SUCCEEDED(rv)) {
+QByteArray body(bodyContent.textContent().toLatin1());
+writeStream(error, os, body.data(), body.count(), true);
+mapiRelease(os);
+} else {
+qWarning() << "Unable to write HTML to body";
+*error = QMessageManager::FrameworkFault;
+}
+#else
+if ((subType == "rtf") || (subType == "html")) {
+QByteArray body(bodyContent.textContent().toLatin1());
+LONG textFormat(EDITOR_FORMAT_RTF);
+if (subType == "html") {
+// Encode the HTML within RTF
+TCHAR codePage[6] = _T("1252");
+GetLocaleInfo(LOCALE_SYSTEM_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE, codePage, sizeof(codePage));
+QByteArray format("{\\rtf1\\ansi\\ansicpg" +
+QString::fromUtf16(reinterpret_cast<const quint16*>(codePage)).toLatin1() +
+"\\fromhtml1 {\\*\\htmltag1 ");
+body = format + body + "}}";
+textFormat = EDITOR_FORMAT_HTML;
+}
+// Mark this message as formatted
+if (!setMapiProperty(message, PR_MSG_EDITOR_FORMAT, textFormat)) {
+qWarning() << "Unable to set message editor format in message.";
+*error = QMessageManager::FrameworkFault;
+}
+IStream *os(0);
+rv = message->OpenProperty(PR_RTF_COMPRESSED, &IID_IStream, STGM_CREATE | STGM_WRITE, MAPI_CREATE | MAPI_MODIFY, reinterpret_cast<LPUNKNOWN*>(&os));
+if (HR_SUCCEEDED(rv)) {
+IStream *compressor(0);
+rv = WrapCompressedRTFStream(os, MAPI_MODIFY, &compressor);
+if (HR_SUCCEEDED(rv)) {
+// The wrapper stream does not support Stat()
+writeStream(error, compressor, body.data(), body.length(), false);
+compressor->Release();
+} else {
+qWarning() << "Unable to open RTF compressor stream for write.";
+*error = QMessageManager::FrameworkFault;
+}
+os->Release();
+} else {
+qWarning() << "Unable to open compressed RTF stream for write.";
+*error = QMessageManager::FrameworkFault;
+}
+#endif
+} else {
+QString body(bodyContent.textContent());
+#ifdef _WIN32_WCE
+IStream *os(0);
+HRESULT rv = message->OpenProperty(PR_BODY_W, 0, STGM_WRITE, MAPI_MODIFY | MAPI_CREATE,(LPUNKNOWN*)&os);
+if (HR_SUCCEEDED(rv)) {
+writeStream(error, os, body.utf16(), body.count() * sizeof(WCHAR), true);
+mapiRelease(os);
+} else {
+qWarning() << "Unable to write text to body";
+*error = QMessageManager::FrameworkFault;
+}
+#else
+// Mark this message as plain text
+LONG textFormat(EDITOR_FORMAT_PLAINTEXT);
+if (!setMapiProperty(message, PR_MSG_EDITOR_FORMAT, textFormat)) {
+qWarning() << "Unable to set message editor format in message.";
+*error = QMessageManager::FrameworkFault;
+}
+if (!setMapiProperty(message, PR_BODY, body)) {
+qWarning() << "Unable to set body in message.";
+*error = QMessageManager::FrameworkFault;
+}
+#endif
+}
+}
+} else {
+qWarning() << "Unable to delete existing body properties from message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+void addMessageAttachments(QMessageManager::Error *error, const QMessage &source, IMessage *message, WinHelpers::SavePropertyOption saveOption = WinHelpers::SavePropertyChanges )
+{
+Q_UNUSED(saveOption);
+QList<LONG> attachmentNumbers;
+if (MapiSession::messageImpl(source)->_hasAttachments) {
+// Find any existing attachments
+IMAPITable *attachmentsTable(0);
+HRESULT rv = message->GetAttachmentTable(MAPI_UNICODE, &attachmentsTable);
+if (HR_SUCCEEDED(rv)) {
+SizedSPropTagArray(1, columns) = {1, {PR_ATTACH_NUM}};
+QueryAllRows qar(attachmentsTable, reinterpret_cast<LPSPropTagArray>(&columns), 0, 0, false);
+while (qar.query()) {
+for (uint n = 0; n < qar.rows()->cRows; ++n) {
+attachmentNumbers.append(qar.rows()->aRow[n].lpProps[0].Value.l);
+}
+}
+*error = qar.error();
+if (*error != QMessageManager::NoError) {
+qWarning() << "Unable to get attachments numbers from table.";
+}
+mapiRelease(attachmentsTable);
+} else {
+qWarning() << "Unable to get attachments table from message.";
+*error = QMessageManager::FrameworkFault;
+}
+}
+if (*error == QMessageManager::NoError) {
+// Add any current attachments not present
+foreach (const QMessageContentContainerId &attachmentId, source.attachmentIds()) {
+QMessageContentContainer attachment(source.find(attachmentId));
+bool isAttachment = (!attachment.suggestedFileName().isEmpty() && attachment.isContentAvailable());
+if (isAttachment) {
+LONG number(MapiSession::containerImpl(attachment)->_attachmentNumber);
+if (!number || !attachmentNumbers.contains(number)) {
+addAttachment(message, attachment);
+}
+}
+}
+}
+}
+struct FolderHeapNode
+{
+FolderHeapNode(const MapiFolderPtr &folder, const QMessageFilter &filter);
+QMessageFilter _filter;
+MapiFolderPtr _folder;
+LPMAPITABLE _table;
+QMessage _front;
+};
+FolderHeapNode::FolderHeapNode(const MapiFolderPtr &folder, const QMessageFilter &filter)
+: _filter(filter),
+_folder(folder)
+{
+}
+typedef QSharedPointer<FolderHeapNode> FolderHeapNodePtr;
+// FolderHeap is a binary heap used to merge sort messages from different folders and stores
+class FolderHeap {
+public:
+FolderHeap(QMessageManager::Error *error, const QList<FolderHeapNodePtr> &protoHeap, const QMessageSortOrder &sortOrder);
+~FolderHeap();
+QMessage takeFront(QMessageManager::Error *error);
+bool isEmpty() const { return _heap.count() == 0; }
+private:
+void sink(int i); // Also known as sift-down
+QMessageFilter _filter;
+QMessageSortOrder _ordering;
+QList<FolderHeapNodePtr> _heap;
+};
+FolderHeap::FolderHeap(QMessageManager::Error *error, const QList<FolderHeapNodePtr> &protoHeap, const QMessageSortOrder &sortOrder)
+{
+_ordering = sortOrder;
+foreach (const FolderHeapNodePtr &node, protoHeap) {
+if (!node->_folder) {
+qWarning() << "Unable to access folder:" << node->_folder->name();
+continue;
+}
+QMessageIdList messageIdList;
+node->_table = node->_folder->queryBegin(error, node->_filter, sortOrder);
+if (*error == QMessageManager::NoError) {
+if (node->_table) {
+messageIdList = node->_folder->queryNext(error, node->_table, node->_filter);
+if (messageIdList.isEmpty() || (*error != QMessageManager::NoError)) {
+node->_folder->queryEnd(node->_table);
+}
+}
+if (!messageIdList.isEmpty()) {
+node->_front = node->_folder->message(error, messageIdList.front());
+if (*error == QMessageManager::NoError) {
+_heap.append(node);
+}
+}
+}
+}
+if (!_ordering.isEmpty()) {
+for (int i = _heap.count()/2 - 1; i >= 0; --i)
+sink(i);
+}
+}
+FolderHeap::~FolderHeap()
+{
+}
+QMessage FolderHeap::takeFront(QMessageManager::Error *error)
+{
+QMessage result(_heap[0]->_front);
+FolderHeapNodePtr node(_heap[0]);
+QMessageIdList messageIdList;
+if (node->_table) {
+messageIdList = node->_folder->queryNext(error, node->_table, node->_filter);
+if (messageIdList.isEmpty() || (*error != QMessageManager::NoError)) {
+node->_folder->queryEnd(node->_table);
+}
+}
+if (*error != QMessageManager::NoError)
+return result;
+if (messageIdList.isEmpty()) {
+if (_heap.count() > 1) {
+_heap[0] = _heap.takeLast();
+} else {
+_heap.pop_back();
+}
+} else {
+node->_front = node->_folder->message(error, messageIdList.front());
+if (*error != QMessageManager::NoError)
+return result;
+}
+if (!_ordering.isEmpty()) {
+// Reposition this folder in the heap based on the new front message
+sink(0);
+}
+return result;
+}
+void FolderHeap::sink(int i)
+{
+while (true) {
+const int leftChild(2*i + 1);
+if (leftChild >= _heap.count())
+return;
+const int rightChild(leftChild + 1);
+int minChild(leftChild);
+if ((rightChild < _heap.count()) && (QMessageSortOrderPrivate::lessThan(_ordering, _heap[rightChild]->_front, _heap[leftChild]->_front)))
+minChild = rightChild;
+// Reverse positions only if the child sorts before the parent
+if (QMessageSortOrderPrivate::lessThan(_ordering, _heap[minChild]->_front, _heap[i]->_front)) {
+FolderHeapNodePtr temp(_heap[minChild]);
+_heap[minChild] = _heap[i];
+_heap[i] = temp;
+i = minChild;
+} else {
+return;
+}
+}
+}
+bool bodyMatches(const QMessage &message, const QString &body, QMessageDataComparator::MatchFlags matchFlags)
+{
+if (body.isEmpty())
+return true;
+QMessageContentContainer bodyContainer(message.find(message.bodyId()));
+if (matchFlags & QMessageDataComparator::MatchCaseSensitive) {
+return bodyContainer.textContent().contains(body, Qt::CaseSensitive);
+}
+return bodyContainer.textContent().contains(body, Qt::CaseInsensitive);
+}
+QMessageIdList filterMessages(QMessageManager::Error *error, QList<FolderHeapNodePtr> &folderNodes, const QMessageSortOrder &sortOrder, uint limit, uint offset, const QString &body = QString(), QMessageDataComparator::MatchFlags matchFlags = 0)
+{
+QMessageIdList result;
+QHash<QMessageId, bool> avoidDuplicates; // For complex filters it's necessary to check for duplicates
+FolderHeap folderHeap(error, folderNodes, sortOrder);
+if (*error != QMessageManager::NoError)
+return result;
+int count = 0 - offset;
+while (!folderHeap.isEmpty()) {
+// Ideally would not retrieve unwanted messages using IMAPITable::SeekRow
+// But this is not feasible on Windows Mobile http://msdn.microsoft.com/en-us/library/bb446068.aspx:
+// 'If there are large numbers of rows in the table, the SeekRow oepration can be slow. Do not set lRowCount ot a numer greater than 50'
+if (limit && (count == limit))
+break;
+QMessage front(folderHeap.takeFront(error));
+if (*error != QMessageManager::NoError)
+return result;
+if (!avoidDuplicates.contains(front.id()) && bodyMatches(front, body, matchFlags)) {
+avoidDuplicates.insert(front.id(), true);
+if (count >= 0) {
+result.append(front.id());
+}
+++count;
+}
+}
+if (offset) {
+return result.mid(offset, (limit ? limit : -1));
+} else {
+return result;
+}
+}
+}
+QEvent::Type MapiSession::NotifyEvent::eventType()
+{
+static int result = QEvent::registerEventType();
+return static_cast<QEvent::Type>(result);
+}
+MapiSession::NotifyEvent::NotifyEvent(MapiStore *store, const QMessageId &id, MapiSession::NotifyType type)
+: QEvent(eventType()),
+_store(store),
+_id(id),
+_notifyType(type)
+{
+}
+QEvent::Type MapiSession::NotifyEvent::type()
+{
+return eventType();
+}
+namespace WinHelpers {
+// Note: UNICODE is always defined
+QString QStringFromLpctstr(LPCTSTR lpszValue)
+{
+bool isBadStringPointer = false;
+#ifndef _WIN32_WCE
+isBadStringPointer = ::IsBadStringPtr(lpszValue, (UINT_PTR)-1); // Don't crash when MAPI returns a bad string (and it does).
+#endif
+if (!lpszValue || isBadStringPointer)
+return QString();
+return QString::fromUtf16(reinterpret_cast<const quint16*>(lpszValue));
+}
+Lptstr LptstrFromQString(const QString &src)
+{
+uint length(src.length());
+Lptstr dst(length+1);
+const quint16 *data = src.utf16();
+const quint16 *it = data, *end = data + length;
+TCHAR *oit = dst;
+for ( ; it != end; ++it, ++oit) {
+*oit = static_cast<TCHAR>(*it);
+}
+*oit = TCHAR('\0');
+return dst;
+}
+ULONG createNamedProperty(IMAPIProp *object, const QString &name)
+{
+ULONG result = 0;
+if (!name.isEmpty()) {
+Lptstr nameBuffer = LptstrFromQString(name);
+MAPINAMEID propName = { 0 };
+propName.lpguid = &GuidPublicStrings;
+propName.ulKind = MNID_STRING;
+propName.Kind.lpwstrName = nameBuffer;
+LPMAPINAMEID propNames = &propName;
+SPropTagArray *props;
+HRESULT rv = object->GetIDsFromNames(1, &propNames, MAPI_CREATE, &props);
+if (HR_SUCCEEDED(rv)) {
+result = props->aulPropTag[0] | PT_UNICODE;
+MAPIFreeBuffer(props);
+} else {
+qWarning() << "createNamedProperty: GetIDsFromNames failed";
+}
+}
+return result;
+}
+ULONG getNamedPropertyTag(IMAPIProp *object, const QString &name)
+{
+ULONG result = 0;
+if (!name.isEmpty()) {
+LPTSTR nameBuffer = LptstrFromQString(name);
+MAPINAMEID propName = { 0 };
+propName.lpguid = &GuidPublicStrings;
+propName.ulKind = MNID_STRING;
+propName.Kind.lpwstrName = nameBuffer;
+LPMAPINAMEID propNames = &propName;
+SPropTagArray *props;
+HRESULT rv = object->GetIDsFromNames(1, &propNames, 0, &props);
+if (HR_SUCCEEDED(rv)) {
+if (props->aulPropTag[0] != PT_ERROR) {
+result = props->aulPropTag[0] | PT_UNICODE;
+}
+MAPIFreeBuffer(props);
+} else {
+qWarning() << "getNamedPropertyTag: GetIDsFromNames failed";
+}
+}
+return result;
+}
+bool setNamedProperty(IMAPIProp *object, ULONG tag, const QString &value)
+{
+if (object && tag && !value.isEmpty()) {
+SPropValue prop = { 0 };
+prop.ulPropTag = tag;
+prop.Value.LPSZ = reinterpret_cast<LPTSTR>(const_cast<quint16*>(value.utf16()));
+HRESULT rv = object->SetProps(1, &prop, 0);
+if (HR_SUCCEEDED(rv)) {
+return true;
+} else {
+qWarning() << "setNamedProperty: SetProps failed";
+}
+}
+return false;
+}
+QString getNamedProperty(IMAPIProp *object, ULONG tag)
+{
+QString result;
+if (object && tag) {
+SPropValue *prop(0);
+HRESULT rv = HrGetOneProp(object, tag, &prop);
+if (HR_SUCCEEDED(rv)) {
+result = QStringFromLpctstr(prop->Value.LPSZ);
+MAPIFreeBuffer(prop);
+} else if (rv != MAPI_E_NOT_FOUND) {
+qWarning() << "getNamedProperty: HrGetOneProp failed";
+}
+}
+return result;
+}
+QByteArray contentTypeFromExtension(const QString &extension)
+{
+QByteArray result("application/octet-stream");
+if (!extension.isEmpty()) {
+// Create the extension string to search for
+QString dotExtension(extension);
+if (!dotExtension.startsWith('.')) {
+dotExtension.prepend('.');
+}
+Lptstr ext = LptstrFromQString(dotExtension);
+#if !defined(_WIN32_WCE) && (_MSC_VER>=1500)
+IQueryAssociations *associations(0);
+HRESULT rv = AssocCreate(CLSID_QueryAssociations, IID_PPV_ARGS(&associations));
+if (HR_SUCCEEDED(rv)) {
+rv = associations->Init(0, ext, 0, 0);
+if (HR_SUCCEEDED(rv)) {
+// Find the length of the content-type string
+DWORD length = 0;
+rv = associations->GetString(0, ASSOCSTR_CONTENTTYPE, 0, 0, &length);
+if ((rv == S_FALSE) && length) {
+// Retrieve the string
+wchar_t *buffer = new wchar_t[length + 1];
+buffer[length] = '\0';
+rv = associations->GetString(0, ASSOCSTR_CONTENTTYPE, 0, buffer, &length);
+if (rv == S_OK) {
+QString output(QString::fromUtf16(reinterpret_cast<quint16*>(buffer)));
+result = output.toLatin1();
+}
+delete [] buffer;
+}
+}
+mapiRelease(associations);
+}
+#elif  !defined(_WIN32_WCE) && (_MSC_VER<1500)
+//TODO Windows 2005 and 2003 don't have IID_PPV_ARGS.
+//find alternative
+#else
+// Find any registry entry for this extension
+HKEY key = { 0 };
+LONG rv = RegOpenKeyEx(HKEY_CLASSES_ROOT, ext, 0, 0, &key);
+if (rv == ERROR_SUCCESS) {
+WCHAR value[512] = { 0 };
+DWORD valueBytes = sizeof(value);
+rv = RegQueryValueEx(key, L"Content Type", 0, 0, reinterpret_cast<LPBYTE>(&value), &valueBytes);
+if (rv == ERROR_SUCCESS) {
+if (valueBytes > 1) {
+result = QStringFromLpctstr(value).toLatin1();
+}
+} else {
+qWarning() << "Unable to query key for extension:" << extension;
+}
+RegCloseKey(key);
+}
+#endif
+}
+return result;
+}
+MapiInitializer::MapiInitializer()
+: _initialized(false)
+{
+#ifndef QT_NO_THREAD
+// Note MAPIINIT is ignored on Windows Mobile but used on Outlook 2007 see msdn ms862621 vs cc842343
+MAPIINIT_0 MAPIINIT = { 0, MAPI_MULTITHREAD_NOTIFICATIONS };
+LPVOID arg(&MAPIINIT);
+#else
+LPVOID arg(0);
+#endif
+HRESULT rv = MAPIInitialize(arg);
+if (HR_SUCCEEDED(rv)) {
+_initialized = true;
+} else {
+_initialized = false;
+qWarning() << "Unable to initialize MAPI - rv:" << hex << (ULONG)rv;
+}
+}
+MapiInitializer::~MapiInitializer()
+{
+if (_initialized) {
+MAPIUninitialize();
+_initialized = false;
+}
+}
+MapiInitializationToken initializeMapi()
+{
+MapiInitializationToken result;
+if (!initializer.hasLocalData()) {
+initializer.setLocalData(new InitRecord);
+}
+InitRecordPtr &threadInitializer(initializer.localData());
+if (!(*threadInitializer).isNull()) {
+result = (*threadInitializer).toStrongRef();
+} else {
+result = MapiInitializationToken(new MapiInitializer());
+(*threadInitializer) = result;
+}
+return result;
+}
+class StoreSortHelper {
+public:
+StoreSortHelper(const QMessageAccountSortOrder *sortOrder, MapiStorePtr storePtr)
+:_ordering(sortOrder),
+_storePtr(storePtr)
+{}
+MapiStorePtr store()
+{
+return _storePtr;
+}
+StoreSortHelper& operator=(const StoreSortHelper &other) {
+if (&other == this)
+return *this;
+_ordering = other._ordering;
+_storePtr = other._storePtr;
+return *this;
+}
+bool operator<(const StoreSortHelper &other) const
+{
+bool result (_storePtr->name() < other._storePtr->name());
+if (QMessageAccountSortOrderPrivate::order(*_ordering) == Qt::DescendingOrder)
+result = !result;
+return result;
+}
+private:
+const QMessageAccountSortOrder *_ordering;
+MapiStorePtr _storePtr;
+};
+class FolderSortHelper {
+public:
+FolderSortHelper(const QMessageFolderSortOrder *sortOrder, MapiFolderPtr folderPtr, const QMessageFolder &folder)
+:_ordering(sortOrder),
+_folderPtr(folderPtr),
+_folder(folder)
+{}
+MapiFolderPtr mapiFolderPtr()
+{
+return _folderPtr;
+}
+QMessageFolder folder()
+{
+return _folder;
+}
+FolderSortHelper& operator=(const FolderSortHelper &other) {
+if (&other == this)
+return *this;
+_ordering = other._ordering;
+_folderPtr = other._folderPtr;
+_folder = other._folder;
+return *this;
+}
+bool operator<(const FolderSortHelper &other) const
+{
+return QMessageFolderSortOrderPrivate::lessthan(*_ordering, _folder, other._folder);
+}
+private:
+const QMessageFolderSortOrder *_ordering;
+MapiFolderPtr _folderPtr;
+QMessageFolder _folder;
+};
+}
+using namespace WinHelpers;
+MapiFolder::MapiFolder()
+:_valid(false),
+_folder(0),
+_hasSubFolders(false),
+_messageCount(0),
+_init(false)
+{
+}
+MapiFolderPtr MapiFolder::createFolder(QMessageManager::Error *error, const MapiStorePtr &store, IMAPIFolder *folder, const MapiRecordKey &recordKey, const QString &name, const MapiEntryId &entryId, bool hasSubFolders, uint messageCount)
+{
+Q_UNUSED(error);
+MapiFolderPtr ptr = MapiFolderPtr(new MapiFolder(store, folder, recordKey, name, entryId, hasSubFolders, messageCount));
+if (!ptr.isNull()) {
+ptr->_self = ptr;
+}
+return ptr;
+}
+MapiFolder::MapiFolder(const MapiStorePtr &store, IMAPIFolder *folder, const MapiRecordKey &recordKey, const QString &name, const MapiEntryId &entryId, bool hasSubFolders, uint messageCount)
+:_store(store),
+_valid(folder != 0),
+_folder(folder),
+_key(recordKey),
+_name(name),
+_entryId(entryId),
+_hasSubFolders(hasSubFolders),
+_messageCount(messageCount),
+_init(false)
+{
+}
+MapiFolder::~MapiFolder()
+{
+mapiRelease(_folder);
+_valid = false;
+_init = false;
+}
+void MapiFolder::findSubFolders(QMessageManager::Error *error)
+{
+if (!_folder) {
+*error = QMessageManager::FrameworkFault;
+qWarning() << "No folder to search for subfolders";
+} else if (_hasSubFolders) {
+IMAPITable *subFolders(0);
+HRESULT rv = _folder->GetHierarchyTable(0, &subFolders);
+if (HR_SUCCEEDED(rv)) {
+SizedSPropTagArray(5, columns) = {5, {PR_ENTRYID, PR_IS_NEWSGROUP, PR_IS_NEWSGROUP_ANCHOR, PR_EXTENDED_FOLDER_FLAGS, PR_FOLDER_TYPE}};
+rv = subFolders->SetColumns(reinterpret_cast<LPSPropTagArray>(&columns), 0);
+if (HR_SUCCEEDED(rv)) {
+// Extract the Entry IDs for the subfolders
+while (true) {
+LPSRowSet rows(0);
+if (subFolders->QueryRows(1, 0, &rows) == S_OK) {
+if (rows->cRows == 1) {
+SRow *row(&rows->aRow[0]);
+MapiEntryId entryId(row->lpProps[0].Value.bin.lpb, row->lpProps[0].Value.bin.cb);
+bool isNewsGroup = (row->lpProps[1].ulPropTag == PR_IS_NEWSGROUP && row->lpProps[1].Value.b);
+bool isNewsGroupAnchor = (row->lpProps[2].ulPropTag == PR_IS_NEWSGROUP_ANCHOR && row->lpProps[2].Value.b);
+bool special(isNewsGroup || isNewsGroupAnchor);
+#ifndef _WIN32_WCE
+// Skip slow folders, necessary evil
+if (row->lpProps[3].ulPropTag == PR_EXTENDED_FOLDER_FLAGS) {
+QByteArray extendedFlags(reinterpret_cast<const char*>(row->lpProps[3].Value.bin.lpb), row->lpProps[3].Value.bin.cb);
+if (extendedFlags[2] & 8) { // Synchronization issues, skip like Outlook
+special = true;
+}
+} else if (row->lpProps[4].ulPropTag == PR_FOLDER_TYPE) {
+if (row->lpProps[4].Value.ul != FOLDER_GENERIC) {
+special = true;
+}
+} else {
+special = true;
+}
+#endif
+FreeProws(rows);
+if (special) {
+// Doesn't contain messages that should be searched...
+}  else {
+_subFolders.append(entryId);
+}
+} else {
+// We have retrieved all rows
+FreeProws(rows);
+break;
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Error getting rows from sub folder table.";
+break;
+}
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to set columns on folder table.";
+}
+mapiRelease(subFolders);
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to get hierarchy table for folder:" << name();
+}
+}
+}
+MapiFolderPtr MapiFolder::nextSubFolder(QMessageManager::Error *error)
+{
+MapiFolderPtr result;
+if (!_hasSubFolders)
+return result;
+if (!_init) {
+_init = true;
+findSubFolders(error);
+if (*error != QMessageManager::NoError) {
+qWarning() << "Unable to find sub folders.";
+return result;
+}
+}
+if (!_subFolders.isEmpty()) {
+result = _store->openFolder(error, _subFolders.takeFirst());
+} else {
+// Allow the traversal to be restarted
+_init = false;
+}
+return result;
+}
+LPMAPITABLE MapiFolder::queryBegin(QMessageManager::Error *error, const QMessageFilter &filter, const QMessageSortOrder &sortOrder)
+{
+if (!_valid || !_folder) {
+Q_ASSERT(_valid && _folder);
+*error = QMessageManager::FrameworkFault;
+return 0;
+}
+MapiRestriction restriction(filter);
+if (!restriction.isValid()) {
+*error = QMessageManager::ConstraintFailure;
+return 0;
+}
+LPMAPITABLE messagesTable(0);
+HRESULT rv = _folder->GetContentsTable(MAPI_UNICODE, &messagesTable);
+if (HR_SUCCEEDED(rv)) {
+SizedSPropTagArray(2, columns) = {2, {PR_ENTRYID, PR_RECORD_KEY}};
+rv = messagesTable->SetColumns(reinterpret_cast<LPSPropTagArray>(&columns), 0);
+if (HR_SUCCEEDED(rv)) {
+if (!sortOrder.isEmpty()) {
+QMessageSortOrderPrivate::sortTable(error, sortOrder, messagesTable);
+}
+if (!restriction.isEmpty()) {
+ULONG flags(0);
+if (messagesTable->Restrict(restriction.sRestriction(), flags) != S_OK)
+*error = QMessageManager::ConstraintFailure;
+}
+if (*error != QMessageManager::NoError) {
+return 0;
+}
+return messagesTable;
+} else {
+*error = QMessageManager::ContentInaccessible;
+return 0;
+}
+mapiRelease(messagesTable);
+messagesTable = 0;
+} else {
+*error = QMessageManager::ContentInaccessible;
+return 0;
+}
+return 0;
+}
+QMessageIdList MapiFolder::queryNext(QMessageManager::Error *error, LPMAPITABLE messagesTable, const QMessageFilter &filter)
+{
+QMessageIdList result;
+while (true) {
+LPSRowSet rows(0);
+HRESULT rv = messagesTable->QueryRows(1, 0, &rows);
+if (HR_SUCCEEDED(rv)) {
+if (rows->cRows == 1) {
+LPSPropValue entryIdProp(&rows->aRow[0].lpProps[0]);
+LPSPropValue recordKeyProp(&rows->aRow[0].lpProps[1]);
+MapiRecordKey recordKey(recordKeyProp->Value.bin.lpb, recordKeyProp->Value.bin.cb);
+MapiEntryId entryId(entryIdProp->Value.bin.lpb, entryIdProp->Value.bin.cb);
+#ifdef _WIN32_WCE
+QMessageId id(QMessageIdPrivate::from(_store->entryId(), entryId, recordKey, _entryId));
+#else
+QMessageId id(QMessageIdPrivate::from(_store->recordKey(), entryId, recordKey, _key));
+#endif
+FreeProws(rows);
+if (QMessageFilterPrivate::matchesMessageRequired(filter)
+&& !QMessageFilterPrivate::matchesMessageSimple(filter, QMessage(id)))
+continue;
+result.append(id);
+return result;
+} else {
+// We have retrieved all rows
+FreeProws(rows);
+return result;
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to query rows in message table.";
+return result;
+}
+}
+}
+void MapiFolder::queryEnd(LPMAPITABLE messagesTable)
+{
+mapiRelease(messagesTable);
+}
+uint MapiFolder::countMessages(QMessageManager::Error *error, const QMessageFilter &filter) const
+{
+uint result(0);
+if (!_valid || !_folder) {
+Q_ASSERT(_valid && _folder);
+*error = QMessageManager::FrameworkFault;
+return result;
+}
+MapiRestriction restriction(filter);
+if (!restriction.isValid()) {
+*error = QMessageManager::ConstraintFailure;
+return result;
+}
+IMAPITable *messagesTable(0);
+HRESULT rv = _folder->GetContentsTable(MAPI_UNICODE, &messagesTable);
+if (HR_SUCCEEDED(rv)) {
+if (!restriction.isEmpty()) {
+ULONG flags(0);
+rv = messagesTable->Restrict(restriction.sRestriction(), flags);
+if (HR_FAILED(rv)) {
+*error = QMessageManager::ConstraintFailure;
+qWarning() << "Unable to set restriction on message table.";
+}
+}
+if (*error == QMessageManager::NoError) {
+ULONG count(0);
+rv = messagesTable->GetRowCount(0, &count);
+if (HR_SUCCEEDED(rv)) {
+result = count;
+} else {
+qWarning() << "Unable to count messages in folder.";
+}
+}
+mapiRelease(messagesTable);
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to get folder contents table.";
+}
+return result;
+}
+void MapiFolder::removeMessages(QMessageManager::Error *error, const QMessageIdList &ids)
+{
+SBinary *bin(0);
+if (MAPIAllocateBuffer(ids.count() * sizeof(SBinary), reinterpret_cast<LPVOID*>(&bin)) != S_OK) {
+return;
+}
+int index = 0;
+foreach (const QMessageId &id, ids) {
+MapiEntryId entryId(QMessageIdPrivate::entryId(id));
+bin[index].cb = entryId.count();
+if (MAPIAllocateMore(bin[index].cb, bin, reinterpret_cast<LPVOID*>(&bin[index].lpb)) != S_OK) {
+break;
+}
+memcpy(bin[index].lpb, entryId.constData(), bin[index].cb);
+++index;
+}
+if (index > 0) {
+ENTRYLIST entryList = { 0 };
+entryList.cValues = index;
+entryList.lpbin = bin;
+ULONG flags(0);
+//flags |= DELETE_HARD_DELETE;  this flag is only available when the store is exchange...
+HRESULT rv = _folder->DeleteMessages(&entryList, 0, 0, flags);
+if (HR_FAILED(rv)) {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to delete messages from folder.";
+}
+}
+MAPIFreeBuffer(bin);
+}
+MapiEntryId MapiFolder::messageEntryId(QMessageManager::Error *error, const MapiRecordKey &messageKey)
+{
+MapiEntryId result;
+MapiRecordKey key(messageKey);
+IMAPITable *messagesTable(0);
+HRESULT rv = _folder->GetContentsTable(MAPI_UNICODE, &messagesTable);
+if (HR_SUCCEEDED(rv)) {
+SPropValue keyProp;
+keyProp.ulPropTag = PR_RECORD_KEY;
+keyProp.Value.bin.cb = key.count();
+keyProp.Value.bin.lpb = reinterpret_cast<LPBYTE>(key.data());
+SRestriction restriction;
+restriction.rt = RES_PROPERTY;
+restriction.res.resProperty.relop = RELOP_EQ;
+restriction.res.resProperty.ulPropTag = PR_RECORD_KEY;
+restriction.res.resProperty.lpProp = &keyProp;
+ULONG flags(0);
+rv = messagesTable->Restrict(&restriction, flags);
+if (HR_SUCCEEDED(rv)) {
+SizedSPropTagArray(1, columns) = {1, {PR_ENTRYID}};
+rv = messagesTable->SetColumns(reinterpret_cast<LPSPropTagArray>(&columns), 0);
+if (HR_SUCCEEDED(rv)) {
+LPSRowSet rows(0);
+rv = messagesTable->QueryRows(1, 0, &rows);
+if (HR_SUCCEEDED(rv)) {
+if (rows->cRows == 1) {
+LPSPropValue entryIdProp(&rows->aRow[0].lpProps[0]);
+result = MapiEntryId(entryIdProp->Value.bin.lpb, entryIdProp->Value.bin.cb);
+} else {
+*error = QMessageManager::InvalidId;
+}
+FreeProws(rows);
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to query rows from message table.";
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to set columns on message table.";
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to restrict content table.";
+}
+mapiRelease(messagesTable);
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to get contents table for folder.";
+}
+return result;
+}
+IMessage *MapiFolder::openMessage(QMessageManager::Error *error, const MapiEntryId &entryId)
+{
+IMessage *message(0);
+LPENTRYID entryIdPtr(reinterpret_cast<LPENTRYID>(const_cast<char*>(entryId.data())));
+ULONG objectType(0);
+HRESULT rv = _folder->OpenEntry(entryId.count(), entryIdPtr, 0, MAPI_BEST_ACCESS, &objectType, reinterpret_cast<LPUNKNOWN*>(&message));
+if (rv != S_OK) {
+*error = QMessageManager::InvalidId;
+qWarning() << "Invalid message entryId:" << entryId.toBase64();
+}
+return message;
+}
+QMessageFolder MapiFolder::folder(QMessageManager::Error *error, const QMessageFolderId& id) const
+{
+return _store->folder(error, id);
+}
+QMessage MapiFolder::message(QMessageManager::Error *error, const QMessageId& id) const
+{
+return _store->message(error, id);
+}
+QMessage::StandardFolder MapiFolder::standardFolder() const
+{
+return _store->standardFolder(_entryId);
+}
+QMessageFolderId MapiFolder::id() const
+{
+#ifdef _WIN32_WCE
+return QMessageFolderIdPrivate::from(_key, _store->entryId(), _entryId);
+#else
+return QMessageFolderIdPrivate::from(_key, _store->recordKey(), _entryId);
+#endif
+}
+QMessageAccountId MapiFolder::accountId() const
+{
+return _store->id();
+}
+QMessageFolderId MapiFolder::parentId() const
+{
+MapiEntryId parentEntryId;
+if (getMapiProperty(_folder, PR_PARENT_ENTRYID, &parentEntryId)) {
+QMessageManager::Error ignoredError(QMessageManager::NoError);
+MapiFolderPtr parent(_store->openFolder(&ignoredError, parentEntryId));
+if (!parent.isNull()) {
+QMessageManager::Error ignoredError(QMessageManager::NoError);
+MapiFolderPtr root(_store->rootFolder(&ignoredError));
+if ((ignoredError != QMessageManager::NoError)
+|| !_store->session()->equal(parent->entryId(), root->entryId())) {
+return parent->id();
+}
+}
+}
+return QMessageFolderId();
+}
+QList<QMessageFolderId> MapiFolder::ancestorIds() const
+{
+QList<QMessageFolderId> result;
+QMessageManager::Error ignoredError(QMessageManager::NoError);
+MapiFolderPtr root(_store->rootFolder(&ignoredError));
+if (ignoredError == QMessageManager::NoError) {
+MapiFolderPtr current = _self.toStrongRef();
+MapiSessionPtr session = _store->session();
+while ((ignoredError == QMessageManager::NoError) && !session->equal(current->entryId(), root->entryId())) {
+// Find the parent of this folder and append to the list of ancestors
+MapiEntryId parentEntryId;
+if (getMapiProperty(current->_folder, PR_PARENT_ENTRYID, &parentEntryId)) {
+QMessageManager::Error ignoredError(QMessageManager::NoError);
+current = _store->openFolder(&ignoredError, parentEntryId);
+if (!current.isNull() && !session->equal(current->entryId(), root->entryId())) {
+result.append(current->id());
+}
+}
+}
+}
+return result;
+}
+MapiRecordKey MapiFolder::storeKey() const
+{
+return _store->recordKey();
+}
+#ifdef _WIN32_WCE
+MapiEntryId MapiFolder::storeEntryId() const
+{
+return _store->entryId();
+}
+#endif
+static unsigned long commonFolderMap(QMessage::StandardFolder folder)
+{
+static bool init = false;
+static QMap<QMessage::StandardFolder,unsigned long> propertyMap;
+if(!init)
+{
+propertyMap.insert(QMessage::DraftsFolder,PROP_TAG(PT_BINARY,0x36D7));
+propertyMap.insert(QMessage::TrashFolder,PROP_TAG(PT_BINARY,0x35E3));
+propertyMap.insert(QMessage::OutboxFolder,PROP_TAG(PT_BINARY,0x35E2));
+propertyMap.insert(QMessage::SentFolder,PROP_TAG(PT_BINARY,0x35E4));
+init = true;
+}
+return propertyMap.value(folder);
+}
+IMessage *MapiFolder::createMessage(QMessageManager::Error* error)
+{
+IMessage *message = 0;
+if(FAILED(_folder->CreateMessage(NULL, 0, &message)!=S_OK))
+{
+*error = QMessageManager::FrameworkFault;
+mapiRelease(message);
+}
+return message;
+}
+IMessage* MapiFolder::createMessage(QMessageManager::Error* error, const QMessage& source, const MapiSessionPtr &session, SavePropertyOption saveOption )
+{
+IMessage* mapiMessage(0);
+HRESULT rv = _folder->CreateMessage(0, 0, &mapiMessage);
+if (HR_SUCCEEDED(rv)) {
+// Store the message properties
+if (*error == QMessageManager::NoError) {
+storeMessageProperties(error, source, mapiMessage);
+}
+#ifndef _WIN32_WCE
+//Ensure the message is moved to the sent folder after submission
+//On Windows Mobile occurs by default and at discretion of mail client settings.
+MapiFolderPtr sentFolder = _store->findFolder(error,QMessage::SentFolder);
+if (!sentFolder.isNull() && *error == QMessageManager::NoError) {
+if (!setMapiProperty(mapiMessage, PR_SENTMAIL_ENTRYID, sentFolder->entryId())) {
+qWarning() << "Unable to set sent folder entry id on message";
+}
+}
+#endif
+if (*error == QMessageManager::NoError) {
+replaceMessageRecipients(error, source, mapiMessage, session->session());
+}
+if (*error == QMessageManager::NoError) {
+replaceMessageBody(error, source, mapiMessage, _store);
+}
+if (*error == QMessageManager::NoError) {
+addMessageAttachments(error, source, mapiMessage, saveOption );
+}
+#ifndef _WIN32_WCE //unsupported
+if (*error == QMessageManager::NoError && saveOption == SavePropertyChanges ) {
+if (HR_FAILED(mapiMessage->SaveChanges(0))) {
+qWarning() << "Unable to save changes for message.";
+}
+}
+#endif
+if (*error != QMessageManager::NoError) {
+mapiRelease(mapiMessage);
+}
+} else {
+qWarning() << "Failed to create MAPI message";
+*error = QMessageManager::FrameworkFault;
+}
+return mapiMessage;
+}
+MapiStorePtr MapiStore::createStore(QMessageManager::Error *error, const MapiSessionPtr &session, IMsgStore *store, const MapiRecordKey &key, const MapiEntryId &entryId, const QString &name, bool cachedMode)
+{
+Q_UNUSED(error);
+MapiStorePtr ptr = MapiStorePtr(new MapiStore(session, store, key, entryId, name, cachedMode));
+if (!ptr.isNull()) {
+ptr->_self = ptr;
+}
+return ptr;
+}
+MapiStore::MapiStore()
+:_valid(false),
+_store(0),
+_cachedMode(true),
+_adviseConnection(0)
+{
+}
+MapiStore::MapiStore(const MapiSessionPtr &session, IMsgStore *store, const MapiRecordKey &key, const MapiEntryId &entryId, const QString &name, bool cachedMode)
+:_session(session),
+_valid(true),
+_store(store),
+_key(key),
+_entryId(entryId),
+_name(name),
+_cachedMode(cachedMode),
+_adviseConnection(0)
+{
+// Find which standard folders the store contains
+foreach (QMessage::StandardFolder sf, QList<QMessage::StandardFolder>() << QMessage::InboxFolder
+<< QMessage::DraftsFolder
+<< QMessage::TrashFolder
+<< QMessage::SentFolder
+<< QMessage::OutboxFolder) {
+QMessageManager::Error ignoredError(QMessageManager::NoError);
+MapiEntryId entryId(standardFolderId(&ignoredError, sf));
+if (!entryId.isEmpty()) {
+_standardFolderId[sf] = entryId;
+}
+}
+}
+MapiStore::~MapiStore()
+{
+_folderMap.clear();
+if (_adviseConnection != 0) {
+_store->Unadvise(_adviseConnection);
+}
+mapiRelease(_store);
+_valid = false;
+}
+MapiFolderPtr MapiStore::findFolder(QMessageManager::Error *error, QMessage::StandardFolder sf)
+{
+MapiFolderPtr result;
+if (_standardFolderId.contains(sf)) {
+result = openFolder(error, _standardFolderId[sf]);
+}
+return result;
+}
+MapiEntryId MapiStore::standardFolderId(QMessageManager::Error *error, QMessage::StandardFolder sf) const
+{
+MapiEntryId result;
+#ifndef _WIN32_WCE
+//check if the store supports the common folder (not possible for mobile)
+bool commonFolderSupported(false);
+unsigned long tag(0);
+switch(sf)
+{
+case QMessage::InboxFolder:
+tag = FOLDER_IPM_INBOX_VALID;
+break;
+case QMessage::OutboxFolder:
+tag = FOLDER_IPM_OUTBOX_VALID;
+break;
+case QMessage::TrashFolder:
+tag = FOLDER_IPM_WASTEBASKET_VALID;
+break;
+case QMessage::SentFolder:
+tag = FOLDER_IPM_SENTMAIL_VALID;
+break;
+case QMessage::DraftsFolder:
+//assume drafts exists in every store since there is no mask for it
+commonFolderSupported = true;
+break;
+}
+if (tag) {
+ULONG folderSupportMask(0);
+if (getMapiProperty(_store, PR_VALID_FOLDER_MASK, &folderSupportMask)) {
+if (folderSupportMask & tag) {
+commonFolderSupported = true;
+}
+} else {
+qWarning() << "Could not get folder mask property for store:" << _name;
+}
+}
+if (!commonFolderSupported) {
+return result;
+}
+#endif
+if (sf == QMessage::InboxFolder) {
+result = receiveFolderId(error);
+} else {
+IMAPIProp* source = _store;
+MapiFolderPtr rf;
+#ifndef _WIN32_WCE
+//the drafts entryid can only be queried on the inbox or root folder.
+if(sf == QMessage::DraftsFolder) {
+rf = receiveFolder(error);
+if(*error != QMessageManager::NoError) {
+//inbox failed, try root folder.
+rf = rootFolder(error);
+if(*error != QMessageManager::NoError)
+{
+return result;
+}
+}
+source = rf->folder();
+}
+#endif
+MapiEntryId entryId;
+if (getMapiProperty(source, commonFolderMap(sf), &entryId)) {
+result = entryId;
+} else {
+*error = QMessageManager::ContentInaccessible;
+}
+}
+return result;
+}
+QMessageFolderIdList MapiStore::folderIds(QMessageManager::Error *error) const
+{
+QMessageFolderIdList folderIds;
+MapiFolderPtr root(rootFolder(error));
+if (*error == QMessageManager::NoError) {
+QList<MapiFolderPtr> folders;
+folders.append(root);
+// No valid reason to list the root folder.
+while (!folders.isEmpty()) {
+MapiFolderPtr subFolder(folders.back()->nextSubFolder(error));
+if (!subFolder.isNull() && subFolder->isValid()) {
+folderIds.append(subFolder->id());
+folders.append(subFolder);
+} else {
+folders.pop_back();
+}
+}
+} else {
+qWarning() << "Unable to open root folder for store:" << _name;
+}
+return folderIds;
+}
+QMessageFolder MapiStore::folderFromId(QMessageManager::Error *error, const QMessageFolderId &folderId)
+{
+QMessageFolder result;
+QList<MapiFolderPtr> folders;
+MapiFolderPtr root(rootFolder(error));
+if (!root.isNull() && root->isValid())
+folders.append(root);
+while (!folders.isEmpty()) {
+MapiFolderPtr subFolder(folders.back()->nextSubFolder(error));
+if (!subFolder.isNull() && subFolder->isValid()) {
+if (folderId == subFolder->id()) {
+QStringList path;
+for (int i = 0; i < folders.count(); ++i) {
+if (!folders[i]->name().isEmpty()) {
+path.append(folders[i]->name());
+}
+}
+path.append(subFolder->name());
+result = QMessageFolderPrivate::from(subFolder->id(), id(), folders.last()->id(), subFolder->name(), path.join("/"));
+return result;
+}
+folders.append(subFolder);
+} else {
+folders.pop_back();
+}
+}
+return result;
+}
+QList<MapiFolderPtr> MapiStore::filterFolders(QMessageManager::Error *error, const QMessageFolderFilter &afilter) const
+{
+QList<MapiFolderPtr> result;
+QMessageFolderFilter filter(QMessageFolderFilterPrivate::preprocess(error, _session, afilter));
+if (*error != QMessageManager::NoError)
+return result;
+#if 0 //(was ifndef _WIN32_WCE) TODO: fix issue with GetHierarchyTable only returning top level folders
+MapiFolderPtr root(rootFolder(error));
+if (*error == QMessageManager::NoError) {
+IMAPITable *folderTable(0);
+HRESULT rv = root->_folder->GetHierarchyTable(CONVENIENT_DEPTH | MAPI_UNICODE, &folderTable);
+if (HR_SUCCEEDED(rv)) {
+SizedSPropTagArray(5, columns) = {5, {PR_ENTRYID, PR_IS_NEWSGROUP, PR_IS_NEWSGROUP_ANCHOR, PR_EXTENDED_FOLDER_FLAGS, PR_FOLDER_TYPE}};
+QueryAllRows qar(folderTable, reinterpret_cast<LPSPropTagArray>(&columns), 0, 0, false);
+while (qar.query()) {
+for (uint n = 0; n < qar.rows()->cRows; ++n) {
+SPropValue *props = qar.rows()->aRow[n].lpProps;
+bool isNewsGroup = (props[1].ulPropTag == PR_IS_NEWSGROUP && props[1].Value.b);
+bool isNewsGroupAnchor = (props[2].ulPropTag == PR_IS_NEWSGROUP_ANCHOR && props[2].Value.b);
+bool special(isNewsGroup || isNewsGroupAnchor);
+// Skip slow folders, necessary evil
+if (props[3].ulPropTag == PR_EXTENDED_FOLDER_FLAGS) {
+QByteArray extendedFlags(reinterpret_cast<const char*>(props[3].Value.bin.lpb), props[3].Value.bin.cb);
+if (extendedFlags[2] & 8) { // Synchronization issues, skip like Outlook
+special = true;
+}
+} else if (props[4].ulPropTag == PR_FOLDER_TYPE) {
+if (props[4].Value.ul != FOLDER_GENERIC) {
+special = true;
+}
+} else {
+special = true;
+}
+if (!special) {
+MapiEntryId entryId(props[0].Value.bin.lpb, props[0].Value.bin.cb);
+MapiFolderPtr folder(openFolder(error, entryId));
+if (QMessageFolderFilterPrivate::matchesFolder(filter, folder)) {
+result.append(folder);
+}
+}
+}
+}
+*error = qar.error();
+mapiRelease(folderTable);
+}
+}
+#else
+// Windows mobile does not support CONVENIENT_DEPTH...
+foreach (const QMessageFolderId &folderId, folderIds(error)) {
+MapiEntryId entryId = QMessageFolderIdPrivate::entryId(folderId);
+MapiFolderPtr folder(openFolder(error, entryId));
+if (QMessageFolderFilterPrivate::matchesFolder(filter, folder)) {
+result.append(folder);
+}
+}
+#endif
+return result;
+}
+MapiEntryId MapiStore::messageEntryId(QMessageManager::Error *error, const MapiRecordKey &folderKey, const MapiRecordKey &messageKey)
+{
+MapiEntryId result;
+MapiFolderPtr folder(openFolderWithKey(error, folderKey));
+if (*error == QMessageManager::NoError) {
+result = folder->messageEntryId(error, messageKey);
+}
+return result;
+}
+MapiFolderPtr MapiStore::openFolder(QMessageManager::Error *error, const MapiEntryId& entryId) const
+{
+MapiFolderPtr result(0);
+// See if we can create a new pointer to an existing folder
+QWeakPointer<MapiFolder> &existing = _folderMap[entryId];
+if (!existing.isNull()) {
+// Get a pointer to the existing folder
+result = existing.toStrongRef();
+if (!result.isNull()) {
+return result;
+}
+}
+// We need to create a new instance
+IMAPIFolder *folder = openMapiFolder(error, entryId);
+if (folder && (*error == QMessageManager::NoError)) {
+SizedSPropTagArray(4, columns) = {4, {PR_DISPLAY_NAME, PR_RECORD_KEY, PR_CONTENT_COUNT, PR_SUBFOLDERS}};
+SPropValue *properties(0);
+ULONG count;
+HRESULT rv = folder->GetProps(reinterpret_cast<LPSPropTagArray>(&columns), MAPI_UNICODE, &count, &properties);
+if (HR_SUCCEEDED(rv)) {
+QString name(QStringFromLpctstr(properties[0].Value.LPSZ));
+MapiRecordKey recordKey(properties[1].Value.bin.lpb, properties[1].Value.bin.cb);
+uint messageCount = properties[2].Value.ul;
+bool hasSubFolders = properties[3].Value.b;
+MapiFolderPtr folderPtr = MapiFolder::createFolder(error, _self.toStrongRef(), folder, recordKey, name, entryId, hasSubFolders, messageCount);
+if (*error == QMessageManager::NoError) {
+result = folderPtr;
+// Add to the map
+_folderMap.insert(entryId, result);
+} else {
+qWarning() << "Error creating folder object";
+}
+MAPIFreeBuffer(properties);
+} else {
+qWarning() << "Unable to access folder properties";
+mapiRelease(folder);
+}
+} else {
+qWarning() << "Unable to open folder.";
+}
+return result;
+}
+MapiFolderPtr MapiStore::openFolderWithKey(QMessageManager::Error *error, const MapiRecordKey &recordKey) const
+{
+#if 0 // Doesn't work on desktop or mobile, only searches top level folders
+MapiFolderPtr result;
+MapiFolderPtr root(rootFolder(error));
+if (*error == QMessageManager::NoError) {
+if (root->recordKey() == recordKey) {
+result = root;
+} else {
+IMAPITable *folderTable(0);
+// TODO: this won't work on windows mobile:
+HRESULT rv = root->_folder->GetHierarchyTable(CONVENIENT_DEPTH | MAPI_UNICODE, &folderTable);
+if (HR_SUCCEEDED(rv)) {
+// Find the entry ID corresponding to this recordKey
+SPropValue keyProp = { 0 };
+keyProp.ulPropTag = PR_RECORD_KEY;
+keyProp.Value.bin.cb = recordKey.count();
+keyProp.Value.bin.lpb = reinterpret_cast<LPBYTE>(const_cast<char*>(recordKey.data()));
+SRestriction restriction = { 0 };
+restriction.rt = RES_PROPERTY;
+restriction.res.resProperty.relop = RELOP_EQ;
+restriction.res.resProperty.ulPropTag = PR_RECORD_KEY;
+restriction.res.resProperty.lpProp = &keyProp;
+ULONG flags(0);
+rv = folderTable->Restrict(&restriction, flags);
+if (HR_SUCCEEDED(rv)) {
+SizedSPropTagArray(1, columns) = {1, {PR_ENTRYID}};
+rv = folderTable->SetColumns(reinterpret_cast<LPSPropTagArray>(&columns), 0);
+if (HR_SUCCEEDED(rv)) {
+SRowSet *rows(0);
+if (folderTable->QueryRows(1, 0, &rows) == S_OK) {
+if (rows->cRows == 1) {
+MapiEntryId entryId(rows->aRow[0].lpProps[0].Value.bin.lpb, rows->aRow[0].lpProps[0].Value.bin.cb);
+// Open the folder using its entry ID
+result = openFolder(error, entryId);
+} else {
+*error = QMessageManager::InvalidId;
+}
+FreeProws(rows);
+} else {
+*error = QMessageManager::InvalidId;
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to set columns for folder table";
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to restrict folder table";
+}
+mapiRelease(folderTable);
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to open hierarchy table for store.";
+}
+}
+}
+return result;
+#else
+foreach (const QMessageFolderId &folderId, folderIds(error)) {
+MapiRecordKey key = QMessageFolderIdPrivate::folderRecordKey(folderId);
+if (key == recordKey) {
+MapiEntryId entryId = QMessageFolderIdPrivate::entryId(folderId);
+MapiFolderPtr folder(openFolder(error, entryId));
+return folder;
+}
+}
+return MapiFolderPtr();
+#endif
+}
+bool MapiStore::supports(ULONG featureFlag) const
+{
+LONG supportMask(0);
+if (getMapiProperty(store(), PR_STORE_SUPPORT_MASK, &supportMask)) {
+return supportMask & featureFlag;
+}
+// Otherwise, we can't query the store support, so just assume that the feature is supported
+return true;
+}
+IMessage *MapiStore::openMessage(QMessageManager::Error *error, const MapiEntryId &entryId)
+{
+IMessage *message(0);
+LPENTRYID entryIdPtr(reinterpret_cast<LPENTRYID>(const_cast<char*>(entryId.data())));
+ULONG objectType(0);
+HRESULT rv = _store->OpenEntry(entryId.count(), entryIdPtr, 0, MAPI_BEST_ACCESS, &objectType, reinterpret_cast<LPUNKNOWN*>(&message));
+if (HR_SUCCEEDED(rv)) {
+if (objectType != MAPI_MESSAGE) {
+qWarning() << "Not a message - wrong object type:" << objectType;
+mapiRelease(message);
+*error = QMessageManager::InvalidId;
+}
+} else {
+*error = QMessageManager::InvalidId;
+qWarning() << "Invalid message entryId:" << entryId.toBase64();
+}
+return message;
+}
+IMAPIFolder *MapiStore::openMapiFolder(QMessageManager::Error *error, const MapiEntryId &entryId) const
+{
+IMAPIFolder *folder(0);
+// TODO:See MS KB article 312013, OpenEntry is not re-entrant, also true of MAPI functions in general?
+// TODO:See ms859378, GetPropsExample for alternative memory allocation technique
+LPENTRYID entryIdPtr(reinterpret_cast<LPENTRYID>(const_cast<char*>(entryId.data())));
+ULONG objectType(0);
+HRESULT rv = _store->OpenEntry(entryId.count(), entryIdPtr, 0, MAPI_BEST_ACCESS, &objectType, reinterpret_cast<LPUNKNOWN*>(&folder));
+if (HR_SUCCEEDED(rv)) {
+if (objectType != MAPI_FOLDER) {
+qWarning() << "Not a folder - wrong object type:" << objectType;
+mapiRelease(folder);
+*error = QMessageManager::InvalidId;
+}
+} else {
+*error = QMessageManager::InvalidId;
+qWarning() << "Invalid folder entryId:" << entryId.toBase64();
+}
+return folder;
+}
+QMessageAccountId MapiStore::id() const
+{
+#ifdef _WIN32_WCE
+return QMessageAccountIdPrivate::from(_entryId);
+#else
+return QMessageAccountIdPrivate::from(_key);
+#endif
+}
+QMessage::TypeFlags MapiStore::types() const
+{
+QMessage::TypeFlags flags(QMessage::Email);
+#ifdef _WIN32_WCE
+if (name().toUpper() == "SMS") {
+// On Windows Mobile SMS store is named "SMS"
+flags = QMessage::Sms;
+}
+#endif
+return flags;
+}
+// TODO: can we remove this?
+QMessageAddress MapiStore::address() const
+{
+QMessageAddress result;
+return result;
+}
+MapiSessionPtr MapiStore::session() const
+{
+return _session.toStrongRef();
+}
+MapiFolderPtr MapiStore::rootFolder(QMessageManager::Error *error) const
+{
+MapiFolderPtr result;
+MapiEntryId entryId(rootFolderId(error));
+if (*error == QMessageManager::NoError) {
+result = openFolder(error, entryId);
+}
+return result;
+}
+MapiEntryId MapiStore::rootFolderId(QMessageManager::Error *error) const
+{
+MapiEntryId result;
+if (!_valid || !_store) {
+Q_ASSERT(_valid && _store);
+*error = QMessageManager::FrameworkFault;
+return result;
+}
+MapiEntryId entryId;
+if (getMapiProperty(_store, PR_IPM_SUBTREE_ENTRYID, &entryId)) {
+result = entryId;
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to get root folder entry ID for store:" << _name;
+}
+return result;
+}
+MapiFolderPtr MapiStore::receiveFolder(QMessageManager::Error *error) const
+{
+MapiFolderPtr result;
+MapiEntryId entryId(receiveFolderId(error));
+if (*error == QMessageManager::NoError) {
+result = openFolder(error, entryId);
+}
+return result;
+}
+MapiEntryId MapiStore::receiveFolderId(QMessageManager::Error *error) const
+{
+MapiEntryId result;
+if (!_valid || !_store) {
+Q_ASSERT(_valid && _store);
+*error = QMessageManager::FrameworkFault;
+return result;
+}
+ULONG entryIdSize = 0;
+LPENTRYID entryIdPtr = 0;
+HRESULT rv = _store->GetReceiveFolder(0, 0, &entryIdSize, &entryIdPtr, 0);
+if (HR_SUCCEEDED(rv)) {
+result = MapiEntryId(entryIdPtr, entryIdSize);
+MAPIFreeBuffer(entryIdPtr);
+} else {
+*error = QMessageManager::FrameworkFault;
+}
+return result;
+}
+QMessageFolder MapiStore::folder(QMessageManager::Error *error, const QMessageFolderId& id) const
+{
+return _session.toStrongRef()->folder(error, id);
+}
+QMessage MapiStore::message(QMessageManager::Error *error, const QMessageId& id) const
+{
+return _session.toStrongRef()->message(error, id);
+}
+QMessage::StandardFolder MapiStore::standardFolder(const MapiEntryId &entryId) const
+{
+QMap<QMessage::StandardFolder, MapiEntryId>::const_iterator it = _standardFolderId.begin(), end = _standardFolderId.end();
+for ( ; it != end; ++it) {
+if (_session.toStrongRef()->equal(it.value(), entryId)) {
+return it.key();
+}
+}
+return QMessage::DraftsFolder;
+}
+bool MapiStore::setAdviseSink(ULONG mask, IMAPIAdviseSink *sink)
+{
+if (_adviseConnection != 0) {
+_store->Unadvise(_adviseConnection);
+}
+HRESULT rv = _store->Advise(0, 0, mask, sink, &_adviseConnection);
+if (HR_FAILED(rv)) {
+qWarning() << "Unable to register for notifications from store.";
+return false;
+}
+return true;
+}
+void MapiStore::notifyEvents(ULONG mask)
+{
+// Test whether this store supports notifications
+if (supports(STORE_NOTIFY_OK)) {
+AdviseSink *sink(new AdviseSink(this));
+if (setAdviseSink(mask, sink)) {
+// sink will be deleted when the store releases it
+} else {
+delete sink;
+}
+} else {
+qWarning() << "Store does not support notifications.";
+}
+}
+#ifdef _WIN32_WCE
+QString MapiStore::transportName() const
+{
+QString result;
+if(!getMapiProperty(_store,PR_CE_TRANSPORT_NAME,&result))
+qWarning() << "Could not query transport name for store " << name();
+return result;
+}
+#endif
+HRESULT MapiStore::AdviseSink::QueryInterface(REFIID id, LPVOID FAR* o)
+{
+if (id == IID_IUnknown) {
+*o = this;
+AddRef();
+return S_OK;
+}
+return E_NOINTERFACE;
+}
+ULONG MapiStore::AdviseSink::AddRef()
+{
+return InterlockedIncrement(&_refCount);
+}
+ULONG MapiStore::AdviseSink::Release()
+{
+ULONG result = InterlockedDecrement(&_refCount);
+if (result == 0) {
+delete this;
+}
+return result;
+}
+ULONG MapiStore::AdviseSink::OnNotify(ULONG notificationCount, LPNOTIFICATION notifications)
+{
+MapiSessionPtr session = _store->_session.toStrongRef();
+if (!session.isNull()) {
+for (uint i = 0; i < notificationCount; ++i) {
+NOTIFICATION &notification(notifications[i]);
+if (notification.ulEventType == fnevNewMail) {
+// TODO: Do we need to process this, or is handling object-created sufficient?
+//NEWMAIL_NOTIFICATION &newmail(notification.info.newmail);
+} else {
+OBJECT_NOTIFICATION &object(notification.info.obj);
+if (object.ulObjType == MAPI_MESSAGE) {
+MapiEntryId entryId(object.lpEntryID, object.cbEntryID);
+if (!entryId.isEmpty()) {
+// Create a partial ID from the information we have (a message can be
+// retrieved using only the store key and the message entry ID)
+#ifdef _WIN32_WCE
+QMessageId messageId(QMessageIdPrivate::from(_store->entryId(),entryId));
+#else
+QMessageId messageId(QMessageIdPrivate::from(_store->recordKey(), entryId));
+#endif
+MapiSession::NotifyType notifyType;
+switch (notification.ulEventType)
+{
+case fnevObjectCopied: notifyType = MapiSession::Added; break;
+case fnevObjectCreated: notifyType = MapiSession::Added; break;
+case fnevObjectDeleted: notifyType = MapiSession::Removed; break;
+case fnevObjectModified: notifyType = MapiSession::Updated; break;
+case fnevObjectMoved: notifyType = MapiSession::Updated; break;
+}
+// Create an event to be processed by the UI thread
+QCoreApplication::postEvent(session.data(), new MapiSession::NotifyEvent(_store, messageId, notifyType));
+} else {
+qWarning() << "Received notification, but no entry ID";
+}
+}
+}
+}
+}
+return 0;
+}
+class SessionManager : public QObject
+{
+Q_OBJECT
+public:
+SessionManager();
+bool initialize(MapiSession *newSession);
+const MapiSessionPtr &session() const;
+private slots:
+void appDestroyed();
+private:
+MapiSessionPtr ptr;
+};
+SessionManager::SessionManager()
+{
+connect(QCoreApplication::instance(), SIGNAL(destroyed()), this, SLOT(appDestroyed()));
+}
+bool SessionManager::initialize(MapiSession *newSession)
+{
+if(newSession->_mapiSession)
+{
+ptr = MapiSessionPtr(newSession);
+ptr->_self = ptr;
+return true;
+}
+return false;
+}
+const MapiSessionPtr &SessionManager::session() const
+{
+return ptr;
+}
+void SessionManager::appDestroyed()
+{
+// We need to terminate the MAPI session before main ends
+ptr.clear();
+}
+Q_GLOBAL_STATIC(SessionManager, manager);
+MapiSessionPtr MapiSession::createSession(QMessageManager::Error *error)
+{
+static bool initialized(manager()->initialize(new MapiSession(error)));
+MapiSessionPtr ptr(manager()->session());
+if (ptr.isNull()) {
+if (*error == QMessageManager::NoError) {
+*error = QMessageManager::ContentInaccessible;
+}
+qWarning() << "Unable to instantiate session";
+}
+return ptr;
+}
+MapiSession::MapiSession()
+:_token(0),
+_mapiSession(0),
+_filterId(0),
+_registered(false)
+{
+}
+MapiSession::MapiSession(QMessageManager::Error *error)
+:QObject(),
+_token(WinHelpers::initializeMapi()),
+_mapiSession(0),
+_filterId(0),
+_registered(false)
+{
+if (!_token->_initialized) {
+*error = QMessageManager::ContentInaccessible;
+} else {
+// Attempt to start a MAPI session on the default profile
+HRESULT rv = MAPILogonEx(0, (LPTSTR)0, 0, MAPI_EXTENDED | MAPI_USE_DEFAULT | MAPI_NEW_SESSION, &_mapiSession);
+if (HR_FAILED(rv)) {
+qWarning() << "Failed to login to MAPI session - rv:" << hex << (ULONG)rv;
+*error = QMessageManager::ContentInaccessible;
+_mapiSession = 0;
+}
+// This thread must run the message pump for the hidden MAPI window
+// http://blogs.msdn.com/stephen_griffin/archive/2009/05/22/the-fifth-mapi-multithreading-rule.aspx
+dispatchNotifications();
+}
+}
+MapiSession::~MapiSession()
+{
+_storeMap.clear();
+if (_mapiSession) {
+_mapiSession->Logoff(0, 0, 0);
+mapiRelease(_mapiSession);
+}
+}
+MapiStorePtr MapiSession::findStore(QMessageManager::Error *error, const QMessageAccountId &id, bool cachedMode) const
+{
+MapiStorePtr result(0);
+if (!_mapiSession) {
+Q_ASSERT(_mapiSession);
+*error = QMessageManager::FrameworkFault;
+return result;
+}
+IMAPITable *mapiMessageStoresTable(0);
+if (_mapiSession->GetMsgStoresTable(0, &mapiMessageStoresTable) != S_OK) {
+*error = QMessageManager::ContentInaccessible;
+return result;
+}
+const int nCols(3);
+enum { defaultStoreColumn = 0, entryIdColumn, recordKeyColumn };
+SizedSPropTagArray(nCols, columns) = {nCols, {PR_DEFAULT_STORE, PR_ENTRYID, PR_RECORD_KEY}};
+QueryAllRows qar(mapiMessageStoresTable, reinterpret_cast<LPSPropTagArray>(&columns), 0, 0, false);
+while(qar.query()) {
+for (uint n = 0; n < qar.rows()->cRows; ++n) {
+SPropValue *props = qar.rows()->aRow[n].lpProps;
+#ifdef _WIN32_WCE
+MapiEntryId storeKey(props[entryIdColumn].Value.bin.lpb, props[entryIdColumn].Value.bin.cb);
+#else
+MapiRecordKey storeKey(props[recordKeyColumn].Value.bin.lpb, props[recordKeyColumn].Value.bin.cb);
+#endif
+if ((!id.isValid() && props[defaultStoreColumn].Value.b) ||  // default store found
+(id.isValid() && (id == QMessageAccountIdPrivate::from(storeKey)))) {    // specified store found
+MapiEntryId entryId(props[entryIdColumn].Value.bin.lpb, props[entryIdColumn].Value.bin.cb);
+result = openStore(error, entryId, cachedMode);
+break;
+}
+}
+}
+*error = qar.error();
+mapiRelease(mapiMessageStoresTable);
+return result;
+}
+template<typename Predicate, typename Ordering>
+QList<MapiStorePtr> MapiSession::filterStores(QMessageManager::Error *error, Predicate predicate, Ordering sortOrder, uint limit, uint offset, bool cachedMode) const
+{
+if (!predicate._filter.isSupported()) {
+*error = QMessageManager::ConstraintFailure;
+return QList<MapiStorePtr>();
+}
+QList<MapiStorePtr> result;
+if (!_mapiSession) {
+Q_ASSERT(_mapiSession);
+*error = QMessageManager::FrameworkFault;
+return result;
+}
+IMAPITable *mapiMessageStoresTable(0);
+if (_mapiSession->GetMsgStoresTable(0, &mapiMessageStoresTable) != S_OK) {
+*error = QMessageManager::ContentInaccessible;
+} else {
+SizedSPropTagArray(1, columns) = {1, {PR_ENTRYID}};
+QueryAllRows qar(mapiMessageStoresTable, reinterpret_cast<LPSPropTagArray>(&columns), 0, 0, false);
+while (qar.query()) {
+for (uint n = 0; n < qar.rows()->cRows; ++n) {
+MapiEntryId entryId(qar.rows()->aRow[n].lpProps[0].Value.bin.lpb, qar.rows()->aRow[n].lpProps[0].Value.bin.cb);
+MapiStorePtr store(openStore(error, entryId, cachedMode));
+if (!store.isNull()) {
+#ifndef _WIN32_WCE
+// We only want stores that contain private messages
+if (store->supports(STORE_PUBLIC_FOLDERS)) {
+continue;
+}
+#endif
+if (predicate(store)) {
+result.append(store);
+}
+}
+}
+}
+*error = qar.error();
+mapiRelease(mapiMessageStoresTable);
+}
+if (!sortOrder.isEmpty()) {
+QList<StoreSortHelper> accountList;
+foreach (MapiStorePtr storePtr, result) {
+accountList.append(StoreSortHelper(&sortOrder, storePtr));
+}
+qSort(accountList.begin(), accountList.end());
+result.clear();
+foreach (StoreSortHelper alt, accountList) {
+result.append(alt.store());
+}
+accountList.clear();
+}
+// See note in filerMessages explaining why IMAPITable::SeekRow can't be used to skip unwanted items
+if (offset) {
+return result.mid(offset, (limit ? limit : -1));
+} else {
+return result;
+}
+}
+QList<MapiStorePtr> MapiSession::filterStores(QMessageManager::Error *error, const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder, uint limit, uint offset, bool cachedMode) const
+{
+AccountFilterPredicate pred(filter);
+return filterStores<const AccountFilterPredicate&, const QMessageAccountSortOrder &>(error, pred, sortOrder, limit, offset, cachedMode);
+}
+QList<MapiStorePtr> MapiSession::allStores(QMessageManager::Error *error, bool cachedMode) const
+{
+return filterStores(error, QMessageAccountFilter(), QMessageAccountSortOrder(), 0, 0, cachedMode);
+}
+QList<MapiFolderPtr> MapiSession::filterFolders(QMessageManager::Error *error, const QMessageFolderFilter &filter, const QMessageFolderSortOrder &sortOrder, uint limit, uint offset, bool cachedMode) const
+{
+if (!filter.isSupported()) {
+*error = QMessageManager::ConstraintFailure;
+return QList<MapiFolderPtr>();
+}
+QList<MapiFolderPtr> result;
+if (!_mapiSession) {
+Q_ASSERT(_mapiSession);
+*error = QMessageManager::FrameworkFault;
+return result;
+}
+foreach (const MapiStorePtr &store, allStores(error, cachedMode)) {
+result.append(store->filterFolders(error, filter));
+}
+if (!sortOrder.isEmpty()) {
+QList<FolderSortHelper> folderList;
+foreach (MapiFolderPtr folderPtr, result) {
+QMessageFolder orderFolder(folder(error, folderPtr->id()));
+if (*error != QMessageManager::NoError) {
+folderList.clear();
+break;
+}
+folderList.append(FolderSortHelper(&sortOrder, folderPtr, orderFolder));
+}
+qSort(folderList.begin(), folderList.end());
+result.clear();
+foreach (FolderSortHelper helper, folderList) {
+result.append(helper.mapiFolderPtr());
+}
+folderList.clear();
+}
+// See note in filerMessages explaining why IMAPITable::SeekRow can't be used to skip unwanted items
+if (offset) {
+return result.mid(offset, (limit ? limit : -1));
+} else {
+return result;
+}
+}
+IMsgStore *MapiSession::openMapiStore(QMessageManager::Error *error, const MapiEntryId &entryId, bool cachedMode) const
+{
+IMsgStore *store(0);
+LPENTRYID entryIdPtr(reinterpret_cast<LPENTRYID>(const_cast<char*>(entryId.data())));
+unsigned long openFlags = MAPI_BEST_ACCESS | MDB_WRITE;
+if(!cachedMode)
+openFlags |= MDB_ONLINE;
+HRESULT rv = _mapiSession->OpenMsgStore(0, entryId.count(), entryIdPtr, 0, openFlags, reinterpret_cast<LPMDB*>(&store));
+if (HR_FAILED(rv)) {
+*error = QMessageManager::InvalidId;
+qWarning() << "Invalid store entryId:" << entryId.toBase64();
+}
+return store;
+}
+MapiStorePtr MapiSession::openStore(QMessageManager::Error *error, const MapiEntryId& entryId, bool cachedMode) const
+{
+MapiStorePtr result(0);
+// See if we can create a new pointer to an existing store
+MapiStorePtr &existing = _storeMap[entryId];
+if (!existing.isNull()) {
+return existing;
+}
+// We need to create a new instance
+IMsgStore *store = openMapiStore(error, entryId, cachedMode);
+if (store && (*error == QMessageManager::NoError)) {
+// Find the other properties of this store
+SizedSPropTagArray(2, columns) = {2, {PR_DISPLAY_NAME, PR_RECORD_KEY}};
+SPropValue *properties(0);
+ULONG count;
+HRESULT rv = store->GetProps(reinterpret_cast<LPSPropTagArray>(&columns), MAPI_UNICODE, &count, &properties);
+if (HR_SUCCEEDED(rv)) {
+QString name(QStringFromLpctstr(properties[0].Value.LPSZ));
+MapiRecordKey recordKey(properties[1].Value.bin.lpb, properties[1].Value.bin.cb);
+MapiStorePtr storePtr = MapiStore::createStore(error, _self.toStrongRef(), store, recordKey, entryId, name, cachedMode);
+if (*error == QMessageManager::NoError) {
+result = storePtr;
+// Add to the map
+_storeMap.insert(entryId, result);
+} else {
+qWarning() << "Error creating store object";
+}
+MAPIFreeBuffer(properties);
+} else {
+qWarning() << "Unable to access store properties";
+mapiRelease(store);
+}
+}
+return result;
+}
+MapiStorePtr MapiSession::openStoreWithKey(QMessageManager::Error *error, const MapiRecordKey &recordKey, bool cachedMode) const
+{
+MapiStorePtr result;
+IMAPITable *storesTable(0);
+HRESULT rv = _mapiSession->GetMsgStoresTable(0, &storesTable);
+if (HR_SUCCEEDED(rv)) {
+// Find the entry ID corresponding to this recordKey
+SPropValue keyProp = { 0 };
+keyProp.ulPropTag = PR_RECORD_KEY;
+keyProp.Value.bin.cb = recordKey.count();
+keyProp.Value.bin.lpb = reinterpret_cast<LPBYTE>(const_cast<char*>(recordKey.data()));
+SRestriction restriction = { 0 };
+restriction.rt = RES_PROPERTY;
+restriction.res.resProperty.relop = RELOP_EQ;
+restriction.res.resProperty.ulPropTag = PR_RECORD_KEY;
+restriction.res.resProperty.lpProp = &keyProp;
+ULONG flags(0);
+rv = storesTable->Restrict(&restriction, flags);
+if (HR_SUCCEEDED(rv)) {
+SizedSPropTagArray(1, columns) = {1, {PR_ENTRYID}};
+rv = storesTable->SetColumns(reinterpret_cast<LPSPropTagArray>(&columns), 0);
+if (HR_SUCCEEDED(rv)) {
+SRowSet *rows(0);
+if (storesTable->QueryRows(1, 0, &rows) == S_OK) {
+if (rows->cRows == 1) {
+MapiEntryId entryId(rows->aRow[0].lpProps[0].Value.bin.lpb, rows->aRow[0].lpProps[0].Value.bin.cb);
+result = openStore(error, entryId, cachedMode);
+} else {
+*error = QMessageManager::InvalidId;
+}
+FreeProws(rows);
+} else {
+*error = QMessageManager::InvalidId;
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to set columns for stores table";
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to restrict stores table";
+}
+mapiRelease(storesTable);
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to open stores table.";
+}
+return result;
+}
+QMessageAccountId MapiSession::defaultAccountId(QMessageManager::Error *error, QMessage::Type type) const
+{
+#ifdef _WIN32_WCE
+if (type == QMessage::Sms) {
+foreach (MapiStorePtr store, allStores(error)) {
+if (store->name() == "SMS") {
+return store->id();
+}
+}
+}
+#endif
+if (type == QMessage::Email) {
+// Return the account of the default store
+MapiStorePtr store(defaultStore(error));
+if (*error == QMessageManager::NoError) {
+return store->id();
+}
+}
+return QMessageAccountId();
+}
+IMessage *MapiSession::openMapiMessage(QMessageManager::Error *error, const QMessageId &id, MapiStorePtr *storePtr) const
+{
+IMessage *message(0);
+#ifdef _WIN32_WCE
+MapiEntryId storeRecordKey(QMessageIdPrivate::storeRecordKey(id));
+#else
+MapiRecordKey storeRecordKey(QMessageIdPrivate::storeRecordKey(id));
+#endif
+MapiStorePtr mapiStore(findStore(error, QMessageAccountIdPrivate::from(storeRecordKey)));
+if (*error == QMessageManager::NoError) {
+MapiEntryId entryId(QMessageIdPrivate::entryId(id));
+message = mapiStore->openMessage(error, entryId);
+if (*error == QMessageManager::NoError) {
+if (storePtr) {
+*storePtr = mapiStore;
+}
+} else {
+qWarning() << "Invalid message entryId:" << entryId.toBase64();
+mapiRelease(message);
+}
+} else {
+qWarning() << "Invalid store recordKey:" << storeRecordKey.toBase64();
+}
+return message;
+}
+MapiEntryId MapiSession::messageEntryId(QMessageManager::Error *error, const MapiRecordKey &storeKey, const MapiRecordKey &folderKey, const MapiRecordKey &messageKey)
+{
+MapiEntryId result;
+MapiStorePtr store(openStoreWithKey(error, storeKey));
+if (*error == QMessageManager::NoError) {
+result = store->messageEntryId(error, folderKey, messageKey);
+}
+return result;
+}
+MapiRecordKey MapiSession::messageRecordKey(QMessageManager::Error *error, const QMessageId &id)
+{
+MapiRecordKey result;
+IMessage *message = openMapiMessage(error, id);
+if (*error == QMessageManager::NoError) {
+if (!getMapiProperty(message, PR_RECORD_KEY, &result)) {
+qWarning() << "Unable to query message record key.";
+}
+mapiRelease(message);
+}
+return result;
+}
+MapiRecordKey MapiSession::folderRecordKey(QMessageManager::Error *error, const QMessageId &id)
+{
+MapiRecordKey result;
+MapiStorePtr store;
+IMessage *message = openMapiMessage(error, id, &store);
+if (*error == QMessageManager::NoError) {
+// Find the parent folder for the message
+MapiEntryId folderId;
+if (getMapiProperty(message, PR_PARENT_ENTRYID, &folderId)) {
+MapiFolderPtr folder = store->openFolder(error, folderId);
+if (*error == QMessageManager::NoError) {
+result = folder->recordKey();
+}
+} else {
+qWarning() << "Unable to query folder entry ID from message.";
+}
+mapiRelease(message);
+}
+return result;
+}
+#ifdef _WIN32_WCE
+MapiEntryId MapiSession::folderEntryId(QMessageManager::Error *error, const QMessageId &id)
+{
+MapiEntryId result;
+IMessage *message = openMapiMessage(error, id);
+if (*error == QMessageManager::NoError) {
+// Find the parent folder for the message
+MapiEntryId folderId;
+if (getMapiProperty(message, PR_PARENT_ENTRYID, &folderId)) {
+result = folderId;
+} else {
+qWarning() << "Unable to query folder entry ID from message.";
+}
+mapiRelease(message);
+}
+return result;
+}
+#endif
+bool MapiSession::equal(const MapiEntryId &lhs, const MapiEntryId &rhs) const
+{
+ULONG result(0);
+LPENTRYID lhsEntryId(reinterpret_cast<LPENTRYID>(const_cast<char*>(lhs.data())));
+LPENTRYID rhsEntryId(reinterpret_cast<LPENTRYID>(const_cast<char*>(rhs.data())));
+HRESULT rv = _mapiSession->CompareEntryIDs(lhs.count(), lhsEntryId, rhs.count(), rhsEntryId, 0, &result);
+if (HR_FAILED(rv)) {
+qWarning() << "Unable to compare entry IDs.";
+}
+return (result != FALSE);
+}
+QMessageFolder MapiSession::folder(QMessageManager::Error *error, const QMessageFolderId& id) const
+{
+QMessageFolder result;
+if(!id.isValid())
+{
+*error = QMessageManager::InvalidId;
+return result;
+}
+#ifdef _WIN32_WCE
+MapiEntryId storeRecordKey(QMessageFolderIdPrivate::storeRecordKey(id));
+#else
+MapiRecordKey storeRecordKey(QMessageFolderIdPrivate::storeRecordKey(id));
+#endif
+MapiStorePtr mapiStore(findStore(error, QMessageAccountIdPrivate::from(storeRecordKey)));
+if (*error != QMessageManager::NoError)
+return result;
+// Find the root folder for this store
+MapiFolderPtr storeRoot(mapiStore->rootFolder(error));
+if (*error != QMessageManager::NoError)
+return result;
+MapiEntryId entryId(QMessageFolderIdPrivate::entryId(id));
+MapiFolderPtr folder = mapiStore->openFolder(error, entryId);
+if (folder && (*error == QMessageManager::NoError)) {
+#ifndef _WIN32_WCE
+SizedSPropTagArray(3, columns) = {3, {PR_DISPLAY_NAME, PR_PARENT_ENTRYID, PR_RECORD_KEY}};
+#else
+SizedSPropTagArray(2, columns) = {2, {PR_DISPLAY_NAME, PR_PARENT_ENTRYID}};
+#endif
+SPropValue *properties(0);
+ULONG count;
+HRESULT rv = folder->folder()->GetProps(reinterpret_cast<LPSPropTagArray>(&columns), MAPI_UNICODE, &count, &properties);
+if (HR_SUCCEEDED(rv)) {
+QString name(QStringFromLpctstr(properties[0].Value.LPSZ));
+MapiEntryId parentEntryId(properties[1].Value.bin.lpb, properties[1].Value.bin.cb);
+#ifndef _WIN32_WCE
+MapiRecordKey folderKey(properties[2].Value.bin.lpb, properties[2].Value.bin.cb);
+#else
+MapiRecordKey folderKey;
+#endif
+MAPIFreeBuffer(properties);
+QMessageFolderId folderId(QMessageFolderIdPrivate::from(folderKey, storeRecordKey, entryId));
+if (equal(parentEntryId, storeRoot->entryId())) {
+// This folder is a direct child of the root folder
+QMessageAccountId accountId(QMessageAccountIdPrivate::from(storeRecordKey));
+return QMessageFolderPrivate::from(folderId, accountId, QMessageFolderId(), name, name);
+}
+QStringList path;
+path.append(name);
+QMessageFolderId parentId;
+MapiEntryId ancestorEntryId(parentEntryId);
+MapiFolderPtr ancestorFolder;
+// Iterate through ancestors towards the root
+while ((ancestorFolder = mapiStore->openFolder(error, ancestorEntryId)) &&
+(ancestorFolder && (*error == QMessageManager::NoError))) {
+SPropValue *ancestorProperties(0);
+if (ancestorFolder->folder()->GetProps(reinterpret_cast<LPSPropTagArray>(&columns), MAPI_UNICODE, &count, &ancestorProperties) == S_OK) {
+#ifndef _WIN32_WCE
+SPropValue &ancestorRecordKeyProp(ancestorProperties[2]);
+MapiRecordKey ancestorRecordKey(ancestorRecordKeyProp.Value.bin.lpb, ancestorRecordKeyProp.Value.bin.cb);
+bool reachedRoot(ancestorRecordKey == storeRoot->recordKey());
+#else
+MapiRecordKey ancestorRecordKey;
+bool reachedRoot(equal(ancestorEntryId, storeRoot->entryId()));
+#endif
+if (ancestorEntryId == parentEntryId) {
+// This ancestor is the parent of the folder being retrieved, create a QMessageFolderId for the parent
+parentId = QMessageFolderIdPrivate::from(ancestorRecordKey, storeRecordKey, parentEntryId);
+}
+SPropValue &entryIdProp(ancestorProperties[1]);
+ancestorEntryId = MapiEntryId(entryIdProp.Value.bin.lpb, entryIdProp.Value.bin.cb);
+QString ancestorName(QStringFromLpctstr(ancestorProperties[0].Value.LPSZ));
+MAPIFreeBuffer(ancestorProperties);
+if (reachedRoot) {
+// Reached the root and have a complete path for the folder being retrieved
+QMessageAccountId accountId(QMessageAccountIdPrivate::from(storeRecordKey));
+return QMessageFolderPrivate::from(folderId, accountId, parentId, name, path.join("/"));
+}
+// Prepare to consider next ancestor
+if (!ancestorName.isEmpty())
+path.prepend(ancestorName);
+} else {
+break;
+}
+}
+}
+}
+// Failed to quickly retrieve the folder, fallback to an exhaustive search of all folders
+result = mapiStore->folderFromId(error, id);
+return result;
+}
+QMessage MapiSession::message(QMessageManager::Error *error, const QMessageId& id) const
+{
+Q_UNUSED(error);
+QMessage result = QMessagePrivate::from(id);
+// How do we find what type of message this is?
+result.setType(QMessage::Email);
+result.d_ptr->_elementsPresent.properties = 0;
+result.d_ptr->_elementsPresent.recipients = 0;
+result.d_ptr->_elementsPresent.body = 0;
+result.d_ptr->_elementsPresent.attachments = 0;
+result.d_ptr->_modified = false;
+return result;
+}
+bool MapiSession::updateMessageProperties(QMessageManager::Error *error, QMessage *msg) const
+{
+bool result(false);
+if (!msg->d_ptr->_elementsPresent.properties) {
+bool isModified(msg->d_ptr->_modified);
+msg->d_ptr->_elementsPresent.properties = 1;
+MapiStorePtr store;
+IMessage *message = openMapiMessage(error, msg->id(), &store);
+if (*error == QMessageManager::NoError) {
+#ifndef _WIN32_WCE
+const int np = 14;
+#else
+const int np = 12;
+#endif
+SizedSPropTagArray(np, msgCols) = {np, { PR_PARENT_ENTRYID,
+PR_MESSAGE_FLAGS,
+PR_MSG_STATUS,
+PR_MESSAGE_CLASS,
+PR_SENDER_NAME,
+PR_SENDER_EMAIL_ADDRESS,
+PR_CLIENT_SUBMIT_TIME,
+PR_MESSAGE_DELIVERY_TIME,
+PR_SUBJECT,
+PR_HASATTACH,
+PR_PRIORITY,
+#ifndef _WIN32_WCE
+PR_MSG_EDITOR_FORMAT,
+PR_RTF_IN_SYNC,
+#endif
+PR_MESSAGE_SIZE
+}};
+ULONG count = 0;
+LPSPropValue properties;
+HRESULT rv = message->GetProps(reinterpret_cast<LPSPropTagArray>(&msgCols), MAPI_UNICODE, &count, &properties);
+if (HR_SUCCEEDED(rv)) {
+QString senderName;
+QString senderAddress;
+QString messageClass;
+MapiEntryId parentEntryId;
+QMessage::StatusFlags flags(0);
+//assumption that stores support only a single message type
+msg->d_ptr->_type = store->types() & QMessage::Sms ? QMessage::Sms : QMessage::Email;
+for (ULONG n = 0; n < count; ++n) {
+SPropValue &prop(properties[n]);
+switch (prop.ulPropTag) {
+case PR_MESSAGE_FLAGS:
+if (prop.Value.ul & MSGFLAG_READ) {
+flags |= QMessage::Read;
+}
+break;
+case PR_PARENT_ENTRYID:
+parentEntryId = MapiEntryId(prop.Value.bin.lpb, prop.Value.bin.cb);
+break;
+case PR_MSG_STATUS:
+if (prop.Value.l & (MSGSTATUS_DELMARKED | MSGSTATUS_REMOTE_DELETE)) {
+flags |= QMessage::Removed;
+}
+#ifdef _WIN32_WCE
+if (prop.Value.l & MSGSTATUS_HAS_PR_BODY) {
+msg->d_ptr->_contentFormat = EDITOR_FORMAT_PLAINTEXT;
+#if(_WIN32_WCE > 0x501)
+} else if (prop.Value.l & MSGSTATUS_HAS_PR_BODY_HTML) {
+msg->d_ptr->_contentFormat = EDITOR_FORMAT_HTML;
+#endif
+} else if (prop.Value.l & MSGSTATUS_HAS_PR_CE_MIME_TEXT) {
+// This is how MS providers store HTML, as per http://msdn.microsoft.com/en-us/library/bb446140.aspx
+msg->d_ptr->_contentFormat = EDITOR_FORMAT_MIME;
+}
+#endif
+break;
+case PR_MESSAGE_CLASS:
+messageClass = QStringFromLpctstr(prop.Value.LPSZ);
+break;
+case PR_SENDER_NAME:
+senderName = QStringFromLpctstr(prop.Value.LPSZ);
+break;
+case PR_SENDER_EMAIL_ADDRESS:
+senderAddress = QStringFromLpctstr(prop.Value.LPSZ);
+break;
+case PR_CLIENT_SUBMIT_TIME:
+msg->setDate(fromFileTime(prop.Value.ft));
+break;
+case PR_MESSAGE_DELIVERY_TIME:
+msg->setReceivedDate(fromFileTime(prop.Value.ft));
+break;
+case PR_SUBJECT:
+msg->setSubject(QStringFromLpctstr(prop.Value.LPSZ));
+break;
+case PR_HASATTACH:
+msg->d_ptr->_hasAttachments = (prop.Value.b != FALSE);
+if (prop.Value.b) {
+flags |= QMessage::HasAttachments;
+}
+break;
+case PR_PRIORITY:
+if (prop.Value.l == PRIO_URGENT) {
+msg->setPriority(QMessage::HighPriority);
+} else if (prop.Value.l == PRIO_NONURGENT) {
+msg->setPriority(QMessage::LowPriority);
+} else {
+msg->setPriority(QMessage::NormalPriority);
+}
+break;
+#ifndef _WIN32_WCE
+case PR_MSG_EDITOR_FORMAT:
+msg->d_ptr->_contentFormat = prop.Value.l;
+break;
+case PR_RTF_IN_SYNC:
+msg->d_ptr->_rtfInSync = (prop.Value.b != FALSE);;
+break;
+#endif
+case PR_MESSAGE_SIZE:
+QMessagePrivate::setSize(*msg, prop.Value.l);
+break;
+default:
+break;
+}
+}
+msg->setStatus(flags);
+msg->setParentAccountId(store->id());
+if (!senderName.isEmpty() || !senderAddress.isEmpty()) {
+msg->setFrom(createAddress(senderName, senderAddress));
+QMessagePrivate::setSenderName(*msg, senderName);
+}
+if (!parentEntryId.isEmpty()) {
+QMessagePrivate::setStandardFolder(*msg, store->standardFolder(parentEntryId));
+// MAPI does not support the notion of incoming/outgoing messages.  Instead, we
+// will treat Outgoing as meaning 'in the Sent folder'
+msg->setStatus(QMessage::Incoming, (msg->standardFolder() != QMessage::SentFolder));
+MapiFolderPtr parentFolder(store->openFolder(error, parentEntryId));
+if (parentFolder) {
+QMessagePrivate::setParentFolderId(*msg, parentFolder->id());
+}
+}
+if (!isModified) {
+msg->d_ptr->_modified = false;
+}
+result = true;
+MAPIFreeBuffer(properties);
+} else {
+*error = QMessageManager::ContentInaccessible;
+}
+mapiRelease(message);
+}
+}
+return result;
+}
+bool MapiSession::updateMessageRecipients(QMessageManager::Error *error, QMessage *msg) const
+{
+bool result(false);
+if (!msg->d_ptr->_elementsPresent.recipients) {
+bool isModified(msg->d_ptr->_modified);
+msg->d_ptr->_elementsPresent.recipients = 1;
+IMessage *message = openMapiMessage(error, msg->id());
+if (*error == QMessageManager::NoError) {
+// Extract the recipients for the message
+IMAPITable *recipientsTable(0);
+HRESULT rv = message->GetRecipientTable(0, &recipientsTable);
+if (HR_SUCCEEDED(rv)) {
+QMessageAddressList to;
+QMessageAddressList cc;
+QMessageAddressList bcc;
+#ifndef _WIN32_WCE
+SizedSPropTagArray(3, rcpCols) = {3, { PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_RECIPIENT_TYPE}};
+QueryAllRows qar(recipientsTable, reinterpret_cast<LPSPropTagArray>(&rcpCols), 0, 0);
+#else
+// CE does not support SetColumns on recipient tables
+QueryAllRows qar(recipientsTable, 0, 0, 0, false);
+#endif
+while(qar.query()) {
+for (uint n = 0; n < qar.rows()->cRows; ++n) {
+QString name;
+QString address;
+LONG type(0);
+SPropValue *props = qar.rows()->aRow[n].lpProps;
+#ifndef _WIN32_WCE
+if (props[0].ulPropTag == PR_DISPLAY_NAME)
+name = QStringFromLpctstr(props[0].Value.LPSZ);
+if (props[1].ulPropTag == PR_EMAIL_ADDRESS)
+address = QStringFromLpctstr(props[1].Value.LPSZ);
+if (props[2].ulPropTag == PR_RECIPIENT_TYPE)
+type = props[2].Value.l;
+#else
+for (uint i = 0; i < qar.rows()->aRow[n].cValues; ++i) {
+if (props[i].ulPropTag == PR_DISPLAY_NAME) {
+name = QStringFromLpctstr(props[i].Value.LPSZ);
+} else if (props[i].ulPropTag == PR_EMAIL_ADDRESS) {
+address = QStringFromLpctstr(props[i].Value.LPSZ);
+} else if (props[i].ulPropTag == PR_RECIPIENT_TYPE){
+type = props[i].Value.l;
+}
+}
+#endif
+if (!name.isEmpty() || !address.isEmpty()) {
+QMessageAddressList *list = 0;
+switch (type) {
+case MAPI_TO:
+list = &to;
+break;
+case MAPI_CC:
+list = &cc;
+break;
+case MAPI_BCC:
+list = &bcc;
+break;
+default:
+break;
+}
+if (list) {
+list->append(createAddress(name, address));
+}
+}
+}
+}
+if (!to.isEmpty()) {
+msg->setTo(to);
+}
+if (!cc.isEmpty()) {
+msg->setCc(cc);
+}
+if (!bcc.isEmpty()) {
+msg->setBcc(bcc);
+}
+if (!isModified) {
+msg->d_ptr->_modified = false;
+}
+if (qar.error() != QMessageManager::NoError) {
+*error = qar.error();
+result = false;
+} else {
+result = true;
+}
+mapiRelease(recipientsTable);
+} else {
+#ifdef _WIN32_WCE
+if (rv == MAPI_E_NO_RECIPIENTS) {
+updateMessageProperties(error, msg);
+if (*error == QMessageManager::NoError) {
+if (msg->d_ptr->_contentFormat == EDITOR_FORMAT_MIME) {
+// The recipient info can be extracted from the MIME body
+updateMessageBody(error, msg);
+}
+}
+} else {
+#endif
+*error = QMessageManager::ContentInaccessible;
+#ifdef _WIN32_WCE
+}
+#endif
+}
+mapiRelease(message);
+}
+}
+return result;
+}
+bool MapiSession::updateMessageBody(QMessageManager::Error *error, QMessage *msg) const
+{
+bool result(false);
+// TODO: Signed messages are stored with the body as an attachment; we need to implement this
+if (!msg->d_ptr->_elementsPresent.body) {
+if (!msg->d_ptr->_elementsPresent.properties) {
+// We need the properties before we can fetch the body
+if (!updateMessageProperties(error, msg)) {
+return false;
+}
+}
+bool isModified(msg->d_ptr->_modified);
+msg->d_ptr->_elementsPresent.body = 1;
+QByteArray messageBody;
+QByteArray bodySubType;
+MapiStorePtr store;
+IMessage *message = openMapiMessage(error, msg->id(), &store);
+if (*error == QMessageManager::NoError) {
+//SMS body stored in subject on CEMAPI
+if (store->types() & QMessage::Sms) {
+messageBody.append(reinterpret_cast<const char*>(msg->subject().utf16()),msg->subject().count()*sizeof(quint16));
+bodySubType = "plain";
+} else {
+IStream *is(0);
+bool asciiData(false);
+LONG contentFormat(msg->d_ptr->_contentFormat);
+if (contentFormat == EDITOR_FORMAT_DONTKNOW) {
+// Attempt to read HTML first
+contentFormat = EDITOR_FORMAT_HTML;
+}
+if (contentFormat == EDITOR_FORMAT_PLAINTEXT) {
+#ifdef _WIN32_WCE
+ULONG tags[] = { PR_BODY, PR_BODY_W, PR_BODY_A };
+#else
+ULONG tags[] = { PR_BODY };
+#endif
+const int n = sizeof(tags)/sizeof(tags[0]);
+for (int i = 0; i < n; ++i) {
+HRESULT rv = message->OpenProperty(tags[i], &IID_IStream, STGM_READ, 0, (IUnknown**)&is);
+if (HR_SUCCEEDED(rv)) {
+messageBody = readStream(error, is);
+bodySubType = "plain";
+if (i == 2) {
+asciiData = true;
+}
+break;
+}
+}
+if (messageBody.isEmpty()) {
+qWarning() << "Unable to open PR_BODY!";
+}
+} else if (contentFormat == EDITOR_FORMAT_HTML) {
+// See if there is a body HTML property
+// Correct variants discussed at http://blogs.msdn.com/raffael/archive/2008/09/08/mapi-on-windows-mobile-6-programmatically-retrieve-mail-body-sample-code.aspx
+#if(_WIN32_WCE > 0x501)
+ULONG tags[] = { PR_BODY_HTML, PR_BODY_HTML_W, PR_BODY_HTML_A };
+#else
+ULONG tags[] = { PR_BODY_HTML };
+#endif
+const int n = sizeof(tags)/sizeof(tags[0]);
+for (int i = 0; i < n; ++i) {
+HRESULT rv = message->OpenProperty(tags[i], &IID_IStream, STGM_READ, 0, (IUnknown**)&is);
+if (HR_SUCCEEDED(rv)) {
+messageBody = readStream(error, is);
+bodySubType = "html";
+if (i == 2) {
+asciiData = true;
+}
+break;
+}
+}
+if (messageBody.isEmpty()) {
+#ifdef _WIN32_WCE
+qWarning() << "Unable to open PR_BODY_HTML!";
+#else
+// We couldn't get HTML; try RTF
+contentFormat = EDITOR_FORMAT_DONTKNOW;
+#endif
+}
+#ifdef _WIN32_WCE
+} else if (contentFormat == EDITOR_FORMAT_MIME) {
+// MIME format is only used on mobile
+HRESULT rv = message->OpenProperty(PR_CE_MIME_TEXT, &IID_IStream, STGM_READ, 0, (IUnknown**)&is);
+if (HR_SUCCEEDED(rv)) {
+messageBody = readStream(error, is);
+QMailMessage mimeMsg(QMailMessage::fromRfc2822(messageBody));
+// Extract the recipient info from the message headers
+QMessageAddressList addresses;
+foreach (const QMailAddress &addr, mimeMsg.to()) {
+QString addressString(addr.address());
+if(!addressString.isEmpty())
+addresses.append(QMessageAddress(QMessageAddress::Email, addressString));
+}
+if (!addresses.isEmpty()) {
+msg->setTo(addresses);
+}
+addresses.clear();
+foreach (const QMailAddress &addr, mimeMsg.cc()) {
+QString addressString(addr.address());
+if(!addressString.isEmpty())
+addresses.append(QMessageAddress(QMessageAddress::Email, addressString));
+}
+if (!addresses.isEmpty()) {
+msg->setCc(addresses);
+}
+addresses.clear();
+foreach (const QMailAddress &addr, mimeMsg.bcc()) {
+QString addressString(addr.address());
+addresses.append(QMessageAddress(QMessageAddress::Email, addressString));
+}
+if (!addresses.isEmpty()) {
+msg->setBcc(addresses);
+}
+// Extract the text of the message body
+if (mimeMsg.multipartType() == QMailMessage::MultipartNone) {
+if (mimeMsg.contentType().type().toLower() == "text") {
+QByteArray subType(mimeMsg.contentType().subType().toLower());
+if ((subType == "plain") || (subType == "html") || (subType == "rtf")) {
+messageBody = QTextCodec::codecForName("utf-16")->fromUnicode(mimeMsg.body().data());
+bodySubType = subType;
+}
+}
+} else if ((mimeMsg.multipartType() == QMailMessage::MultipartAlternative) ||
+(mimeMsg.multipartType() == QMailMessage::MultipartMixed) ||
+(mimeMsg.multipartType() == QMailMessage::MultipartRelated)) {
+// For multipart/related, just try the first part
+int maxParts(mimeMsg.multipartType() == QMailMessage::MultipartRelated ? 1 : mimeMsg.partCount());
+for (int i = 0; i < maxParts; ++i) {
+const QMailMessagePart &part(mimeMsg.partAt(i));
+if (part.contentType().type().toLower() == "text") {
+QByteArray subType(part.contentType().subType().toLower());
+if ((subType == "plain") || (subType == "html") || (subType == "rtf")) {
+messageBody = QTextCodec::codecForName("utf-16")->fromUnicode(part.body().data());
+bodySubType = subType;
+break;
+}
+}
+}
+}
+} else {
+qWarning() << "Unable to open PR_CE_MIME_TEXT!";
+}
+#endif
+}
+#ifndef _WIN32_WCE // RTF not supported on mobile
+if (bodySubType.isEmpty()) {
+if (!msg->d_ptr->_rtfInSync) {
+// See if we need to sync the RTF
+if (!store->supports(STORE_RTF_OK)) {
+BOOL updated(FALSE);
+HRESULT rv = RTFSync(message, RTF_SYNC_BODY_CHANGED, &updated);
+if (HR_SUCCEEDED(rv)) {
+if (updated) {
+if (HR_FAILED(message->SaveChanges(0))) {
+qWarning() << "Unable to save changes after synchronizing RTF.";
+}
+}
+} else {
+qWarning() << "Unable to synchronize RTF.";
+}
+}
+}
+// Either the body is in RTF, or we need to read the RTF to know that it is text...
+HRESULT rv = message->OpenProperty(PR_RTF_COMPRESSED, &IID_IStream, STGM_READ, 0, (IUnknown**)&is);
+if (HR_SUCCEEDED(rv)) {
+IStream *decompressor(0);
+if (WrapCompressedRTFStream(is, 0, &decompressor) == S_OK) {
+ULONG bytes = 0;
+char buffer[BUFSIZ] = { 0 };
+do {
+decompressor->Read(buffer, BUFSIZ, &bytes);
+messageBody.append(buffer, bytes);
+} while (bytes == BUFSIZ);
+decompressor->Release();
+// RTF is stored in ASCII
+asciiData = true;
+if (contentFormat == EDITOR_FORMAT_DONTKNOW) {
+// Inspect the message content to see if we can tell what is in it
+if (!messageBody.isEmpty()) {
+QByteArray initialText(messageBody.left(256));
+if (initialText.indexOf("\\fromtext") != -1) {
+// This message originally contained text
+contentFormat = EDITOR_FORMAT_PLAINTEXT;
+// See if we can get the plain text version instead
+IStream *ts(0);
+rv = message->OpenProperty(PR_BODY, &IID_IStream, STGM_READ, 0, (IUnknown**)&ts);
+if (HR_SUCCEEDED(rv)) {
+messageBody = readStream(error, ts);
+bodySubType = "plain";
+asciiData = false;
+ts->Release();
+} else {
+qWarning() << "Unable to prefer plain text body.";
+}
+} else if (initialText.indexOf("\\fromhtml1") != -1) {
+// This message originally contained text
+contentFormat = EDITOR_FORMAT_HTML;
+}
+}
+}
+if (bodySubType.isEmpty()) {
+if (contentFormat == EDITOR_FORMAT_PLAINTEXT) {
+messageBody = extractPlainText(messageBody);
+bodySubType = "plain";
+} else if (contentFormat == EDITOR_FORMAT_HTML) {
+messageBody = extractHtml(messageBody);
+bodySubType = "html";
+} else {
+// I guess we must just have RTF
+bodySubType = "rtf";
+}
+}
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to decompress RTF";
+bodySubType = "plain";
+}
+}
+}
+#endif
+if (bodySubType.isEmpty()) {
+qWarning() << "Unable to locate body for message.";
+}
+mapiRelease(is);
+if (asciiData) {
+// Convert the ASCII content back to UTF-16
+messageBody = QTextCodec::codecForName("utf-16")->fromUnicode(decodeContent(messageBody, "Latin-1"));
+}
+}
+if (*error == QMessageManager::NoError) {
+QMessageContentContainerPrivate *messageContainer(((QMessageContentContainer *)(msg))->d_ptr);
+bool bodyDownloaded = true;
+#ifdef _WIN32_WCE
+ULONG status = 0;
+if(getMapiProperty(message,PR_MSG_STATUS,&status)) {
+bodyDownloaded = !((status & MSGSTATUS_HEADERONLY) || (status & MSGSTATUS_PARTIAL));
+}
+#else
+//TODO windows
+#endif
+if (!msg->d_ptr->_hasAttachments) {
+// Make the body the entire content of the message
+messageContainer->setContent(messageBody, QByteArray("text"), bodySubType, QByteArray("utf-16"));
+msg->d_ptr->_bodyId = messageContainer->bodyContentId();
+messageContainer->_available = bodyDownloaded;
+} else {
+// Add the message body data as the first part
+QMessageContentContainer bodyPart;
+{
+QMessageContentContainerPrivate *bodyContainer(((QMessageContentContainer *)(&bodyPart))->d_ptr);
+bodyContainer->setContent(messageBody, QByteArray("text"), bodySubType, QByteArray("utf-16"));
+bodyContainer->_available = bodyDownloaded;
+}
+messageContainer->setContentType(QByteArray("multipart"), QByteArray("mixed"), QByteArray());
+msg->d_ptr->_bodyId = messageContainer->appendContent(bodyPart);
+}
+if (!isModified) {
+msg->d_ptr->_modified = false;
+}
+result = true;
+}
+mapiRelease(message);
+}
+}
+return result;
+}
+bool MapiSession::updateMessageAttachments(QMessageManager::Error *error, QMessage *msg) const
+{
+bool result(false);
+if (!msg->d_ptr->_elementsPresent.attachments) {
+if (!msg->d_ptr->_elementsPresent.properties) {
+// We need the properties before we can fetch the attachments
+if (!updateMessageProperties(error, msg)) {
+return false;
+}
+}
+bool isModified(msg->d_ptr->_modified);
+msg->d_ptr->_elementsPresent.attachments = 1;
+if (msg->d_ptr->_hasAttachments) {
+IMessage *message = openMapiMessage(error, msg->id());
+if (*error == QMessageManager::NoError) {
+QMessageContentContainerPrivate *messageContainer(((QMessageContentContainer *)(msg))->d_ptr);
+// Find any attachments for this message
+IMAPITable *attachmentsTable(0);
+HRESULT rv = message->GetAttachmentTable(0, &attachmentsTable);
+if (HR_SUCCEEDED(rv)) {
+// Find the properties of these attachments
+SizedSPropTagArray(7, attCols) = {7, { PR_ATTACH_NUM,
+PR_ATTACH_EXTENSION,
+PR_ATTACH_LONG_FILENAME,
+PR_ATTACH_FILENAME,
+PR_ATTACH_CONTENT_ID,
+PR_ATTACH_SIZE,
+PR_RENDERING_POSITION }};
+QueryAllRows qar(attachmentsTable, reinterpret_cast<LPSPropTagArray>(&attCols), NULL, NULL);
+while(qar.query()) {
+for (uint n = 0; n < qar.rows()->cRows; ++n) {
+LONG number(0);
+QString extension;
+QString filename;
+QString contentId;
+LONG size(0);
+LONG renderingPosition(0);
+// If not available, the output tag will not match our requested content tag
+if (qar.rows()->aRow[n].lpProps[0].ulPropTag == PR_ATTACH_NUM) {
+number = qar.rows()->aRow[n].lpProps[0].Value.l;
+} else {
+// We can't access this part...
+continue;
+}
+if (qar.rows()->aRow[n].lpProps[1].ulPropTag == PR_ATTACH_EXTENSION) {
+extension = QStringFromLpctstr(qar.rows()->aRow[n].lpProps[1].Value.LPSZ);
+}
+if (qar.rows()->aRow[n].lpProps[2].ulPropTag == PR_ATTACH_LONG_FILENAME) {
+filename = QStringFromLpctstr(qar.rows()->aRow[n].lpProps[2].Value.LPSZ);
+} else if (qar.rows()->aRow[n].lpProps[3].ulPropTag == PR_ATTACH_FILENAME) {
+filename = QStringFromLpctstr(qar.rows()->aRow[n].lpProps[3].Value.LPSZ);
+}
+if (qar.rows()->aRow[n].lpProps[4].ulPropTag == PR_ATTACH_CONTENT_ID) {
+contentId = QStringFromLpctstr(qar.rows()->aRow[n].lpProps[4].Value.LPSZ);
+}
+if (qar.rows()->aRow[n].lpProps[5].ulPropTag == PR_ATTACH_SIZE) {
+// Increase the size estimate by a third to allow for transfer encoding
+size = (qar.rows()->aRow[n].lpProps[5].Value.l * 4 / 3);
+}
+if (qar.rows()->aRow[n].lpProps[6].ulPropTag == PR_RENDERING_POSITION) {
+renderingPosition = qar.rows()->aRow[n].lpProps[6].Value.l;
+}
+WinHelpers::AttachmentLocator locator(msg->id(), number);
+QMessageContentContainer attachment(WinHelpers::fromLocator(locator));
+QMessageContentContainerPrivate *container(((QMessageContentContainer *)(&attachment))->d_ptr);
+if (!extension.isEmpty()) {
+QByteArray contentType(contentTypeFromExtension(extension));
+if (!contentType.isEmpty()) {
+int index = contentType.indexOf('/');
+if (index != -1) {
+container->setContentType(contentType.left(index), contentType.mid(index + 1), QByteArray());
+} else {
+container->setContentType(contentType, QByteArray(), QByteArray());
+}
+}
+}
+if (!contentId.isEmpty()) {
+container->setHeaderField("Content-ID", contentId.toAscii());
+}
+if (renderingPosition == -1) {
+QByteArray value("attachment");
+if (!filename.isEmpty()) {
+value.append("; filename=" + filename.toAscii());
+}
+container->setHeaderField("Content-Disposition", value);
+}
+container->_name = filename.toAscii();
+container->_size = size;
+container->_available = haveAttachmentData(error,msg->id(),number);
+messageContainer->appendContent(attachment);
+if (!isModified) {
+msg->d_ptr->_modified = false;
+}
+}
+}
+if (qar.error() != QMessageManager::NoError) {
+*error = qar.error();
+} else {
+result = true;
+}
+mapiRelease(attachmentsTable);
+} else {
+*error = QMessageManager::ContentInaccessible;
+qWarning() << "Unable to access attachments table.";
+}
+mapiRelease(message);
+}
+}
+}
+return result;
+}
+bool MapiSession::haveAttachmentData(QMessageManager::Error *error, const QMessageId& id, ULONG number) const
+{
+bool result = false;
+IMessage *message = openMapiMessage(error, id);
+if (*error == QMessageManager::NoError) {
+LPATTACH attachment(0);
+HRESULT rv = message->OpenAttach(number, 0, 0, &attachment);
+if (HR_SUCCEEDED(rv)) {
+IStream *is(0);
+rv = attachment->OpenProperty(PR_ATTACH_DATA_BIN, &IID_IStream, STGM_READ, 0, (IUnknown**)&is);
+if (HR_SUCCEEDED(rv)) {
+result = streamSize(error, is) > 0;
+mapiRelease(is);
+}
+mapiRelease(attachment);
+} else {
+qWarning() << "Unable to open attachment:" << number;
+}
+mapiRelease(message);
+}
+return result;
+}
+QByteArray MapiSession::attachmentData(QMessageManager::Error *error, const QMessageId& id, ULONG number) const
+{
+QByteArray result;
+IMessage *message = openMapiMessage(error, id);
+if (*error == QMessageManager::NoError) {
+LPATTACH attachment(0);
+HRESULT rv = message->OpenAttach(number, 0, 0, &attachment);
+if (HR_SUCCEEDED(rv)) {
+IStream *is(0);
+rv = attachment->OpenProperty(PR_ATTACH_DATA_BIN, &IID_IStream, STGM_READ, 0, (IUnknown**)&is);
+if (HR_SUCCEEDED(rv)) {
+result = readStream(error, is);
+mapiRelease(is);
+}
+mapiRelease(attachment);
+} else {
+qWarning() << "Unable to open attachment:" << number;
+}
+mapiRelease(message);
+}
+return result;
+}
+QMessageIdList MapiSession::queryMessages(QMessageManager::Error *error, const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset, const QString &body, QMessageDataComparator::MatchFlags matchFlags) const
+{
+if (!filter.isSupported()) {
+*error = QMessageManager::ConstraintFailure;
+return QMessageIdList();
+}
+if (QMessageFilterPrivate::isNonMatching(filter)) { // Avoid unnecessary preprocessing/evaluation
+return QMessageIdList();
+}
+QList<FolderHeapNodePtr> folderNodes;
+QMessageFilter processedFilter(QMessageFilterPrivate::preprocess(error, _self.toStrongRef(), filter));
+if (*error != QMessageManager::NoError)
+return  QMessageIdList();
+if (QMessageFilterPrivate::isNonMatching(processedFilter)) { // Filter maybe be simplified by preprocessing
+return QMessageIdList();
+}
+foreach (QMessageFilter subfilter, QMessageFilterPrivate::subfilters(processedFilter)) {
+MapiStoreIterator storeIt(QMessageFilterPrivate::storeIterator(subfilter, error, _self.toStrongRef()));
+for (MapiStorePtr store(storeIt.next()); store && store->isValid(); store = storeIt.next()) {
+MapiFolderIterator folderIt(QMessageFilterPrivate::folderIterator(subfilter, error, store));
+for (MapiFolderPtr folder(folderIt.next()); folder && folder->isValid(); folder = folderIt.next()) {
+QList<QMessageFilter> orderingFilters;
+orderingFilters.append(subfilter);
+foreach(QMessageFilter orderingFilter, QMessageSortOrderPrivate::normalize(orderingFilters, sortOrder)) {
+folderNodes.append(FolderHeapNodePtr(new FolderHeapNode(folder, orderingFilter)));
+}
+}
+}
+}
+if (*error != QMessageManager::NoError)
+return QMessageIdList();
+return filterMessages(error, folderNodes, sortOrder, limit, offset, body, matchFlags);
+}
+void MapiSession::updateMessage(QMessageManager::Error* error, const QMessage& source)
+{
+MapiStorePtr store;
+IMessage *mapiMessage = openMapiMessage(error, source.id(), &store);
+if (*error == QMessageManager::NoError) {
+// Update the stored properties
+if (*error == QMessageManager::NoError) {
+storeMessageProperties(error, source, mapiMessage);
+}
+if (*error == QMessageManager::NoError) {
+replaceMessageRecipients(error, source, mapiMessage, _mapiSession);
+}
+if (*error == QMessageManager::NoError) {
+replaceMessageBody(error, source, mapiMessage, store);
+}
+if (*error == QMessageManager::NoError) {
+// Attachments cannot be removed from a QMessage but new ones can be added
+addMessageAttachments(error, source, mapiMessage);
+}
+#ifndef _WIN32_WCE //unsupported
+if (*error == QMessageManager::NoError) {
+if (HR_FAILED(mapiMessage->SaveChanges(0))) {
+qWarning() << "Unable to save changes for message.";
+}
+}
+#endif
+mapiRelease(mapiMessage);
+}
+}
+void MapiSession::removeMessages(QMessageManager::Error *error, const QMessageIdList &ids)
+{
+#ifdef _WIN32_WCE
+typedef QPair<MapiEntryId, MapiEntryId> FolderKey;
+#else
+typedef QPair<MapiRecordKey, MapiRecordKey> FolderKey;
+#endif
+QMap<FolderKey, QMessageIdList> folderMessageIds;
+// Group messages by folder
+foreach (const QMessageId &id, ids) {
+folderMessageIds[qMakePair(QMessageIdPrivate::storeRecordKey(id), QMessageIdPrivate::folderRecordKey(id))].append(id);
+}
+QMap<FolderKey, QMessageIdList>::const_iterator it = folderMessageIds.begin(), end = folderMessageIds.end();
+for ( ; it != end; ++it) {
+#ifdef _WIN32_WCE
+const MapiEntryId storeKey(it.key().first);
+const MapiEntryId folderKey(it.key().second);
+#else
+const MapiRecordKey storeKey(it.key().first);
+const MapiRecordKey folderKey(it.key().second);
+#endif
+QMessageManager::Error localError(QMessageManager::NoError);
+#ifdef _WIN32_WCE
+MapiStorePtr store = openStore(&localError,storeKey,true);
+#else
+MapiStorePtr store = openStoreWithKey(&localError, storeKey, true);
+#endif
+if (localError == QMessageManager::NoError) {
+#ifdef _WIN32_WCE
+MapiFolderPtr folder = store->openFolder(&localError, folderKey);
+#else
+MapiFolderPtr folder = store->openFolderWithKey(&localError, folderKey);
+#endif
+if (localError == QMessageManager::NoError) {
+folder->removeMessages(&localError, it.value());
+}
+}
+if ((localError != QMessageManager::NoError) && (*error == QMessageManager::NoError)) {
+*error = localError;
+}
+}
+}
+bool MapiSession::event(QEvent *e)
+{
+if (e->type() == NotifyEvent::eventType()) {
+if (NotifyEvent *ne = static_cast<NotifyEvent*>(e)) {
+QMutex* storeMutex = QMessageStorePrivate::mutex(QMessageManager());
+if(!storeMutex->tryLock())
+addToNotifyQueue(*ne);
+else
+{
+notify(ne->_store, ne->_id, ne->_notifyType);
+storeMutex->unlock();
+}
+return true;
+}
+}
+return QObject::event(e);
+}
+void MapiSession::notify(MapiStore *store, const QMessageId &id, MapiSession::NotifyType notifyType)
+{
+QMessageManager::NotificationFilterIdSet matchingFilterIds;
+QMap<QMessageManager::NotificationFilterId, QMessageFilter>::const_iterator it = _filters.begin(), end = _filters.end();
+for ( ; it != end; ++it) {
+const QMessageFilter &filter(it.value());
+if (!filter.isSupported())
+continue;
+// no message properties are available for a removed message, so only empty filter can match
+if (notifyType == MapiSession::Removed) {
+if (filter.isEmpty()) {
+matchingFilterIds.insert(it.key());
+break;
+}
+continue;
+}
+QMessageManager::Error ignoredError(QMessageManager::NoError);
+QMessageFilter processedFilter(QMessageFilterPrivate::preprocess(&ignoredError, _self.toStrongRef(), filter));
+if (ignoredError != QMessageManager::NoError)
+continue;
+QMessage message(id);
+foreach (QMessageFilter subfilter, QMessageFilterPrivate::subfilters(processedFilter)) {
+if (QMessageFilterPrivate::matchesMessage(subfilter, message, store)) {
+matchingFilterIds.insert(it.key());
+break; // subfilters are or'd together
+}
+}
+}
+if (!matchingFilterIds.isEmpty()) {
+void (MapiSession::*signal)(const QMessageId &, const QMessageManager::NotificationFilterIdSet &) =
+((notifyType == Added) ? &MapiSession::messageAdded
+: ((notifyType == Removed) ? &MapiSession::messageRemoved
+: &MapiSession::messageUpdated));
+emit (this->*signal)(id, matchingFilterIds);
+}
+}
+QMessageManager::NotificationFilterId MapiSession::registerNotificationFilter(QMessageManager::Error *error, const QMessageFilter &filter)
+{
+QMessageManager::NotificationFilterId filterId = ++_filterId;
+_filters.insert(filterId, filter);
+if (!_registered) {
+_registered = true;
+foreach (MapiStorePtr store, allStores(error)) {
+store->notifyEvents(fnevNewMail | fnevObjectCreated | fnevObjectCopied | fnevObjectDeleted | fnevObjectModified | fnevObjectMoved);
+}
+}
+return filterId;
+}
+void MapiSession::unregisterNotificationFilter(QMessageManager::Error *error, QMessageManager::NotificationFilterId filterId)
+{
+_filters.remove(filterId);
+Q_UNUSED(error)
+}
+void MapiSession::dispatchNotifications()
+{
+MSG msg = { 0 };
+while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+TranslateMessage(&msg);
+DispatchMessage(&msg);
+}
+QTimer::singleShot(1000, this, SLOT(dispatchNotifications()));
+}
+void MapiSession::processNotifyQueue()
+{
+foreach(const NotifyEvent& e, _notifyEventQueue)
+{
+QMutex* storeMutex = QMessageStorePrivate::mutex(QMessageStore::instance());
+if(storeMutex->tryLock())
+{
+NotifyEvent ne = _notifyEventQueue.dequeue();
+notify(e._store,e._id,e._notifyType);
+storeMutex->unlock();
+}
+else break;
+}
+if(!_notifyEventQueue.isEmpty())
+qWarning() << QString("Notify queue processing interrupted: pending %1").arg(_notifyEventQueue.length());
+}
+QMessagePrivate *MapiSession::messageImpl(const QMessage &message)
+{
+return message.d_ptr;
+}
+QMessageContentContainerPrivate *MapiSession::containerImpl(const QMessageContentContainer &container)
+{
+return container.d_ptr;
+}
+void MapiSession::addToNotifyQueue(const NotifyEvent& e)
+{
+_notifyEventQueue.enqueue(e);
+qWarning() << QString("Store busy...adding notify to queue: pending %1").arg(_notifyEventQueue.length());
+}
+void MapiSession::flushNotifyQueue()
+{
+QTimer::singleShot(0, this, SLOT(processNotifyQueue()));
+}
+#ifndef _WIN32_WCE
+MapiForm::MapiForm(IMsgStore* mapiStore,
+IMAPISession* mapiSession,
+IMAPIFolder* mapiFolder,
+IMessage* mapiMessage)
+:
+m_mapiStore(mapiStore),
+m_mapiSession(mapiSession),
+m_mapiFolder(mapiFolder),
+m_mapiMessage(mapiMessage),
+m_mapiPersistMessage(0),
+m_referenceCount(1)
+{
+if (m_mapiStore) m_mapiStore->AddRef();
+if (m_mapiSession) m_mapiSession->AddRef();
+if (m_mapiFolder) m_mapiFolder->AddRef();
+if (m_mapiMessage) m_mapiMessage->AddRef();
+}
+MapiForm::~MapiForm()
+{
+releaseAll();
+}
+void MapiForm::releaseAll()
+{
+releasePersistMessage();
+mapiRelease(m_mapiMessage);
+mapiRelease(m_mapiFolder);
+mapiRelease(m_mapiStore);
+mapiRelease(m_mapiSession);
+}
+STDMETHODIMP MapiForm::QueryInterface(REFIID riid, void** iface)
+{
+*iface = 0;
+if (riid == IID_IMAPIMessageSite)
+{
+*iface = (IMAPIMessageSite*)this;
+AddRef();
+return S_OK;
+}
+if (riid == IID_IUnknown)
+{
+*iface = (LPUNKNOWN)((IMAPIMessageSite*)this);
+AddRef();
+return S_OK;
+}
+return E_NOINTERFACE;
+}
+STDMETHODIMP_(ULONG) MapiForm::AddRef()
+{
+long refCount = InterlockedIncrement(&m_referenceCount);
+return refCount;
+}
+STDMETHODIMP_(ULONG) MapiForm::Release()
+{
+long refCount = InterlockedDecrement(&m_referenceCount);
+if (!refCount)
+delete this;
+return refCount;
+}
+STDMETHODIMP MapiForm::GetSession (IMAPISession* FAR * mapiSession)
+{
+HRESULT hResult = S_FALSE;
+if (mapiSession)
+{
+*mapiSession = m_mapiSession;
+if (m_mapiSession)
+{
+m_mapiSession->AddRef();
+hResult = S_OK;
+}
+}
+return hResult;
+}
+STDMETHODIMP MapiForm::GetStore(IMsgStore* FAR * mapiStore)
+{
+HRESULT hResult = S_FALSE;
+if (mapiStore)
+{
+*mapiStore = m_mapiStore;
+if (m_mapiStore)
+{
+m_mapiStore->AddRef();
+hResult = S_OK;
+}
+}
+return hResult;
+}
+STDMETHODIMP MapiForm::GetFolder(IMAPIFolder* FAR * mapiFolder)
+{
+HRESULT hResult = S_FALSE;
+if (mapiFolder)
+{
+*mapiFolder = m_mapiFolder;
+if (m_mapiFolder)
+{
+m_mapiFolder->AddRef();
+hResult = S_OK;
+}
+}
+return hResult;
+}
+STDMETHODIMP MapiForm::GetMessage(IMessage* FAR * mapiMessage)
+{
+HRESULT hResult = S_FALSE;
+if (mapiMessage)
+{
+*mapiMessage = m_mapiMessage;
+if(m_mapiMessage)
+{
+m_mapiMessage->AddRef();
+hResult = S_OK;
+}
+}
+return hResult;
+}
+STDMETHODIMP MapiForm::GetFormManager(IMAPIFormMgr* FAR * mapiFormManager)
+{
+HRESULT hRes = S_OK;
+hRes = MAPIOpenFormMgr(m_mapiSession,mapiFormManager);
+if(FAILED(hRes))
+qWarning() << "MAPIOpenFormMgr failed";
+return hRes;
+}
+STDMETHODIMP MapiForm::NewMessage(ULONG isComposeInFolder,
+IMAPIFolder* mapiFolder,
+IPersistMessage* mapiPersistMessage,
+IMessage* FAR * mapiMessage,
+IMAPIMessageSite* FAR * mapiMessageSite,
+LPMAPIVIEWCONTEXT FAR * mapiViewContext)
+{
+*mapiMessage = 0;
+*mapiMessageSite = 0;
+HRESULT hRes = S_OK;
+if (mapiViewContext) *mapiViewContext = 0;
+if ((isComposeInFolder == false) || !mapiFolder)
+mapiFolder = m_mapiFolder;
+if (mapiFolder)
+{
+hRes = mapiFolder->CreateMessage(0, 0, mapiMessage);
+if (*mapiMessage)
+{
+MapiForm *mapiForm = 0;
+mapiForm = new MapiForm(m_mapiStore, m_mapiSession, mapiFolder, *mapiMessage);
+if (mapiForm)
+{
+hRes = mapiForm->setPersistMessage(NULL,mapiPersistMessage);
+*mapiMessageSite = (IMAPIMessageSite*)mapiForm;
+}
+}
+}
+return hRes;
+}
+STDMETHODIMP MapiForm::CopyMessage(IMAPIFolder*)
+{
+return MAPI_E_NO_SUPPORT;
+}
+STDMETHODIMP MapiForm::MoveMessage(IMAPIFolder*, LPMAPIVIEWCONTEXT, LPCRECT)
+{
+return MAPI_E_NO_SUPPORT;
+}
+STDMETHODIMP MapiForm::DeleteMessage(LPMAPIVIEWCONTEXT, LPCRECT)
+{
+return MAPI_E_NO_SUPPORT;
+}
+STDMETHODIMP MapiForm::SaveMessage()
+{
+HRESULT hRes = S_OK;
+if (!m_mapiPersistMessage || !m_mapiMessage)
+return MAPI_E_INVALID_PARAMETER;
+hRes = m_mapiPersistMessage->Save(0, true);
+if (FAILED(hRes))
+{
+qWarning() << "IMessage::Save failed";
+return hRes;
+}
+else
+{
+hRes = (m_mapiMessage->SaveChanges(KEEP_OPEN_READWRITE));
+hRes = (m_mapiPersistMessage->SaveCompleted(NULL));
+}
+return hRes;
+}
+STDMETHODIMP MapiForm::SubmitMessage(ulong flags)
+{
+Q_UNUSED(flags);
+HRESULT hRes = S_OK;
+if (!m_mapiPersistMessage || !m_mapiMessage) return MAPI_E_INVALID_PARAMETER;
+hRes = (m_mapiPersistMessage->Save(m_mapiMessage,true));
+if (FAILED(hRes))
+{
+qWarning() << "IPersistMessage::Save failed";
+return hRes;
+}
+else
+{
+hRes = (m_mapiPersistMessage->HandsOffMessage());
+hRes = (m_mapiMessage->SubmitMessage(NULL));
+}
+mapiRelease(m_mapiMessage);
+return hRes;
+}
+STDMETHODIMP MapiForm::GetSiteStatus(ULONG* status)
+{
+*status = VCSTATUS_NEW_MESSAGE;
+if (m_mapiPersistMessage)
+*status |= VCSTATUS_SAVE | VCSTATUS_SUBMIT | NULL;
+return S_OK;
+}
+bool MapiForm::show()
+{
+IMAPIFormMgr* mapiFormManager = 0;
+if(GetFormManager(&mapiFormManager) != S_OK)
+return false;
+IMAPIForm* MAPIForm = 0;
+if(mapiFormManager->LoadForm((ULONG_PTR) 0, 0, 0, 0, 0, m_mapiFolder,
+this,
+m_mapiMessage,
+0,
+IID_IMAPIForm,
+(LPVOID *) &MAPIForm) != S_OK)
+{
+qWarning() << "IMAPIFormMgr::LoadForm failed";
+mapiFormManager->Release();
+return false;
+}
+mapiFormManager->Release();
+RECT rect;
+bool result = true;
+if (MAPIForm)
+{
+setPersistMessage(MAPIForm,NULL);
+HRESULT hRes = S_OK;
+hRes = MAPIForm->DoVerb(0,0,0,&rect);
+if (S_OK != hRes)
+{
+rect.left = 0;
+rect.right = 500;
+rect.top = 0;
+rect.bottom = 400;
+hRes = MAPIForm->DoVerb(0, 0, 0, &rect);
+}
+if(S_OK != hRes)
+{
+qWarning() << "IMapiForm::DoVerb Failed";
+result = false;
+}
+MAPIForm->Release();
+}
+return  result;
+}
+STDMETHODIMP MapiForm::GetLastError(HRESULT, ULONG, LPMAPIERROR FAR*)
+{
+return MAPI_E_NO_SUPPORT;
+}
+void MapiForm::releasePersistMessage()
+{
+if (m_mapiPersistMessage)
+{
+m_mapiPersistMessage->HandsOffMessage();
+mapiRelease(m_mapiPersistMessage);
+}
+}
+HRESULT MapiForm::setPersistMessage(LPMAPIFORM lpForm, IPersistMessage* mapiPersistMessage)
+{
+HRESULT hRes = S_OK;
+releasePersistMessage();
+if (mapiPersistMessage)
+{
+m_mapiPersistMessage = mapiPersistMessage;
+m_mapiPersistMessage->AddRef();
+}
+else if (lpForm) hRes = (lpForm->QueryInterface(IID_IPersistMessage ,(LPVOID *)&m_mapiPersistMessage));
+return hRes;
+}
+#endif
+#include "winhelpers.moc"
+#include "moc_winhelpers_p.cpp"
+QTM_END_NAMESPACE