--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/messaging/winhelpers.cpp Wed Aug 25 15:49:42 2010 +0300
@@ -0,0 +1,5184 @@
+/****************************************************************************
+**
+** 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 ¬ification(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