libraries/ltkutils/src/clipboard.cpp
author Tom Sutcliffe <thomas.sutcliffe@accenture.com>
Thu, 26 Aug 2010 00:49:35 +0100
changeset 45 534b01198c2d
parent 0 7f656887cf89
permissions -rw-r--r--
Added ENotifyKeypresses and ECaptureCtrlC flags to CCommandBase. Commands can now get keypresses and handle ctrl-C via callbacks instead of having to implement custom active objects. As part of this extended the CCommandBase extension interface to MCommandExtensionsV2 for the new virtual functions KeyPressed(TUint aKeyCode, TUint aModifiers) and CtrlCPressed(). sudo now cleans up correctly by using ECaptureCtrlC.

// 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);
	}