// clipboard.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/ltkutils.h>

#include <baclipb.h>

#include <S32MEM.H>

#include <S32UCMP.H>

const TUid KClipboardUidTypePlainText = {268450333}; // from TXTETEXT.h

// This could probably be optimised away, but I don't feel that confident

NONSHARABLE_CLASS(TFieldMapExternalizer) : public MExternalizer<TStreamRef>

	{

public:

	TFieldMapExternalizer(const CStoreMap& aMap);

	void ExternalizeL(const TStreamRef& anObject,RWriteStream& aStream) const;

private:

	const CStoreMap* iMap;

	};

RFs OpenFsIfNeededLC(RFs* aFsPtr)

	{

	if (!aFsPtr)

		{

		RFs stackFs;

		CleanupClosePushL(stackFs);

		User::LeaveIfError(stackFs.Connect());

		return stackFs;

		}

	else

		{

		CleanupStack::PushL((CBase*)NULL); // Just so the cleanup stack is the same depth in both cases - this is ok to destroy

		return *aFsPtr;

		}

	}

EXPORT_C void LtkUtils::CopyToClipboardL(const TDesC& aText, RFs* aFs)

	{

	/*

	The simple way of implementing this is as follows. However this gives you a dependancy on etext.dll so is not desirable

	CClipboard* cb = CClipboard::NewForWritingLC(FsL());

	CPlainText* text = CPlainText::NewL();

	CleanupStack::PushL(text);

	text->InsertL(0, aText);

	text->CopyToStoreL(cb->Store(), cb->StreamDictionary(), 0, text->DocumentLength());

	cb->CommitL();

	CleanupStack::PopAndDestroy(2, cb); // text, cb

	*/

	RFs fs = OpenFsIfNeededLC(aFs);

	CClipboard* cb = CClipboard::NewForWritingLC(fs);

	CStreamStore& store = cb->Store();

	CStreamDictionary& dictionary = cb->StreamDictionary();

	// Following adapted from CPlainText::DoCopyToStoreL

	if (aText.Length())

		{

		CStoreMap* map=CStoreMap::NewLC(store);

		//CopyComponentsL(aStore,*map,aPos,aLength);

		// create custom externalizer over the map

		TFieldMapExternalizer fMap(*map);

		RStoreWriteStream stream(fMap);

		TStreamId id=stream.CreateLC(store);

		//CopyToStreamL(stream,aPos,aLength);

		stream.WriteInt32L(aText.Length());

		CBufFlat* textBuf = CBufFlat::NewL(256);

		CleanupStack::PushL(textBuf);

		textBuf->InsertL(0, TPtrC8((const TText8*)aText.Ptr(), aText.Size()));

		RBufReadStream input_stream(*textBuf, 0);

		TMemoryStreamUnicodeSource source(input_stream);

		TUnicodeCompressor c;

		c.CompressL(stream,source,KMaxTInt,aText.Length());

		input_stream.Close();

		stream.WriteUint8L(EFalse); // Indicating !fieldSetPresent

		CleanupStack::PopAndDestroy(textBuf);

		stream.CommitL();

		dictionary.AssignL(KClipboardUidTypePlainText,id);

		map->Reset();

		CleanupStack::PopAndDestroy(2);

		}

	cb->CommitL();

	CleanupStack::PopAndDestroy(cb);

	CleanupStack::PopAndDestroy(); // stackfs

	}

EXPORT_C HBufC* LtkUtils::GetFromClipboardL(RFs* aFs)

	{

	/*

	The simple way of implementing this is as follows. However this gives you a dependancy on etext.dll so is not desirable

	CClipboard* cb = CClipboard::NewForReadingLC(FsL());

	CPlainText* text = CPlainText::NewL();

	CleanupStack::PushL(text);

	text->PasteFromStoreL(cb->Store(), cb->StreamDictionary(), 0);

	HBufC* res = HBufC::NewL(text->DocumentLength());

	TPtr ptr(res->Des());

	text->Extract(ptr, 0);

	CleanupStack::PopAndDestroy(2, cb); // text, cb

	return res;

	*/

	RFs fs = OpenFsIfNeededLC(aFs);

	HBufC* result = NULL;

	CClipboard* cb = CClipboard::NewForReadingLC(fs);

	CStreamStore& store = cb->Store();

	CStreamDictionary& dictionary = cb->StreamDictionary();

	// Adapted from CPlainText::PasteFromStoreL, 

	TStreamId id=dictionary.At(KClipboardUidTypePlainText);

	if (id != KNullStreamId)

		{

		RStoreReadStream stream;

		stream.OpenLC(store, id);

		CBufSeg* buffer = CBufSeg::NewL(512);

		CleanupStack::PushL(buffer);

		TInt length = stream.ReadInt32L();

		RBufWriteStream output_stream(*buffer);

		TMemoryStreamUnicodeSink sink(output_stream);

		TUnicodeExpander e;

		e.ExpandL(sink,stream,length);

		output_stream.CommitL();

		output_stream.Close();

		result = HBufC::NewMaxL(buffer->Size()/sizeof(TText));

		TPtr8 ptr = TPtr8((TText8*)result->Ptr(), 0, buffer->Size());

		buffer->Read(0, ptr);

		CleanupStack::PopAndDestroy(2, &stream); // buffer, stream

		}

	CleanupStack::PopAndDestroy(cb);

	CleanupStack::PopAndDestroy(); // OpenFsIfNeededLC

	if (!result) result = KNullDesC().AllocL();

	return result;

	}

TFieldMapExternalizer::TFieldMapExternalizer(const CStoreMap& aMap)

	: iMap(&aMap)

	{}

void TFieldMapExternalizer::ExternalizeL(const TStreamRef& aRef,RWriteStream& aStream) const

// Write the stream id bound to aRef to aStream. If not bound, write KNullStreamId

//

	{

	TSwizzleC<TAny> swizzle=aRef;

	aStream<<iMap->At(swizzle);

	}