--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines/contactsmodel/src/CNTFLDST.CPP	Tue Feb 02 10:12:17 2010 +0200
@@ -0,0 +1,569 @@
+// Copyright (c) 1997-2009 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:
+//
+
+#include <cntdef.h>
+#include <cntfldst.h>
+#include <txtetext.h>
+#include <confndr.h>
+#include <conlist.h>
+
+
+#include "CNTSTD.H"
+#include <s32mem.h>
+
+const TUid KUidEtextToText={0x100040C8};
+const TUid KUidTextToEtext={0x100040C7};
+
+
+//
+// class CContactFieldStorage
+//
+
+
+// for BC-proofing
+EXPORT_C void CContactFieldStorage::CContactFieldStorage_Reserved1() 
+	{  
+	}
+
+
+
+//
+// class CContactTextField
+//
+
+// for BC-proofing
+EXPORT_C /*virtual*/ void CContactTextField::CContactFieldStorage_Reserved1()
+	{
+	}
+
+EXPORT_C CContactTextField::~CContactTextField()
+/** Deletes the text owned by the object, prior to its destruction. */
+    {
+    delete iText;
+    }
+
+void CContactTextField::InternalizeL(RReadStream& aStream)
+    {
+    TInt maxlen =  aStream.ReadInt32L();
+    if (maxlen > 0)
+    	iText =  HBufC::NewL(aStream, maxlen);
+	}
+
+void CContactTextField::InternalizeL(HBufC* aTextStream,TInt aTextFieldIndex)
+    {
+	TInt pos=0;
+	TPtrC des= *aTextStream;
+	TInt totalLen=des.Length();
+	// remove left part
+	for(TInt i=1;i<=aTextFieldIndex && pos<totalLen;i++)
+		{
+		TInt offset=des.Right(totalLen-pos).Locate(KTextStreamSeparator);
+		if (offset != KErrNotFound)
+			pos+=offset+1;
+		else
+			break;
+		}
+	// remove right part
+	if (totalLen>pos)
+		{
+		TInt len=des.Right(totalLen-pos).Locate(KTextStreamSeparator);
+		if (len>0)
+			iText=des.Mid(pos,len).AllocL();
+		}
+	}
+
+void CContactTextField::ExternalizeL(RWriteStream& aStream) const
+    {
+	// Don't attempt to externalise an empty fieldset.
+	if (iText == NULL)
+		{
+		aStream.WriteInt32L(0);	
+		return;
+		}
+
+    TInt maxlen = iText->Length();
+    aStream.WriteInt32L(maxlen);
+    if(maxlen)
+    	{
+    	aStream << *iText;
+    	}    
+   }
+
+void CContactTextField::ExternalizeL(RWriteStream& aStream,TBool aIsInlineBlob,TInt /*aTextFieldIndex*/) const
+    {
+	
+	if (iText)
+      aStream.WriteL(iText->Des());          
+	if (aIsInlineBlob)
+		{
+		TBuf<1> buffer;
+		buffer.Format(_L("%c"),KTextStreamSeparator);
+		aStream.WriteL(buffer); 
+		}
+  }
+
+
+TStreamId CContactTextField::StoreL(CStreamStore& aStore) const
+    {
+
+    RStoreWriteStream stream;
+    TStreamId id=stream.CreateLC(aStore);
+	ExternalizeL(stream);
+    stream.CommitL();
+    CleanupStack::PopAndDestroy();	// stream
+    return id;
+    }
+
+void CContactTextField::RestoreL(CStreamStore& ,RReadStream& aStream)
+    {
+	InternalizeL(aStream);
+	}
+
+EXPORT_C void CContactTextField::SetTextL(const TDesC& aText)
+/** Sets the field text. 
+
+This function allocates a new HBufC descriptor, deleting any existing one, 
+and copies the new text into it. The function can leave.
+
+@param aText The new field text. */
+	{
+	HBufC* text=aText.AllocL();
+	delete iText;
+	iText=text;
+	}
+
+EXPORT_C void CContactTextField::SetText(HBufC *aHbuf)
+/** Sets the field text. 
+
+The text field object takes ownership of the specified descriptor.
+The function cannot leave.
+
+@param aHbuf The new field text. */
+	{
+	delete iText;
+	iText=aHbuf;
+	}
+
+// zzz this should be binned or tested (and re-written)
+EXPORT_C void CContactTextField::SetTextArray(MDesCArray* anArray)
+/** Sets the field text from a descriptor array. Each descriptor 
+in the array is appended to the text field storage. They are separated by 
+paragraph delimiters (CEditableText::EParagraphDelimiter). Any existing text 
+is replaced.
+
+@param anArray Pointer to array of descriptors to set as the field text. */
+    {
+    TInt count = anArray->MdcaCount();
+    delete (iText);
+	TInt size=0;
+	TInt ii=0;
+    for (;ii<count;ii++)
+    	{
+    	size+=anArray->MdcaPoint(ii).Size();
+    	if (ii<(count-1))
+	    	size++; //for semicolon
+		}
+    iText=HBufC::NewL(size);
+    for (ii=0;ii<count;ii++)
+    	{
+    	TPtrC temp(anArray->MdcaPoint(ii));
+    	TPtr ptr = iText->Des();
+    	ptr.Append(temp);
+    	if (ii<(count-1))
+			ptr.Append(CEditableText::EParagraphDelimiter);
+    	}
+    }
+
+EXPORT_C TPtrC CContactTextField::Text() const
+/** Gets a copy of the text which is stored in the field.
+
+@return Descriptor pointing to a copy of the field data. */
+    {
+    TPtrC text;
+    if (iText)
+    	text.Set(*iText);
+    return text;
+    }
+
+TBool CContactTextField::IsFull() const
+	{
+	return (iText && iText->Size()!=0);
+	}
+
+HBufC *CContactTextField::EncodeL(const TDesC& aText,TUid aConversion) const
+	{
+	HBufC8* text=HBufC8::NewLC(aText.Length()*2);
+	TPtr8 ptr = text->Des();
+	TInt i;
+	for (i=0; i < aText.Length(); i++)
+		{
+		ptr.Append(aText[i] & 0x00FF);
+		ptr.Append((aText[i] >> 8) & 0x00FF);
+		}
+	CCnaConverterList* convList=CCnaConverterList::NewLC(); 
+	CConverterBase* conv = convList->NewConverterL(aConversion); 
+	if (!conv)
+		{
+		CleanupStack::PopAndDestroy();          // convList 
+		User::Leave(KErrNotSupported);
+		}
+	CleanupStack::PushL(conv);
+	CBufFlat* decodeBuffer = CBufFlat::NewL(256); 
+	CleanupStack::PushL(decodeBuffer);
+	CBufFlat* encodedBuffer = CBufFlat::NewL(256); 
+	CleanupStack::PushL(encodedBuffer);
+	decodeBuffer->InsertL(0,ptr);
+	RBufReadStream readStream;
+	RBufWriteStream writeStream;
+	readStream.Open(*decodeBuffer);
+	writeStream.Open(*encodedBuffer);
+	conv->ConvertObjectL(readStream, writeStream); 
+	readStream.Close();
+	TInt size=encodedBuffer->Size();
+	HBufC* writeBuf=HBufC::NewLC(size); 
+	TPtr resulttext = writeBuf->Des();
+	for(i = 0; i < (size - 1); i += 2)
+		{
+		resulttext.Append((encodedBuffer->Ptr(0)[i + 1] << 8) | 
+			encodedBuffer->Ptr(0)[i]);
+		}
+
+	writeStream.CommitL();
+	writeStream.Close();
+	CleanupStack::Pop(); // writebuf
+	CleanupStack::PopAndDestroy(2); // buffers 
+	CleanupStack::PopAndDestroy(2); //conv+convList 
+	CleanupStack::PopAndDestroy();  //text
+	return (writeBuf);
+	}
+
+
+EXPORT_C TPtrC CContactTextField::StandardTextLC() const
+/** Converts a copy of the text stored in the field from Symbian editable text 
+format into plain text and returns it as a pointer descriptor.
+
+@return Descriptor pointing to a copy of the field data as plain text. */
+    {
+    TPtrC text;
+    if (iText)
+		text.Set(*iText);
+	HBufC *hbuf=EncodeL(text,KUidEtextToText);
+	CleanupStack::PushL(hbuf);
+	return(hbuf->Des());
+	}
+
+EXPORT_C void CContactTextField::SetStandardTextL(const TDesC& aText)
+/** Converts a text string from plain text into Symbian editable text, and sets 
+this as the text which is stored in the field.  The text is truncated to
+KCntMaxTextFieldLength characters if necessary.
+
+@param aText The new field data. */
+	{
+	// Make a copy of aText and truncate if necessary.
+	TPtr truncText(const_cast<TUint16*>(aText.Ptr()),KCntMaxTextFieldLength);
+	truncText.SetLength(aText.Length()>KCntMaxTextFieldLength ? KCntMaxTextFieldLength : aText.Length());
+
+	HBufC* text=EncodeL(truncText,KUidTextToEtext);
+	delete iText;
+	iText=text;
+	}
+
+EXPORT_C void CContactTextField::SetStandardTextArray(MDesCArray* anArray)
+/** Converts an array of text strings from plain text into Symbian editable text, 
+appends them to a single descriptor, separating them with the new line character, 
+and sets this as the text which is stored in the field. Any existing field 
+text is replaced.  The text is truncated to KCntMaxTextFieldLength characters if
+necessary.
+
+@param anArray Array of descriptors to set as the field data. */
+    {
+    TInt count = anArray->MdcaCount();
+    HBufC *txt=HBufC::NewL(0);
+	CleanupStack::PushL(txt);
+    for (TInt ii=0;ii<count;ii++)
+    	{
+		TInt mdcaLen=anArray->MdcaPoint(ii).Size();
+		if (mdcaLen>0)
+			{
+    		if (txt->Length()>0)
+				txt->Des().Append(TChar('\n'));
+    		txt=txt->ReAllocL(txt->Length()+mdcaLen+1);	// +1 In case we add '\n'
+			CleanupStack::Pop();	// txt(old value)
+			CleanupStack::PushL(txt);
+    		TPtrC temp(anArray->MdcaPoint(ii));
+    		txt->Des().Append(temp);
+			}
+    	}
+
+	// Truncate if necessary.
+	if (txt->Length()>KCntMaxTextFieldLength)
+		{
+		txt->Des().SetLength(KCntMaxTextFieldLength);
+		}
+		
+	HBufC *text=EncodeL(txt->Des(),KUidTextToEtext);
+	CleanupStack::PopAndDestroy();	// txt
+	delete iText;
+    iText=text;
+    }
+
+//
+// class CContactDateField
+//
+
+
+// for BC-proofing
+EXPORT_C /*virtual*/ void CContactDateField::CContactFieldStorage_Reserved1()
+	{
+	}
+
+CContactDateField::CContactDateField()
+	{
+	iTime=Time::NullTTime();
+	}
+
+TStreamId CContactDateField::StoreL(CStreamStore& aStore) const
+    {
+    RStoreWriteStream stream;
+    TStreamId id=stream.CreateLC(aStore);
+	ExternalizeL(stream);
+    stream.CommitL();
+    CleanupStack::PopAndDestroy();	// stream
+    return id;
+    }
+
+void CContactDateField::RestoreL(CStreamStore& ,RReadStream& aStream)
+	{
+	InternalizeL(aStream);
+	}
+
+void CContactDateField::InternalizeL( RReadStream& aStream)
+    {
+    TInt64 timevalue;
+    aStream>>timevalue;
+	iTime=TTime(timevalue);
+    }
+
+void CContactDateField::ExternalizeL(RWriteStream& aStream) const
+    {
+	aStream<<iTime.Int64();
+    }
+
+EXPORT_C void CContactDateField::SetTime(TTime aTime)
+/** Sets the date/time stored in the field from a TTime value.
+
+@param aTime The field's new date/time value. */
+    {
+    iTime=aTime;
+    }
+
+EXPORT_C void CContactDateField::SetTime(TDateTime aDateTime)
+/** Sets the date/time stored in the field from a TDateTime value.
+
+@param aDateTime The field's new date/time value. */
+    {
+    iTime=TTime(aDateTime);
+    }
+
+EXPORT_C TTime CContactDateField::Time() const
+/** Gets the date/time stored in the field as a TTime value.
+
+@return The field's date/time value. */
+    {
+    return iTime;
+    }
+
+TBool CContactDateField::IsFull() const
+	{
+	return(iTime!=Time::NullTTime());
+	}
+
+//
+// class CContactStoreField
+//
+
+// for BC-proofing
+EXPORT_C /*virtual*/ void CContactStoreField::CContactFieldStorage_Reserved1()
+	{
+	}
+
+CContactStoreField::~CContactStoreField()
+	{
+	delete iThing;
+	}
+
+TStreamId CContactStoreField::StoreL(CStreamStore& aStore) const
+    {
+    RStoreWriteStream stream;
+    TStreamId id=stream.CreateLC(aStore);
+	ExternalizeL(stream);
+    stream.CommitL();
+    CleanupStack::PopAndDestroy();	// stream
+    return id;
+    }
+
+void CContactStoreField::RestoreL(CStreamStore&, RReadStream& aStream)
+	{
+	InternalizeL(aStream);
+	}
+
+void CContactStoreField::InternalizeL(RReadStream& aStream)
+    {
+    TInt32 length;
+    aStream>>length;
+    if (iThing)
+    	{
+    	delete (iThing);
+    	}
+    if (length)
+    	{
+		// stream the HBufC descriptor in from the the stream store
+    	iThing=HBufC8::NewLC(aStream,length);
+    	CleanupStack::Pop();// buf
+    	}
+    }
+
+void CContactStoreField::ExternalizeL(RWriteStream& aStream) const
+    {
+    if (IsFull())
+    	{
+    	aStream<<TInt32(iThing->Size());
+    	aStream<<*iThing;
+    	}
+    else
+    	{
+    	aStream<<TInt32(0);
+    	}
+    }
+
+
+EXPORT_C void CContactStoreField::SetThingL(const TDesC8& aDes)
+/** Sets the field data from an 8-bit descriptor.
+
+@param aDes 8-bit descriptor containing the binary data to copy into the 
+field. */
+    {
+    if (iThing)
+    	{
+    	delete (iThing);
+    	}
+	iThing = aDes.AllocL();
+    }
+
+EXPORT_C void CContactStoreField::SetThingL(const HBufC8& aBuf)
+/** Sets the field data from an 8-bit heap descriptor.
+
+@param aDes 8-bit heap descriptor containing the binary data to copy into the field. */
+    {
+    if (iThing)
+    	{
+    	delete (iThing);
+    	}
+	iThing = aBuf.AllocL();
+    }
+
+EXPORT_C void CContactStoreField::SetThingL(const CBufBase* aBuf)
+/** Sets the field data from a buffer.
+
+@param aBuf Buffer containing the binary data to copy into the field. */
+	{
+	TInt len=aBuf->Size();
+	HBufC8* buf=HBufC8::NewLC(len);
+	TPtr8 ptr=buf->Des();
+	TInt pos=0;
+	while (pos<len)
+		{
+		ptr.Append(CONST_CAST(CBufBase*,aBuf)->Ptr(pos));
+		pos=ptr.Length();
+		}
+	CleanupStack::Pop(buf);
+    if (iThing)
+    	{
+    	delete (iThing);
+    	}
+	iThing=buf;
+	}
+
+EXPORT_C HBufC8* CContactStoreField::Thing() const
+/** Gets a pointer to the binary data stored in the field.
+
+@return Pointer to the binary data stored in the field. */
+    {
+    return iThing;
+    }
+
+TBool CContactStoreField::IsFull() const
+	{
+	return (iThing && iThing->Size()!=0);
+	}
+
+//
+// class CContactAgentField
+//
+
+// for BC-proofing
+EXPORT_C /*virtual*/ void CContactAgentField::CContactFieldStorage_Reserved1()
+	{
+	}
+
+TStreamId CContactAgentField::StoreL(CStreamStore& aStore) const
+    {
+    RStoreWriteStream stream;
+    TStreamId id=stream.CreateLC(aStore);
+	ExternalizeL(stream);
+    stream.CommitL();
+    CleanupStack::PopAndDestroy();	// stream
+    return id;
+    }
+
+void CContactAgentField::RestoreL(CStreamStore& ,RReadStream& aStream)
+    {
+	InternalizeL(aStream);
+	}
+
+void CContactAgentField::InternalizeL( RReadStream& aStream)
+    {
+    iAgentId=TContactItemId(aStream.ReadInt32L());
+    }
+
+void CContactAgentField::ExternalizeL(RWriteStream& aStream) const
+    {
+	aStream.WriteInt32L(iAgentId);
+    }
+
+EXPORT_C void CContactAgentField::SetAgentId(TContactItemId aId)
+/** 
+* Sets the agent ID field data.
+* @param aId The agent ID. Must be > 0 otherwise it won't be set.
+*/
+    {
+    if (aId > 0)
+        {
+        iAgentId = aId;
+        }
+    }
+
+EXPORT_C TContactItemId CContactAgentField::Value() const
+/** Gets the agent ID field data.
+
+@return The agent ID. */
+    {
+    return iAgentId;
+    }
+
+TBool CContactAgentField::IsFull() const
+	{
+	return (iAgentId!=KNullContactId);
+	}