// 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:
// Started by DS, October 1996
// Clipboard
// 
//

#include <baclipb.h>
#include <s32file.h>
#include <basched.h>
#include <bautils.h>
#include <s32stor.h>
#include <hal.h>
#include <hal_data.h>
#include <baflpan.h>


#ifdef _UNICODE
const TUid KClipboardFileUid16={0x10003A10};
#define KClipboardFileUid KClipboardFileUid16
#else
const TUid KClipboardFileUid8={268435515};
#define KClipboardFileUid KClipboardFileUid8
#endif

_LIT(KClipboardFileName,"\\System\\Data\\Clpboard.cbd");


inline CClipboard::CClipboard(RFs& aFs)
	: iFs(aFs)
	{__DECLARE_NAME(_S("CClipboard"));}

CClipboard* CClipboard::NewLC(RFs& aFs)
	{
	CClipboard* self=new(ELeave) CClipboard(aFs);
    CleanupStack::PushL(self);
	return self;
	}

void CClipboard::ConstructReadL()
	{
	__ASSERT_DEBUG(iStore==NULL&&iStreamDictionary==NULL,User::Invariant());

//	
	TDriveName clipboardDrive = ClipboardFileDrive();
	TFileName clipboardFile(KClipboardFileName);
	clipboardFile.Insert(0,clipboardDrive);

	CFileStore* store=CDirectFileStore::OpenLC(iFs,clipboardFile,EFileRead|EFileShareReadersOnly);
	if (store->Type()!=TUidType(KDirectFileStoreLayoutUid,KClipboardFileUid))
		User::Leave(KErrCorrupt);
	CStreamDictionary* dict=CStreamDictionary::NewLC();
	RStoreReadStream root;
	root.OpenLC(*store,store->Root());
	root >> *dict;
	CleanupStack::PopAndDestroy(); // root stream
//
	CleanupStack::Pop(2);	// store and dictionary
	iStore=store;
	iStreamDictionary=dict;
	}


EXPORT_C TDriveName CClipboard::ClipboardFileDrive()
/**
 Returns the clipboad file drive information stored in the TLS
 
 @return A drive letter and a colon (A:, B:... etc,.)
 @panic BAFL 23 If drive is either not in range 0-24 or is not defined in HAL file(s).
 If this panic occurs, check the value of EClipboardDrive defined in HAL file(s)
 i,e <values.hda> & <config.hcf>. This value should be in range EDriveA-EDriveY.
 */
    {
	TInt drive;
	TInt retVal;
	TBool badDrive = ETrue;

	retVal = HAL::Get(HAL::EClipboardDrive,drive);	
	
	if(retVal == KErrNone)
		{
		//EDriveZ can not be a valid clipboard drive as it is non-writable
		// Check if drive is between range 0-24,
		if(EDriveA <= drive && EDriveY >= drive)
			{
			badDrive = EFalse; // Drive is valid				
			}
		}
			
	__ASSERT_ALWAYS((badDrive == EFalse), ::Panic(EBafPanicBadDrive));

	TDriveUnit driveUnit(drive);
	return driveUnit.Name();
	}

EXPORT_C CClipboard* CClipboard::NewForReadingLC(RFs& aFs)
/** Constructs a clipboard object and prepares the clipboard's store for reading, 
placing a pointer to the object on the cleanup stack. This allows the object 
and allocated resources to be cleaned up if a subsequent leave occurs.

@param aFs A handle to a file server session. 
@return A pointer to the newly constructed clipboard object. This pointer is 
put onto the cleanup stack. */
    {
	CClipboard* self=NewLC(aFs);
	TRAPD(error,self->ConstructReadL());
	switch (error)
		{
	default:
		User::LeaveIfError(error);
		__ASSERT_DEBUG(self->iStore!=NULL&&self->iStreamDictionary!=NULL,User::Invariant());
		break;
	case KErrPathNotFound:	// clipboard does not exist
	case KErrNotFound:		// no root stream
	case KErrInUse:			// someone is writing to the clipboard
	case KErrCorrupt:		// type is invalid, or cardinality failure
	case KErrEof:			// wrong structure
	case KErrNotSupported:	// not a file store
		// return an empty clipboard: will need an empty dictionary
		__ASSERT_DEBUG(self->iStore==NULL&&self->iStreamDictionary==NULL,User::Invariant());
		self->iStreamDictionary=CStreamDictionary::NewL();
		break;
		}
	return(self);
	}

EXPORT_C CClipboard* CClipboard::NewForReadingL(RFs& aFs)
/** Constructs a clipboard object and prepares the clipboard's store for reading.

@param aFs A handle to a file server session. 
@return A pointer to the newly constructed clipboard object. */
	{
	CClipboard* self=CClipboard::NewForReadingLC(aFs);
	CleanupStack::Pop();
	return self;
	}

EXPORT_C CClipboard* CClipboard::NewForWritingLC(RFs& aFs)
/** Constructs a clipboard object and prepares the clipboard's store for writing.

If the file associated with the clipboard's store does not exist, it is created; 
if it already exists, any existing content is discarded.

@param aFs A handle to a file server session. 
@return A pointer to the newly constructed clipboard object. This pointer is 
put onto the cleanup stack. */
    {
	CClipboard* self=NewLC(aFs);
	self->iStreamDictionary=CStreamDictionary::NewL();
//
	TDriveName clipboardDrive = ClipboardFileDrive();
	TFileName clipboardFile(KClipboardFileName);
	clipboardFile.Insert(0,clipboardDrive);

	RFile file;
	TInt r=file.Open(aFs,clipboardFile,EFileRead|EFileWrite);

	/**
	 * The following branching is desired at this stage:
	 * -> if the path is not present, we need to create it and then create the file. 
	 * -> if the path is present, we only need to create the file 
	 * -> if both path and file exists, we don't need to do anything 
	 * 
	 * Instead of the switch case block we can achieve this by atleast 2 other means.
 	 * Option 1:
	 * RFile file; 
	 * TInt r=file.Open(aFs,clipboardFile,EFileRead|EFileWrite); 
	 * if(r == KErrPathNotFound) { 
	 *       BaflUtils::EnsurePathExistsL(aFs,clipboardFile); 
	 *       r=file.Replace(aFs,clipboardFile,EFileRead|EFileWrite); 
	 * } else if(r == KErrNotFound) { 
	 *       r=file.Replace(aFs,clipboardFile,EFileRead|EFileWrite); 
	 * }
	 * User::LeaveIfError(r);
	 *
	 * => the above code has extra check to be made when the error is KErrNotFound 
	 *    and has increased code size owing to repeated file.Replace().
	 *
	 * Option 2:
	 * BaflUtils::EnsurePathExistsL(aFs,clipboardFile); 
	 * RFile file; 
	 * TInt r=file.Open(aFs,clipboardFile,EFileRead|EFileWrite); 
	 * if(r == KErrNotFound) { 
	 *        r=file.Replace(aFs,clipboardFile,EFileRead|EFileWrite); 
	 * } 
	 * User::LeaveIfError(r);
	 * => Call to BaflUtils::EnsurePathExistsL unconditionally which in turn 
	 * invokes Rfs::MkDirAll() can be expensive and errorneous.
	 * (Check documnentation for RFs::MkDirAll()
	 */
 

	//Maintain the order of the switch case and DO NOT add break between the
	//switch cases. They have been written such that only the required set of 
	//functionality is executed based on the Error code.
	switch (r)
		{
	case KErrPathNotFound:		// path has not been created yet
		BaflUtils::EnsurePathExistsL(aFs,clipboardFile);
		// coverity [fallthrough]
		// Missing break intentional. Read comment before switch case.
	case KErrNotFound:			// it does not exist yet
		r=file.Replace(aFs,clipboardFile,EFileRead|EFileWrite);
		// coverity [fallthrough]
		// Missing break intentional. Read comment before switch case.
	default:
		User::LeaveIfError(r);
		}
//
	CFileStore* store=CDirectFileStore::NewL(file);
	self->iStore=store;
	store->SetTypeL(TUidType(KDirectFileStoreLayoutUid,KClipboardFileUid));
	return self;
	}

EXPORT_C TInt CClipboard::Clear(RFs& aFs)
/** Empties the clipboard.

Note that if the file associated with the clipboard's store does not exist, 
this is not regarded as an error and the function completes successfully.

@param aFs A handle to a file server session. 
@return KErrNone if successful, otherwise another of the system-wide error 
codes. */
	{
	TDriveName clipboardDrive = ClipboardFileDrive();
	TFileName clipboardFile(KClipboardFileName);
	clipboardFile.Insert(0,clipboardDrive);

	RFile file;
	TInt r=file.Open(aFs,clipboardFile,EFileWrite);
	switch (r)
		{
	case KErrNone:			// clear without notification
		r=file.SetSize(0);
		file.Close();
		break;
	case KErrPathNotFound:	// no clipboard to clear
	case KErrNotFound:
		r=KErrNone;
		break;
	default:
		r=aFs.Delete(clipboardFile);	// just delete the fella
		break;
		}
	return r;
	}

EXPORT_C CClipboard::~CClipboard()
/** Destructor. Frees all resources owned by the object, prior to its destruction. 
In particular, the file associated with the clipboard's store is closed.

Note that if the clipboard file store has no root stream, i.e. the CommitL() 
member function of CClipboard has not been called prior to deleting the CClipboard 
object, then the file associated with the clipboard file store is deleted. */
    {
	delete iStreamDictionary;
	CFileStore* store=iStore;
	if (store!=NULL)
		{
		TBool rollback=(store->Root()==KNullStreamId);
   		delete store;
		if (rollback)	// useless clipboard, no root stream
			{
			TDriveName clipboardDrive = ClipboardFileDrive();
			TFileName clipboardFile(KClipboardFileName);
			clipboardFile.Insert(0,clipboardDrive);
			
			iFs.Delete(clipboardFile);
			}
		}
    }

EXPORT_C void CClipboard::CommitL()
/** Commits changes to the clipboard's store.

It externalises the stream dictionary to the clipboard store as the root stream 
and then commits all changes to the store. This function must be called after 
application data has been externalised; failure to do so results in the deletion 
of the file associated with the clipboard store and the loss of data. */
	{
	__ASSERT_DEBUG(iStore!=NULL&&iStreamDictionary!=NULL,User::Invariant());
//
	CFileStore& store=*iStore;
	RStoreWriteStream stream;
	TStreamId root=stream.CreateLC(store);
	stream<< *iStreamDictionary;
	stream.CommitL();
	CleanupStack::PopAndDestroy(); // dictionary stream
	store.SetRootL(root);
	store.CommitL();
	}


// Copy and paste member functions for low level data types


const TUid KClipboardRealTypeUid = { 268435705 };


EXPORT_C void  CClipboard::CopyToL(TReal aReal) __SOFTFP
/** Copies a double-precision floating point value to the clipboard.

Note that the function does not automatically commit changes to the clipboard's 
store. This must be done explicitly.

@param aReal The double-precision floating point value to be copied to the 
clipboard.
@see CommitL() */
    {
	__ASSERT_DEBUG(iStore!=NULL&&iStreamDictionary!=NULL,User::Invariant());
//
    RStoreWriteStream stream;
    TStreamId id = stream.CreateLC ( Store() );
    stream << aReal;
	stream.CommitL();
    CleanupStack::PopAndDestroy();
    StreamDictionary().AssignL ( KClipboardRealTypeUid, id );
    }

EXPORT_C TBool CClipboard::PasteFromL  ( TReal& aReal )
/** Pastes a double-precision floating point value from the clipboard.

If a double-precision floating point value exists on the clipboard, then the 
function restores it to the referenced argument and returns a true value.

If there is no double-precision floating point value on the clipboard, then 
the function returns a false value. The referenced argument is not changed.

@param aReal On return, contains the double-precision floating point value 
found on the clipboard.
@return ETrue, if a double-precision floating point value exists on the 
clipboard and has been pasted to the referenced argument; EFalse otherwise. */
    {
	__ASSERT_DEBUG(iStreamDictionary!=NULL,User::Invariant());
    TStreamId id = StreamDictionary().At(KClipboardRealTypeUid);
    if (id == KNullStreamId)
		return (EFalse); // nothing here
    __ASSERT_DEBUG(iStore!=NULL,User::Invariant());
	RStoreReadStream stream;
    stream.OpenLC (Store(), id);
    stream >> aReal;
    CleanupStack::PopAndDestroy();
    return (ETrue);
    }



// end of BACLIPB.CPP