C++ QMailMessage类代码示例

void WriteMail::modify(const QMailMessage& previousMessage)
{
    QString recipients = "";

    prepareComposer(previousMessage.messageType(), previousMessage.parentAccountId());
    if (composer().isEmpty())
        return;

    // Record any message properties we should retain
    mail.setId(previousMessage.id());
    mail.setParentFolderId(previousMessage.parentFolderId());
    mail.setContentScheme(previousMessage.contentScheme());
    mail.setContentIdentifier(previousMessage.contentIdentifier());
    mail.setTo(previousMessage.to());
    mail.setFrom(previousMessage.from());
    mail.setCustomFields(previousMessage.customFields());
    mail.setServerUid(previousMessage.serverUid());

    m_composerInterface->compose(QMailMessage::NoResponse, previousMessage);

    // ugh. we need to do this everywhere
    m_hasMessageChanged = false;
    m_precursorId = mail.inResponseTo();
    m_replyAction = mail.responseType();
}

// organized after lest expensive search
bool Search::matches(const QMailMessage& in) const
{
    if ( !matchesStatus(in) )
        return false;

    if ( !matchesAccount(in) )
        return false;
    if ( !matchesFolder(in) )
        return false;

    if ( !match(fromMail, in.from().toString() ) )
        return false;

    if ( !matchesTo(in) )
        return false;

    if ( !match(subject, in.subject() ) )
        return false;

    if ( !matchesBeforeDate(in) )
        return false;
    if ( !matchesAfterDate(in) )
        return false;

    if ( !matchesBody(in) )
        return false;

    return true;
}

bool MessageFolder::insertMessage(QMailMessage &message)
{
    message.setParentFolderId(mFolder.id());

    if (message.id().isValid()) {
        return QMailStore::instance()->updateMessage(&message);
    } else {
        return QMailStore::instance()->addMessage(&message);
    }
}

void WriteMail::respond(const QMailMessage& source, QMailMessage::ResponseType type)
{
    prepareComposer(source.messageType(), source.parentAccountId());
    if (composer().isEmpty())
        return;

    m_composerInterface->compose(type, source);
    m_hasMessageChanged = true;
    m_precursorId = source.id();
    m_replyAction = type;
}

bool Search::matchesStatus(const QMailMessage& mail) const
{
    switch( _status ) {
        case Any:       return true;
        case Read:      return ( mail.status() & (QMailMessage::Read | QMailMessage::ReadElsewhere) );
        case Unread:    return ( !(mail.status() & (QMailMessage::Read | QMailMessage::ReadElsewhere)) );
        case Replied:   return ( (mail.status() & QMailMessage::Replied) 
                                 || (mail.status() & QMailMessage::RepliedAll) );
    }

    return false;
}

bool Search::matchesFolder(const QMailMessage& mail) const
{
    if ( folder.isEmpty() )
        return true;

    return ( folder == mail.fromMailbox() );
}

/*  Reading entire mailbox is very slow on a large mailbox  */
bool Search::matchesBody(const QMailMessage& mail) const
{
    if ( body.isEmpty() )
        return true;

    return match(body, mail.body().data());
}

QString EmailMessageListModel::bodyPlainText(const QMailMessage &mailMsg) const
{
    if (QMailMessagePartContainer *container = mailMsg.findPlainTextContainer()) {
        return container->body().data();
    }

    return QString();
}

void ConversationPage::processAttachments(const QMailMessage &message)
{
    if (!message.status() & QMailMessageMetaData::HasAttachments)
        return;

    connect(this, SIGNAL(downloadCompleted()), this, SLOT(saveAttachment()));

    bool oneTimeFlag = true;
    for (uint i = 1; i < message.partCount(); ++i)
    {
        QMailMessagePart sourcePart = message.partAt(i);
        if (!(sourcePart.multipartType() == QMailMessagePartContainer::MultipartNone))
            continue;

        if (oneTimeFlag)
        {
            MSeparator *separator = new MSeparator();
            separator->setObjectName("Separator");
            m_policy->addItem(separator);
            oneTimeFlag = false;
        }

        MStylableWidget *w = new MStylableWidget(this);
        QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Horizontal);
        w->setLayout(layout);
        //% "Attached: "
        MLabel *label = new MLabel(qtTrId("xx_attached"));
        label->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        label->setObjectName ("AttachmentText");
        layout->addItem(label);
        MButton *button = new MButton(sourcePart.displayName());
        button->setObjectName ("AttachmentButton");
        button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        layout->addItem(button);

        //% "Download..."
        AttachmentAction *action = new AttachmentAction(qtTrId("xx_download_context_menu"), button, sourcePart);
        connect(action, SIGNAL(triggered()), this, SLOT(openAttachmentDownloadDialog()));

        //% "Open..."
        action = new AttachmentAction(qtTrId("xx_open_context_menu"), button, sourcePart);
        connect(action, SIGNAL(triggered()), this, SLOT(openAttachmentOpenDialog()));
        m_policy->addItem (w);
    }
}

bool Search::matchesAccount(const QMailMessage& mail) const
{
    if ( fromAccount.isEmpty() )
        return true;
    if (fromAccount == mail.fromAccount() )
        return true;

    return false;
}

/*  TODO:  We should swap the mail in to get the full to, cc and bcc
    lists.  Only to.first() are currently cached.  Reading all the mails
    from disk are currently to slow a process though
*/
bool Search::matchesTo(const QMailMessage& mail) const
{
    if ( recipient.isEmpty() )
        return true;

    foreach (const QMailAddress& address, mail.to())
        if ( match( recipient, address.toString() ) )
            return true;

    return false;
}

void EmailComposerInterface::setMessage( const QMailMessage &mail )
{
    if (mail.multipartType() == QMailMessagePartContainer::MultipartNone) {
        if (mail.hasBody())
            setText( mail.body().data(), mail.contentType().content() );
    } else {
        // The only type of multipart message we currently compose is Mixed, with
        // all but the first part as out-of-line attachments
        int textPart = -1;
        for ( uint i = 0; i < mail.partCount(); ++i ) {
            QMailMessagePart &part = const_cast<QMailMessagePart&>(mail.partAt(i));
            
            if (textPart == -1 && part.contentType().type().toLower() == "text") {
                // This is the first text part, we will use as the forwarded text body
                textPart = i;
            } else {
                QString attPath = part.attachmentPath();
                QMailMessage::AttachmentsAction action = QMailMessage::LinkToAttachments;

                // Detach the part data to a temporary file if necessary
                if (attPath.isEmpty()) {
                    if (part.detachAttachment(Qtopia::tempDir())) {
                        attPath = part.attachmentPath();
                        action = QMailMessage::CopyAttachments;

                        // Create a content object for the file
                        QContent doc(attPath);

                        if (part.hasBody()) {
                            QMailMessageContentType type(part.contentType());

                            if (doc.drmState() == QContent::Unprotected)
                                doc.setType(type.content());
                        }

                        doc.setName(part.displayName());
                        doc.setRole(QContent::Data);

                        doc.commit();

                        // This needs to be removed after composition
                        m_temporaries.append(doc);
                    }
                }

                if (!attPath.isEmpty())
                    attach(attPath, action);
            }
        }

        if (textPart != -1) {
            const QMailMessagePart& part = mail.partAt(textPart);
            setText( part.body().data(), part.contentType().content() );
        }
    }
}

QString AttachmentListModel::attachmentUrl(const QMailMessage message, const QString &attachmentLocation)
{
    QString attachmentDownloadFolder = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation) + "/mail_attachments/" + attachmentLocation;
    for (uint i = 0; i < message.partCount(); i++) {
        QMailMessagePart sourcePart = message.partAt(i);
        if (attachmentLocation == sourcePart.location().toString(true)) {
            QString attachmentPath = attachmentDownloadFolder + "/" + sourcePart.displayName();
            QFile f(attachmentPath);
            if (f.exists()) {
                return attachmentPath;
            } else {
                // we have the part downloaded locally but not in a file type yet
                if (sourcePart.hasBody()) {
                    QString path = sourcePart.writeBodyTo(attachmentDownloadFolder);
                    return path;
                }
                return QString();
            }
        }
    }
    return QString();
}

// match against date, if the mails date is not parsed, always return true
bool Search::matchesAfterDate(const QMailMessage& mail) const
{
    if ( afterDate.isNull() )
        return true;

    QDateTime dateTime = mail.date().toLocalTime();
    if ( dateTime.isNull() )
        return true;

    if ( afterDate < dateTime.date() )
        return true;

    return false;
}

QString EmailMessageListModel::bodyHtmlText(const QMailMessage &mailMsg) const
{
    // TODO: This function assumes that at least the structure has been retrieved already
    if (const QMailMessagePartContainer *container = mailMsg.findHtmlContainer()) {
        if (!container->contentAvailable()) {
            // Retrieve the data for this part
            connect (m_retrievalAction, SIGNAL(activityChanged(QMailServiceAction::Activity)),
                                        this, SLOT(downloadActivityChanged(QMailServiceAction::Activity)));
            QMailMessagePart::Location location = static_cast<const QMailMessagePart *>(container)->location();
            m_retrievalAction->retrieveMessagePart(location);
            return " ";  // Put a space here as a place holder to notify UI that we do have html body.
        }
        return container->body().data();
    }

    return QString();
}