Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 612 insertions, 0 deletions

diff --git a/kmail/partNode.cpp b/kmail/partNode.cpp
new file mode 100644
index 000000000..4fd51c857
--- /dev/null
+++ b/kmail/partNode.cpp
@@ -0,0 +1,612 @@
+/* -*- c++ -*-
+    partNode.cpp A node in a MIME tree.
+
+    This file is part of KMail, the KDE mail client.
+    Copyright (c) 2002 Klarälvdalens Datakonsult AB
+
+    KMail is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License, version 2, as
+    published by the Free Software Foundation.
+
+    KMail is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+    In addition, as a special exception, the copyright holders give
+    permission to link the code of this program with any edition of
+    the Qt library by Trolltech AS, Norway (or with modified versions
+    of Qt that use the same license as Qt), and distribute linked
+    combinations including the two.  You must obey the GNU General
+    Public License in all respects for all of the code used other than
+    Qt.  If you modify this file, you may extend this exception to
+    your version of the file, but you are not obligated to do so.  If
+    you do not wish to do so, delete this exception statement from
+    your version.
+*/
+
+#include <config.h>
+#include "partNode.h"
+#include <klocale.h>
+#include <kdebug.h>
+#include "kmmimeparttree.h"
+#include <mimelib/utility.h>
+#include <qregexp.h>
+#include <kasciistricmp.h>
+#include "util.h"
+
+/*
+  ===========================================================================
+
+
+  S T A R T    O F     T E M P O R A R Y     M I M E     C O D E
+
+
+  ===========================================================================
+  N O T E :   The partNode structure will most likely be replaced by KMime.
+  It's purpose: Speed optimization for KDE 3.   (khz, 28.11.01)
+  ===========================================================================
+*/
+
+partNode::partNode()
+  : mRoot( 0 ), mNext( 0 ), mChild( 0 ),
+    mWasProcessed( false ),
+    mDwPart( 0 ),
+    mType( DwMime::kTypeUnknown ),
+    mSubType( DwMime::kSubtypeUnknown ),
+    mEncryptionState( KMMsgNotEncrypted ),
+    mSignatureState( KMMsgNotSigned ),
+    mMsgPartOk( false ),
+    mEncodedOk( false ),
+    mDeleteDwBodyPart( false ),
+    mMimePartTreeItem( 0 ),
+    mBodyPartMemento( 0 )
+{
+  adjustDefaultType( this );
+}
+
+partNode::partNode( DwBodyPart* dwPart, int explicitType, int explicitSubType,
+		    bool deleteDwBodyPart )
+  : mRoot( 0 ), mNext( 0 ), mChild( 0 ),
+    mWasProcessed( false ),
+    mDwPart( dwPart ),
+    mEncryptionState( KMMsgNotEncrypted ),
+    mSignatureState( KMMsgNotSigned ),
+    mMsgPartOk( false ),
+    mEncodedOk( false ),
+    mDeleteDwBodyPart( deleteDwBodyPart ),
+    mMimePartTreeItem( 0 ),
+    mBodyPartMemento( 0 )
+{
+  if ( explicitType != DwMime::kTypeUnknown ) {
+    mType    = explicitType;     // this happens e.g. for the Root Node
+    mSubType = explicitSubType;  // representing the _whole_ message
+  } else {
+//    kdDebug(5006) << "\n        partNode::partNode()      explicitType == DwMime::kTypeUnknown\n" << endl;
+    if(dwPart && dwPart->hasHeaders() && dwPart->Headers().HasContentType()) {
+      mType    = (!dwPart->Headers().ContentType().Type())?DwMime::kTypeUnknown:dwPart->Headers().ContentType().Type();
+      mSubType = dwPart->Headers().ContentType().Subtype();
+    } else {
+      mType    = DwMime::kTypeUnknown;
+      mSubType = DwMime::kSubtypeUnknown;
+    }
+  }
+#ifdef DEBUG
+  {
+    DwString type, subType;
+    DwTypeEnumToStr( mType, type );
+    DwSubtypeEnumToStr( mSubType, subType );
+    kdDebug(5006) << "\npartNode::partNode()   " << type.c_str() << "/" << subType.c_str() << "\n" << endl;
+  }
+#endif
+}
+
+partNode * partNode::fromMessage( const KMMessage * msg ) {
+  if ( !msg )
+    return 0;
+
+  int mainType    = msg->type();
+  int mainSubType = msg->subtype();
+  if(    (DwMime::kTypeNull    == mainType)
+      || (DwMime::kTypeUnknown == mainType) ){
+    mainType    = DwMime::kTypeText;
+    mainSubType = DwMime::kSubtypePlain;
+  }
+
+  // we don't want to treat the top-level part special. mimelib does
+  // (Message vs. BodyPart, with common base class Entity). But we
+  // used DwBodyPart, not DwEntiy everywhere. *shrug*. DwStrings are
+  // subscrib-shared, so we just force mimelib to parse the whole mail
+  // as just another DwBodyPart...
+  DwBodyPart * mainBody = new DwBodyPart( *msg->getTopLevelPart() );
+
+  partNode * root = new partNode( mainBody, mainType, mainSubType, true );
+  root->buildObjectTree();
+
+  root->setFromAddress( msg->from() );
+  root->dump();
+  return root;
+}
+
+partNode::partNode( bool deleteDwBodyPart, DwBodyPart* dwPart )
+  : mRoot( 0 ), mNext( 0 ), mChild( 0 ),
+    mWasProcessed( false ),
+    mDwPart( dwPart ),
+    mEncryptionState( KMMsgNotEncrypted ),
+    mSignatureState( KMMsgNotSigned ),
+    mMsgPartOk( false ),
+    mEncodedOk( false ),
+    mDeleteDwBodyPart( deleteDwBodyPart ),
+    mMimePartTreeItem( 0 ),
+    mBodyPartMemento( 0 )
+{
+  if ( dwPart && dwPart->hasHeaders() && dwPart->Headers().HasContentType() ) {
+    mType    = (!dwPart->Headers().ContentType().Type())?DwMime::kTypeUnknown:dwPart->Headers().ContentType().Type();
+    mSubType = dwPart->Headers().ContentType().Subtype();
+  } else {
+    mType    = DwMime::kTypeUnknown;
+    mSubType = DwMime::kSubtypeUnknown;
+  }
+}
+
+partNode::~partNode() {
+  if( mDeleteDwBodyPart )
+    delete mDwPart;
+  mDwPart = 0;
+  delete mChild; mChild = 0;
+  delete mNext; mNext = 0;
+  delete mBodyPartMemento; mBodyPartMemento = 0;
+}
+
+#ifndef NDEBUG
+void partNode::dump( int chars ) const {
+  kdDebug(5006) << QString().fill( ' ', chars ) << "+ "
+		<< typeString() << '/' << subTypeString() << endl;
+  if ( mChild )
+    mChild->dump( chars + 1 );
+  if ( mNext )
+    mNext->dump( chars );
+}
+#else
+void partNode::dump( int ) const {}
+#endif
+
+const QCString & partNode::encodedBody() {
+  if ( mEncodedOk )
+    return mEncodedBody;
+
+  if ( mDwPart )
+    mEncodedBody = KMail::Util::CString( mDwPart->Body().AsString() );
+  else
+    mEncodedBody = 0;
+  mEncodedOk = true;
+  return mEncodedBody;
+}
+
+
+void partNode::buildObjectTree( bool processSiblings )
+{
+    partNode* curNode = this;
+    while( curNode && curNode->dwPart() ) {
+        //dive into multipart messages
+        while( DwMime::kTypeMultipart == curNode->type() ) {
+            partNode * newNode = new partNode( curNode->dwPart()->Body().FirstBodyPart() );
+            curNode->setFirstChild( newNode );
+            curNode = newNode;
+        }
+        // go up in the tree until reaching a node with next
+        // (or the last top-level node)
+        while(     curNode
+               && !(    curNode->dwPart()
+                     && curNode->dwPart()->Next() ) ) {
+            curNode = curNode->mRoot;
+        }
+        // we might have to leave when all children have been processed
+        if( this == curNode && !processSiblings )
+            return;
+        // store next node
+        if( curNode && curNode->dwPart() && curNode->dwPart()->Next() ) {
+            partNode* nextNode = new partNode( curNode->dwPart()->Next() );
+            curNode->setNext( nextNode );
+            curNode = nextNode;
+        } else
+            curNode = 0;
+    }
+}
+
+QCString partNode::typeString() const {
+  DwString s;
+  DwTypeEnumToStr( type(), s );
+  return s.c_str();
+}
+
+QCString partNode::subTypeString() const {
+  DwString s;
+  DwSubtypeEnumToStr( subType(), s );
+  return s.c_str();
+}
+
+int partNode::childCount() const {
+  int count = 0;
+  for ( partNode * child = firstChild() ; child ; child = child->nextSibling() )
+    ++ count;
+  return count;
+}
+
+QString partNode::contentTypeParameter( const char * name ) const {
+  if ( !mDwPart || !mDwPart->hasHeaders() )
+    return QString::null;
+  DwHeaders & headers = mDwPart->Headers();
+  if ( !headers.HasContentType() )
+    return QString::null;
+  DwString attr = name;
+  attr.ConvertToLowerCase();
+  for ( DwParameter * param = headers.ContentType().FirstParameter() ; param ; param = param->Next() ) {
+    DwString this_attr = param->Attribute();
+    this_attr.ConvertToLowerCase(); // what a braindead design!
+    if ( this_attr == attr )
+      return QString::fromLatin1( param->Value().data(), param->Value().size() );
+    // warning: misses rfc2231 handling!
+  }
+  return QString::null;
+}
+
+KMMsgEncryptionState partNode::overallEncryptionState() const
+{
+    KMMsgEncryptionState myState = KMMsgEncryptionStateUnknown;
+    if( mEncryptionState == KMMsgNotEncrypted ) {
+        // NOTE: children are tested ONLY when parent is not encrypted
+        if( mChild )
+            myState = mChild->overallEncryptionState();
+        else
+            myState = KMMsgNotEncrypted;
+    }
+    else { // part is partially or fully encrypted
+        myState = mEncryptionState;
+    }
+    // siblings are tested always
+    if( mNext ) {
+        KMMsgEncryptionState otherState = mNext->overallEncryptionState();
+        switch( otherState ) {
+        case KMMsgEncryptionStateUnknown:
+            break;
+        case KMMsgNotEncrypted:
+            if( myState == KMMsgFullyEncrypted )
+                myState = KMMsgPartiallyEncrypted;
+            else if( myState != KMMsgPartiallyEncrypted )
+                myState = KMMsgNotEncrypted;
+            break;
+        case KMMsgPartiallyEncrypted:
+            myState = KMMsgPartiallyEncrypted;
+            break;
+        case KMMsgFullyEncrypted:
+            if( myState != KMMsgFullyEncrypted )
+                myState = KMMsgPartiallyEncrypted;
+            break;
+        case KMMsgEncryptionProblematic:
+            break;
+        }
+    }
+
+//kdDebug(5006) << "\n\n  KMMsgEncryptionState: " << myState << endl;
+
+    return myState;
+}
+
+
+KMMsgSignatureState  partNode::overallSignatureState() const
+{
+    KMMsgSignatureState myState = KMMsgSignatureStateUnknown;
+    if( mSignatureState == KMMsgNotSigned ) {
+        // children are tested ONLY when parent is not signed
+        if( mChild )
+            myState = mChild->overallSignatureState();
+        else
+            myState = KMMsgNotSigned;
+    }
+    else { // part is partially or fully signed
+        myState = mSignatureState;
+    }
+    // siblings are tested always
+    if( mNext ) {
+        KMMsgSignatureState otherState = mNext->overallSignatureState();
+        switch( otherState ) {
+        case KMMsgSignatureStateUnknown:
+            break;
+        case KMMsgNotSigned:
+            if( myState == KMMsgFullySigned )
+                myState = KMMsgPartiallySigned;
+            else if( myState != KMMsgPartiallySigned )
+                myState = KMMsgNotSigned;
+            break;
+        case KMMsgPartiallySigned:
+            myState = KMMsgPartiallySigned;
+            break;
+        case KMMsgFullySigned:
+            if( myState != KMMsgFullySigned )
+                myState = KMMsgPartiallySigned;
+            break;
+        case KMMsgEncryptionProblematic:
+            break;
+        }
+    }
+
+//kdDebug(5006) << "\n\n  KMMsgSignatureState: " << myState << endl;
+
+    return myState;
+}
+
+
+int partNode::nodeId() const
+{
+    int curId = 0;
+    partNode* rootNode = const_cast<partNode*>( this );
+    while( rootNode->mRoot )
+        rootNode = rootNode->mRoot;
+    return rootNode->calcNodeIdOrFindNode( curId, this, 0, 0 );
+}
+
+
+partNode* partNode::findId( int id )
+{
+    int curId = 0;
+    partNode* rootNode = this;
+    while( rootNode->mRoot )
+        rootNode = rootNode->mRoot;
+    partNode* foundNode;
+    rootNode->calcNodeIdOrFindNode( curId, 0, id, &foundNode );
+    return foundNode;
+}
+
+
+int partNode::calcNodeIdOrFindNode( int &curId, const partNode* findNode, int findId, partNode** foundNode )
+{
+    // We use the same algorithm to determine the id of a node and
+    //                           to find the node when id is known.
+    curId++;
+    // check for node ?
+    if( findNode && this == findNode )
+        return curId;
+    // check for id ?
+    if(  foundNode && curId == findId ) {
+        *foundNode = this;
+        return curId;
+    }
+    if( mChild )
+    {
+        int res = mChild->calcNodeIdOrFindNode( curId, findNode, findId, foundNode );
+        if (res != -1) return res;
+    }
+    if( mNext )
+        return mNext->calcNodeIdOrFindNode( curId, findNode, findId, foundNode );
+
+    if(  foundNode )
+        *foundNode = 0;
+    return -1;
+}
+
+
+partNode* partNode::findType( int type, int subType, bool deep, bool wide )
+{
+#ifndef NDEBUG
+  DwString typeStr, subTypeStr;
+  DwTypeEnumToStr( mType, typeStr );
+  DwSubtypeEnumToStr( mSubType, subTypeStr );
+  kdDebug(5006) << "partNode::findType() is looking at " << typeStr.c_str()
+                << "/" << subTypeStr.c_str() << endl;
+#endif
+    if(    (mType != DwMime::kTypeUnknown)
+           && (    (type == DwMime::kTypeUnknown)
+                   || (type == mType) )
+           && (    (subType == DwMime::kSubtypeUnknown)
+                   || (subType == mSubType) ) )
+        return this;
+    if ( mChild && deep )
+        return mChild->findType( type, subType, deep, wide );
+    if ( mNext && wide )
+        return mNext->findType(  type, subType, deep, wide );
+    return 0;
+}
+
+partNode* partNode::findNodeForDwPart( DwBodyPart* part )
+{
+    partNode* found = 0;
+    if( kasciistricmp( dwPart()->partId(), part->partId() ) == 0 )
+        return this;
+    if( mChild )
+        found = mChild->findNodeForDwPart( part );
+    if( mNext && !found )
+        found = mNext->findNodeForDwPart( part );
+    return found;
+}
+
+partNode* partNode::findTypeNot( int type, int subType, bool deep, bool wide )
+{
+    if(    (mType != DwMime::kTypeUnknown)
+           && (    (type == DwMime::kTypeUnknown)
+                   || (type != mType) )
+           && (    (subType == DwMime::kSubtypeUnknown)
+                   || (subType != mSubType) ) )
+        return this;
+    if ( mChild && deep )
+        return mChild->findTypeNot( type, subType, deep, wide );
+    if ( mNext && wide )
+        return mNext->findTypeNot(  type, subType, deep, wide );
+    return 0;
+}
+
+void partNode::fillMimePartTree( KMMimePartTreeItem* parentItem,
+                                 KMMimePartTree*     mimePartTree,
+                                 QString labelDescr,
+                                 QString labelCntType,
+                                 QString labelEncoding,
+                                 KIO::filesize_t size,
+                                 bool revertOrder )
+{
+  if( parentItem || mimePartTree ) {
+
+    if( mNext )
+        mNext->fillMimePartTree( parentItem, mimePartTree,
+                                 QString::null, QString::null, QString::null, 0,
+                                 revertOrder );
+
+    QString cntDesc, cntType, cntEnc;
+    KIO::filesize_t cntSize = 0;
+
+    if( labelDescr.isEmpty() ) {
+        DwHeaders* headers = 0;
+        if( mDwPart && mDwPart->hasHeaders() )
+          headers = &mDwPart->Headers();
+        if( headers && headers->HasSubject() )
+            cntDesc = KMMsgBase::decodeRFC2047String( headers->Subject().AsString().c_str() );
+        if( headers && headers->HasContentType()) {
+            cntType = headers->ContentType().TypeStr().c_str();
+            cntType += '/';
+            cntType += headers->ContentType().SubtypeStr().c_str();
+        }
+        else
+            cntType = "text/plain";
+        if( cntDesc.isEmpty() )
+            cntDesc = msgPart().contentDescription();
+        if( cntDesc.isEmpty() )
+            cntDesc = msgPart().name().stripWhiteSpace();
+        if( cntDesc.isEmpty() )
+            cntDesc = msgPart().fileName();
+        if( cntDesc.isEmpty() ) {
+            if( mRoot && mRoot->mRoot )
+                cntDesc = i18n("internal part");
+            else
+                cntDesc = i18n("body part");
+        }
+        cntEnc = msgPart().contentTransferEncodingStr();
+        if( mDwPart )
+            cntSize = mDwPart->BodySize();
+    } else {
+        cntDesc = labelDescr;
+        cntType = labelCntType;
+        cntEnc  = labelEncoding;
+        cntSize = size;
+    }
+    // remove linebreak+whitespace from folded Content-Description
+    cntDesc.replace( QRegExp("\\n\\s*"), " " );
+
+kdDebug(5006) << "      Inserting one item into MimePartTree" << endl;
+kdDebug(5006) << "                Content-Type: " << cntType << endl;
+    if( parentItem )
+      mMimePartTreeItem = new KMMimePartTreeItem( parentItem,
+                                                  this,
+                                                  cntDesc,
+                                                  cntType,
+                                                  cntEnc,
+                                                  cntSize,
+                                                  revertOrder );
+    else if( mimePartTree )
+      mMimePartTreeItem = new KMMimePartTreeItem( mimePartTree,
+                                                  this,
+                                                  cntDesc,
+                                                  cntType,
+                                                  cntEnc,
+                                                  cntSize );
+    mMimePartTreeItem->setOpen( true );
+    if( mChild )
+        mChild->fillMimePartTree( mMimePartTreeItem, 0,
+                                  QString::null, QString::null, QString::null, 0,
+                                  revertOrder );
+
+  }
+}
+
+void partNode::adjustDefaultType( partNode* node )
+{
+    // Only bodies of  'Multipart/Digest'  objects have
+    // default type 'Message/RfC822'.  All other bodies
+    // have default type 'Text/Plain'  (khz, 5.12.2001)
+    if( node && DwMime::kTypeUnknown == node->type() ) {
+        if(    node->mRoot
+               && DwMime::kTypeMultipart == node->mRoot->type()
+               && DwMime::kSubtypeDigest == node->mRoot->subType() ) {
+            node->setType(    DwMime::kTypeMessage   );
+            node->setSubType( DwMime::kSubtypeRfc822 );
+        }
+        else
+            {
+                node->setType(    DwMime::kTypeText     );
+                node->setSubType( DwMime::kSubtypePlain );
+            }
+    }
+}
+
+bool partNode::isAttachment() const
+{
+  if( !dwPart() )
+    return false;
+  if ( !dwPart()->hasHeaders() )
+    return false;
+  DwHeaders& headers = dwPart()->Headers();
+  if( !headers.HasContentDisposition() )
+    return false;
+  return ( headers.ContentDisposition().DispositionType()
+	   == DwMime::kDispTypeAttachment );
+}
+
+bool partNode::isHeuristicalAttachment() const {
+  if ( isAttachment() )
+    return true;
+  const KMMessagePart & p = msgPart();
+  return !p.fileName().isEmpty() || !p.name().isEmpty() ;
+}
+
+partNode * partNode::next( bool allowChildren ) const {
+  if ( allowChildren )
+    if ( partNode * c = firstChild() )
+      return c;
+  if ( partNode * s = nextSibling() )
+    return s;
+  for ( partNode * p = parentNode() ; p ; p = p->parentNode() )
+    if ( partNode * s = p->nextSibling() )
+      return s;
+  return 0;
+}
+
+bool partNode::isFirstTextPart() const {
+  if ( type() != DwMime::kTypeText )
+    return false;
+  const partNode * root = this;
+  // go up until we reach the root node of a message (of the actual message or
+  // of an attached message)
+  while ( const partNode * p = root->parentNode() ) {
+    if ( p->type() == DwMime::kTypeMessage )
+      break;
+    else
+      root = p;
+  }
+  for ( const partNode * n = root ; n ; n = n->next() )
+    if ( n->type() == DwMime::kTypeText )
+      return n == this;
+  kdFatal() << "partNode::isFirstTextPart(): Didn't expect to end up here..." << endl;
+  return false; // make comiler happy
+}
+
+bool partNode::hasContentDispositionInline() const
+{
+  if( !dwPart() )
+    return false;
+  DwHeaders& headers = dwPart()->Headers();
+  if( headers.HasContentDisposition() )
+    return ( headers.ContentDisposition().DispositionType()
+             == DwMime::kDispTypeInline );
+  else
+    return false;
+}
+
+const QString& partNode::trueFromAddress() const
+{
+  const partNode* node = this;
+  while( node->mFromAddress.isEmpty() && node->mRoot )
+    node = node->mRoot;
+  return node->mFromAddress;
+}