/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  A common base class for Mail application ui classes.

*

*/

// INCLUDE FILES

#include <akntitle.h>

#include <AknsUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <gulicon.h>

#include <msgmailutils.mbg>

#include <miuthdr.h>                    // CImHeader

#include <msvapi.h>                     // CMsvEntry

#include <miutmsg.h>                    // CImEmailMessage

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <ConeResLoader.h>              // RConeResourceLoader

#include <CommonContentPolicy.h>        // ContentPolicy

#include <muiumsvuiserviceutilitiesinternal.h>  // MUIU MTM utils 

#include <AknWaitNoteWrapper.h>

#include <AknWaitDialog.h>

#include <featmgr.h>                    // FeatureManager

#include <bldvariant.hrh>

#include <coeutils.h>

#include <data_caging_path_literals.hrh> 

#include <messaginginternalcrkeys.h>

#include <messagingvariant.hrh>

// Editor base classes:

#include <MsgAttachmentInfo.h>

#include <MsgAttachmentModel.h>

#include <MsgEditorView.h>

#include <MsgBodyControl.h>

#include <MsgAddressControl.h>

#include <MsgRecipientItem.h>

#include <MuiuOperationWait.h>              // CMuiuOperationWait

#include <StringLoader.h>

#include <MsgMailUtils.rsg>

#include "MsgMailAppUi.h"

#include "MsgMailDocument.h"

#include "MsgMailPreferences.h"

#include "MailUtils.h"

// Mail Central Repository handler

#include "CMailCRHandler.h"

// LOCAL CONSTANTS AND MACROS

_LIT(KResourcesWithDir,"z:MsgMailUtils.rSC");

_LIT( KMsgMailMBMFileName, "z:msgmailutils.mbm" );

/// Message details item separator.

_LIT( KMsgDetailsSeparator, "; " );

/// Max length used for message details.

const TInt KMsgMaxDetailsLength    = 128;

// LOCAL FUNCTION PROTOTYPES

typedef TBool (*TParseFunc)( TLex& aLex );

LOCAL_C TBool DoOrReverse( TParseFunc aFunc, TLex& aLex );

LOCAL_C TBool Star( TParseFunc aFunc, TLex& aLex );

LOCAL_C TBool Plus( TParseFunc aFunc, TLex& aLex );

LOCAL_C TBool NoWSCtl( TLex& aLex );

LOCAL_C TBool WSP( TLex& aLex );

LOCAL_C TBool FWS( TLex& aLex );

LOCAL_C TBool CText( TLex& aLex );

LOCAL_C TBool QuotedPair( TLex& aLex );

LOCAL_C TBool FWSCContent( TLex& aLex );

LOCAL_C TBool CContent( TLex& aLex );

LOCAL_C TBool Comment( TLex& aLex );

LOCAL_C TBool CFWS( TLex& aLex );

LOCAL_C TBool AText( TLex& aLex );

LOCAL_C TBool Atom( TLex& aLex );

LOCAL_C TBool DotAtomText( TLex& aLex );

LOCAL_C TBool DotAtom( TLex& aLex );

LOCAL_C TBool DotPlusAText( TLex& aLex );

LOCAL_C TBool QText( TLex& aLex );

LOCAL_C TBool QContent( TLex& aLex );

LOCAL_C TBool FWSQContent( TLex& aLex );

LOCAL_C TBool QuotedString( TLex& aLex );

LOCAL_C TBool LocalPart( TLex& aLex );

LOCAL_C TBool DText( TLex& aLex );

LOCAL_C TBool DContent( TLex& aLex );

LOCAL_C TBool DomainLiteral( TLex& aLex );

LOCAL_C TBool Domain( TLex& aLex );

LOCAL_C TBool FWSDContent( TLex& aLex );

LOCAL_C TBool AddrSpec( TLex& aLex );

LOCAL_C TBool Word( TLex& aLex );

LOCAL_C TBool DisplayName( TLex& aLex );

LOCAL_C TBool CommaMailbox( TLex& aLex );

LOCAL_C TBool AngleAddr( TLex& aLex );

LOCAL_C TBool NameAddr( TLex& aLex );

LOCAL_C TBool Mailbox( TLex& aLex );

LOCAL_C TBool MailboxList( TLex& aLex );

LOCAL_C TBool Group( TLex& aLex );

LOCAL_C TBool Address( TLex& aLex );

// ==================== LOCAL FUNCTIONS ====================

// ----------------------------------------------------

// DoOrReverse()

// Calls aFunc. If it fails, the lexer is returned to 

// the state before calling DoOrReverse().

// ----------------------------------------------------

//

LOCAL_C TBool DoOrReverse( TParseFunc aFunc, TLex& aLex )

	{

	TLexMark mark;

	aLex.Mark( mark );

	if( (*aFunc)(aLex) )

		{

		return ETrue;

		}

	else

		{

		aLex.UnGetToMark( mark );

		return EFalse;

		}

	}

// ----------------------------------------------------

// Star()

// Calls aFunc repeatedly until aFunc returns EFalse.

// The lexer is left to the state where it was after

// the last succesful aFunc call. Returns ETrue if

// at least one call to aFunc succeeded.

// ----------------------------------------------------

//

LOCAL_C TBool Star( TParseFunc aFunc, TLex& aLex )

	{

	TBool hasMore( ETrue );

	TBool hasOne( EFalse );

	while( hasMore )

		{

		if( DoOrReverse( aFunc, aLex ) )

			{

			hasOne = ETrue;	

			}

		else

			{

			hasMore = EFalse;

			}

		}

	return hasOne;

	}

// ----------------------------------------------------

// Like Star() except enforces one succesful call

// to aFunc.

// ----------------------------------------------------

//

LOCAL_C TBool Plus( TParseFunc aFunc, TLex& aLex )

	{

	if( !DoOrReverse( aFunc, aLex ) )

		{

		return EFalse;

		}

	Star( aFunc, aLex );

	return ETrue;

	}

// ----------------------------------------------------

// NO-WS-CTL := %d1-8 / %d11 / %d12 / %d14-31 / %d127 ; US-ASCII 

// control characters that do not include the carriage return, 

// line feed, and white space characters

// ----------------------------------------------------

//

LOCAL_C TBool NoWSCtl( TLex& aLex )

	{

	TChar ch( aLex.Get() );

	return ( (ch >= 1 && ch <= 8)			// CSI: 47 # See a comment above.

		|| ch == 11							// CSI: 47 # See a comment above.

		|| ch == 12							// CSI: 47 # See a comment above.

		|| (ch >= 14 && ch <= 31)			// CSI: 47 # See a comment above.

		|| ch == 127 );						// CSI: 47 # See a comment above.

	}

// ----------------------------------------------------

// text := %d1-9 / %d11 / %d12 / %d14-127 / obs-text ; Characters excluding CR and LF

// ----------------------------------------------------

//

LOCAL_C TBool Text( TLex& aLex )

	{

	TChar ch( aLex.Get() );

	return ( (ch >= 1 && ch <= 9)			// CSI: 47 # See a comment above.

		|| ch == 11							// CSI: 47 # See a comment above.

		|| ch == 12							// CSI: 47 # See a comment above.

		|| (ch >= 14 && ch <= 127) );		// CSI: 47 # See a comment above.

	}

// ----------------------------------------------------

// quoted-pair := ("\" text) / obs-qp

// ----------------------------------------------------

//

LOCAL_C TBool QuotedPair( TLex& aLex )

	{

	if( aLex.Get() != '\\' )

		{

		return EFalse;

		}

	return Text( aLex );

	}

// ----------------------------------------------------

// WSP = SPACE / HTAB

// ----------------------------------------------------

//

LOCAL_C TBool WSP( TLex& aLex )

	{

	TChar ch( aLex.Get() );

	return ch == EKeySpace || ch == EKeyTab;

	}

// ----------------------------------------------------

// FWS := ([*WSP CRLF] 1*WSP) / obs-FWS ; Folding white space

// ----------------------------------------------------

//

LOCAL_C TBool FWS( TLex& aLex )

	{

	return Plus( WSP, aLex );

	}

// ----------------------------------------------------

// ctext := NO-WS-CTL / %d33-39 / %d42-91 / %d93-126 ; Non white space 

// controls and The rest of the US-ASCII characters not including "(", ")", or "\"

// ----------------------------------------------------

//

LOCAL_C TBool CText( TLex& aLex )

	{

	if( !DoOrReverse( NoWSCtl, aLex ) )

		{

		TChar ch( aLex.Get() );

		return( (ch >= 33 && ch <= 39)				// CSI: 47 # See a comment above.

			|| (ch >= 42 && ch <= 91)				// CSI: 47 # See a comment above.

			|| (ch >= 93 && ch <= 126) );			// CSI: 47 # See a comment above.

		}

	else

		{

		return ETrue;

		}

	}

// ----------------------------------------------------

// ccontent := ctext / quoted-pair / comment

// ----------------------------------------------------

//

LOCAL_C TBool CContent( TLex& aLex )

	{

	return DoOrReverse( CText, aLex ) || DoOrReverse( QuotedPair, aLex ) || Comment( aLex );

	}

// ----------------------------------------------------

// [FWS] ccontent

// ----------------------------------------------------

//

LOCAL_C TBool FWSCContent( TLex& aLex )

	{

	FWS( aLex );

	return CContent( aLex );

	}

// ----------------------------------------------------

// comment := "(" *([FWS] ccontent) [FWS] ")"

// ----------------------------------------------------

//

LOCAL_C TBool Comment( TLex& aLex )

	{

	if( aLex.Get() != '(' )

		{

		return EFalse;

		}

	Star( FWSCContent, aLex );

	FWS( aLex );

	return aLex.Get() == ')';

	}

// ----------------------------------------------------

// [FWS] comment

// ----------------------------------------------------

//

LOCAL_C TBool FWSComment( TLex& aLex )

	{

	FWS( aLex );

	return Comment( aLex );

	}

// ----------------------------------------------------

// CFWS := *([FWS] comment) (([FWS] comment) / FWS)

// ----------------------------------------------------

//

LOCAL_C TBool CFWS( TLex& aLex )

	{

	TBool hasOne( Star( FWSComment, aLex ) );

	return hasOne || FWS( aLex );

	}

// ----------------------------------------------------

// atext := ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / 

// "-" / "/" / "=" / "?" "^" / "_" / "`" / "{" / "|" / "}" / "~"; Any 

// character except controls, SP, and specials. Used for atoms

// ----------------------------------------------------

//

LOCAL_C TBool AText( TLex& aLex )

	{

	//ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" "^" / "_" / 

	//	"`" / "{" / "|" / "}" / "~"

	TChar ch( aLex.Get() );

	return( (ch >= 'a' && ch <= 'z' )

		|| (ch >= 'A' && ch <= 'Z' )

		|| (ch >= '0' && ch <= '9' )

		|| ch == '!'

		|| ch == '#'

		|| ch == '$'

		|| ch == '%'

		|| ch == '&'

		|| ch == '\''

		|| ch == '*'

		|| ch == '+'

		|| ch == '-'

		|| ch == '/'

		|| ch == '='

		|| ch == '?'

		|| ch == '^'

		|| ch == '_'

		|| ch == '`'

		|| ch == '{'

		|| ch == '|'

		|| ch == '}'

		|| ch == '~' );

	}

// ----------------------------------------------------

// atom := [CFWS] 1*atext [CFWS]

// ----------------------------------------------------

//

LOCAL_C TBool Atom( TLex& aLex )

	{

	DoOrReverse( CFWS, aLex );

	if( !Plus( AText, aLex ) )

		{

		return EFalse;

		}

	DoOrReverse( CFWS, aLex );

	return ETrue;

	}

// ----------------------------------------------------

// dot-atom := [CFWS] dot-atom-text [CFWS]

// ----------------------------------------------------

//

LOCAL_C TBool DotAtom( TLex& aLex )

	{

	DoOrReverse( CFWS, aLex );

	if( !DoOrReverse( DotAtomText, aLex ) )

		{

		return EFalse;

		}

	DoOrReverse( CFWS, aLex );

	return ETrue;

	}

// ----------------------------------------------------

// "." 1*atext

// ----------------------------------------------------

//

LOCAL_C TBool DotPlusAText( TLex& aLex )

	{

	return aLex.Get() == '.' && Plus( AText, aLex );

	}

// ----------------------------------------------------

// dot-atom-text := 1*atext *("." 1*atext)

// ----------------------------------------------------

//

LOCAL_C TBool DotAtomText( TLex& aLex )

	{

	if( !Plus( AText, aLex ) )

		{

		return EFalse;

		}

	Star( DotPlusAText, aLex );

	return ETrue;

	}

// ----------------------------------------------------

// qtext := NO-WS-CTL / %d33 / %d35-91 / %d93-126 ; Non white space 

// controls and The rest of the US-ASCII characters not including "\" 

// or the quote character

// ----------------------------------------------------

//

LOCAL_C TBool QText( TLex& aLex )

	{

	if( DoOrReverse( NoWSCtl, aLex ) )

		{

		return ETrue;

		}

	TChar ch( aLex.Get() );

	return ch == 33						// CSI: 47 # See a comment above.

		|| (ch >= 35 && ch <= 91)		// CSI: 47 # See a comment above.

		|| (ch >= 93 && ch <= 126);		// CSI: 47 # See a comment above.

	}

// ----------------------------------------------------

// qcontent := qtext / quoted-pair

// ----------------------------------------------------

//

LOCAL_C TBool QContent( TLex& aLex )

	{

	return DoOrReverse( QText, aLex ) || QuotedPair( aLex );

	}

// ----------------------------------------------------

// [FWS] qcontent

// ----------------------------------------------------

//

LOCAL_C TBool FWSQContent( TLex& aLex )

	{

	FWS( aLex );

	return QContent( aLex );

	}

// ----------------------------------------------------

// quoted-string := [CFWS] DQUOTE *([FWS] qcontent) [FWS] DQUOTE [CFWS]

// ----------------------------------------------------

//

LOCAL_C TBool QuotedString( TLex& aLex )

	{

	DoOrReverse( CFWS, aLex );

	if( aLex.Get() != '"' )

		{

		return EFalse;

		}

	Star( FWSQContent, aLex );

	DoOrReverse( FWS, aLex );

	if( aLex.Get() != '"' )

		{

		return EFalse;

		}

	DoOrReverse( CFWS, aLex );

	return ETrue;

	}

// ----------------------------------------------------

// word := atom / quoted-string

// ----------------------------------------------------

//

LOCAL_C TBool Word( TLex& aLex )

	{

	return DoOrReverse( Atom, aLex ) || QuotedString( aLex );

	}

// ----------------------------------------------------

// address := mailbox / group

// ----------------------------------------------------

//

LOCAL_C TBool Address( TLex& aLex )

	{

	return DoOrReverse( Mailbox, aLex ) || Group( aLex );

	}

// ----------------------------------------------------

// mailbox := name-addr / addr-spec

// ----------------------------------------------------

//

LOCAL_C TBool Mailbox( TLex& aLex )

	{

	return DoOrReverse( NameAddr, aLex ) || AddrSpec( aLex );

	}

// ----------------------------------------------------

// name-addr := [display-name] angle-addr

// ----------------------------------------------------

//

LOCAL_C TBool NameAddr( TLex& aLex )

	{

	DoOrReverse( DisplayName, aLex );

	return AngleAddr( aLex );

	}

// ----------------------------------------------------

// angle-addr := [CFWS] "<" addr-spec ">" [CFWS] / obs-angle-addr

// ----------------------------------------------------

//

LOCAL_C TBool AngleAddr( TLex& aLex )

	{

	DoOrReverse( CFWS, aLex );

	if( aLex.Get() != '<' )

		{

		return EFalse;

		}

	if( !DoOrReverse( AddrSpec, aLex ) )

		{