/*
* Copyright (c) 2008 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 "creator_file.h" 
#include <DRMRights.h>
#include <caf/supplier.h>
#include <caf/importfile.h>
#include "creator_traces.h"

using namespace ContentAccess;

static const TInt KFilesFieldLength = 256;

//_LIT(KCreatorFilesPrefixName, "CR_");
//_LIT(KCreatorFilesPrefixFolderName, "CR_FLDR_");

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

CFilesParameters::CFilesParameters()
    {
    LOGSTRING("Creator: CFilesParameters::CFilesParameters");
    iFullFilePath = HBufC::New(KFilesFieldLength);
    }
CFilesParameters::CFilesParameters( CFilesParameters& aCopy )
    {
    LOGSTRING("Creator: CFilesParameters::CFilesParameters");
    iFullFilePath = HBufC::New(KFilesFieldLength);
    iFullFilePath->Des().Copy( *aCopy.iFullFilePath );
    iFileCommand = aCopy.iFileCommand;
    iEncrypt = aCopy.iEncrypt;
    if ( aCopy.iPermission )
        {
        iPermission = CDRMPermission::NewL();
        iPermission->DuplicateL( *aCopy.iPermission );
        }
    }
CFilesParameters::~CFilesParameters()
    {
    LOGSTRING("Creator: CFilesParameters::~CFilesParameters");
    delete iFullFilePath;
    delete iPermission;
    }

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

CCreatorFiles* CCreatorFiles::NewL(CCreatorEngine* aEngine)
    {
    CCreatorFiles* self = CCreatorFiles::NewLC(aEngine);
    CleanupStack::Pop(self);
    return self;
    }

CCreatorFiles* CCreatorFiles::NewLC(CCreatorEngine* aEngine)
    {
    CCreatorFiles* self = new (ELeave) CCreatorFiles;
    CleanupStack::PushL(self);
    self->ConstructL(aEngine);
    return self;
    }

CCreatorFiles::CCreatorFiles() :
    iFs ( CEikonEnv::Static()->FsSession() )
    {
    }

void CCreatorFiles::ConstructL(CCreatorEngine* aEngine)
    {
    LOGSTRING("Creator: CCreatorFiles::ConstructL");

    iEngine = aEngine;

    iDirectoryQueriedFromUser = HBufC::New(KFilesFieldLength);
    User::LeaveIfError( iApaLs.Connect() );
    
    iFilePaths = new (ELeave) CDesCArrayFlat( 4 );
    
    // Restore file id 
    CDictionaryFileStore* store = iEngine->FileStoreLC();
    User::LeaveIfNull( store );
    if ( store->IsPresentL( KUidDictionaryUidFiles ) )
        {
        RDictionaryReadStream in;
        in.OpenLC( *store, KUidDictionaryUidFiles );
        TRAPD( err, iFileId = in.ReadInt32L() );
        if ( err )
            {
            iFileId = 1;
            }
        CleanupStack::PopAndDestroy(); // in
        }
    else
        {
        iFileId = 1;
        }
    CleanupStack::PopAndDestroy( store );
    }

CCreatorFiles::~CCreatorFiles()
    {
    LOGSTRING("Creator: CCreatorFiles::~CCreatorFiles");
    
    // this is done only once per file operation:
    if ( iFilePaths && iFilePaths->Count() )
        {
        TRAP_IGNORE( StorePathsForDeleteL( *iFilePaths ) );
        }
    delete iFilePaths;
    delete iDirectoryQueriedFromUser;
    delete iParameters;
    delete iUserParameters;
    iApaLs.Close();
    }

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

TBool CCreatorFiles::AskDataFromUserL(TInt aCommand, TInt& aNumberOfEntries)
    {
    LOGSTRING("Creator: CCreatorFiles::AskDataFromUserL");
    
    if ( aCommand == ECmdDeleteCreatorFiles )
        {
        return iEngine->YesNoQueryDialogL( _L("Delete all files created with Creator?") );
        }
    
    delete iUserParameters;
    iUserParameters = NULL;
    iUserParameters = new(ELeave) CFilesParameters();
    
    iDirectoryQueriedFromUser->Des().Copy( KNullDesC );

    if (iEngine->EntriesQueryDialogL(aNumberOfEntries, _L("How many entries to create?")))
        {
        // set a default directory  (eg. c:\Nokia\Images\)
        TFileName directory;
        iEngine->SetDefaultPathForFileCommandL(aCommand, directory);

        // directory query dialog
        CAknTextQueryDialog* textDialog = CAknTextQueryDialog::NewL(directory, CAknQueryDialog::ENoTone);
        textDialog->SetMaxLength(256);

        TBuf<50> promptText;

        if (aCommand == ECmdCreateFileEntryEmptyFolder)
            promptText.Copy( _L("Specify the folder path and name") );
        else
            promptText.Copy( _L("Specify the directory") );

        if (textDialog->ExecuteLD(R_DIRECTORY_QUERY, promptText))
            {
	        // check that the root folder is correct
            if (directory.Length() < 3  ||  BaflUtils::CheckFolder(iFs, directory.Left(3)) != KErrNone)
                {
                CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
                errorNote->ExecuteLD(_L("Invalid path"));
                return EFalse;
                }        
            else
                {
                // check the directory contains a trailing backlash
                if (directory.Right(1) != _L("\\"))
                    directory.Append(_L("\\"));

                // copy the directory name to a class member
                iDirectoryQueriedFromUser->Des() = directory;
                if ( aCommand == ECmdCreateFileEntryEmptyFolder ) return ETrue;
                else return AskDRMDataFromUserL();
                }
            }        
        else
            return EFalse;
        }
    else
        return EFalse;

    }


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

TInt CCreatorFiles::CreateFileEntryL(CFilesParameters *aParameters, TInt aCommand)
    {
    LOGSTRING("Creator: CCreatorFiles::CreateFileEntryL");

    // clear any existing parameter definations
    delete iParameters;
    iParameters = NULL;
    TFileName directoryToBeCreated;
            
    CFilesParameters* parameters = aParameters;
    
    if (!parameters)
        {
        if ( iUserParameters )
            {
            iParameters = new (ELeave) CFilesParameters( *iUserParameters );
            // iUserParameters = NULL;
            }
        else
            {
            // random data needed if no predefined data available
            iParameters = new (ELeave) CFilesParameters;            
            }
        parameters = iParameters;
        }

    TInt err = KErrNone;

    // if we just create directories
    if ( aCommand == ECmdCreateFileEntryEmptyFolder)
        {
        // strip the last backslash from the path
        if( iDirectoryQueriedFromUser && iDirectoryQueriedFromUser->Des().Length() > 0)
        	directoryToBeCreated = iDirectoryQueriedFromUser->Des();
        else if( parameters->iFullFilePath && parameters->iFullFilePath->Des().Length() > 0 )
        	directoryToBeCreated = parameters->iFullFilePath->Des();
        else 
        	return err;
        
        _LIT(KSlash, "\\");
        if( directoryToBeCreated.Right(1) == KSlash )
        	directoryToBeCreated.SetLength ( directoryToBeCreated.Length() - 1 ); 
            
        // generate a unique file name
        err = CApaApplication::GenerateFileName( iFs, directoryToBeCreated);
        if (err != KErrNone)
            return err;

        // now append the backslah back
        directoryToBeCreated.Append( _L("\\") );
        
        // now create the new directory
        err = iFs.MkDirAll( directoryToBeCreated );
        
        // Add directoryToBeCreated to store
        iFilePaths->AppendL( directoryToBeCreated );

        LOGSTRING3("Creator: CCreatorFiles::CreateFileEntryL creating empty directory %S returns err", &directoryToBeCreated, err);
        }

    else  // files
        {
        LOGSTRING2("Creator: CCreatorFiles::CreateFileEntryL file id is %d", aCommand);

        // get source
        TFileName fullSourcePath;
        switch (aCommand)
            {
	        case ECmdCreateFileEntryJPEG_25kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJPEG_25kB );  break; }
	        case ECmdCreateFileEntryJPEG_200kB:     { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJPEG_200kB );  break; }
	        case ECmdCreateFileEntryJPEG_500kB:     { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJPEG_500kB );  break; }
	        case ECmdCreateFileEntryPNG_15kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EPNG_15kB );  break; }
	        case ECmdCreateFileEntryGIF_2kB:        { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EGIF_2kB );  break; }
	        case ECmdCreateFileEntryRNG_1kB:        { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ERNG_1kB );  break; }
	        case ECmdCreateFileEntryMIDI_10kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMIDI_10kB );  break; }
	        case ECmdCreateFileEntryWAV_20kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWAVE_20kB );  break; }
	        case ECmdCreateFileEntryAMR_20kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EAMR_20kB );  break; }
	        case ECmdCreateFileEntryXLS_15kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EExcel_15kB );  break; }
	        case ECmdCreateFileEntryDOC_20kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWord_20kB );  break; }
	        case ECmdCreateFileEntryPPT_40kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EPowerPoint_40kB );  break; }
	        case ECmdCreateFileEntryTXT_10kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EText_10kB );  break; }
	        case ECmdCreateFileEntryTXT_70kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EText_70kB );  break; }
	        case ECmdCreateFileEntry3GPP_70kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::E3GPP_70kB );  break; }
	        case ECmdCreateFileEntryMP3_250kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMP3_250kB );  break; }
	        case ECmdCreateFileEntryAAC_100kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EAAC_100kB );  break; }
	        case ECmdCreateFileEntryRM_95kB:        { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ERM_95kB );  break; }
	        case ECmdCreateFileEntryBMP_25kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EBMP_25kB );  break; }
	        case ECmdCreateFileEntryDeck_1kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESavedDeck_1kB );  break; }
	        case ECmdCreateFileEntryHTML_20kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EHTML_20kB );  break; }
	        case ECmdCreateFileEntryJAD_1kB:        { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJAD_1kB );  break; }
	        case ECmdCreateFileEntryJAR_10kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJAR_10kB );  break; }
	        case ECmdCreateFileEntryJP2_65kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJP2_65kB );  break; }
	        case ECmdCreateFileEntryMP4_200kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMP4_200kB );  break; }
	        case ECmdCreateFileEntryMXMF_40kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMXMF_40kB );  break; }
	        case ECmdCreateFileEntryRAM_1kB:        { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ERAM_1kB );  break; }
	        case ECmdCreateFileEntrySVG_15kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESVG_15kB );  break; }
	        case ECmdCreateFileEntrySWF_15kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESWF_15kB );  break; }
	        case ECmdCreateFileEntryTIF_25kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ETIF_25kB );  break; }
	        case ECmdCreateFileEntryVCF_1kB:        { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EVCF_1kB );  break; }
	        case ECmdCreateFileEntryVCS_1kB:        { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EVCS_1kB );  break; }
	        case ECmdCreateFileEntrySISX_10kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESISX_10kB );  break; }
	        case ECmdCreateFileEntryWMA_50kB:       { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWMA_50kB );  break; }
	        case ECmdCreateFileEntryWMV_200kB:      { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWMV_200kB );  break; }
	        case ECmdCreateFileEntryEmptyFolder:    { User::Panic(_L("EmptyFolder"), 801); break; }
	        default:                                { return KErrPathNotFound; }
            }


        // define the full target path
        TFileName fullTargetPath;

        if ( parameters->iFullFilePath && parameters->iFullFilePath->Des().Length() > 3 )
            {
            _LIT(KSlash, "\\");
            // check the path is ok
            fullTargetPath = parameters->iFullFilePath->Des();
            
            if(fullTargetPath.Right(1) == KSlash)
                {
                // Remove '\' from the end, because the filename check does not work with it:
                fullTargetPath.SetLength ( fullTargetPath.Length() - 1 );
                }
            
            if (!iFs.IsValidName( fullTargetPath ))
		        User::Leave(KErrBadName);

            // target path = directory + the file name from source path
            TParse parser;
            parser.Set(fullSourcePath, NULL, NULL);
            
            // Add '\' to the end:
            fullTargetPath.Append(KSlash);            
            // Add filename:
            fullTargetPath.Append( parser.NameAndExt() );

            LOGSTRING2("Creator: CCreatorFiles::CreateFileEntryL iFullFilePath used, fullTargetPath: %S", &fullTargetPath);
            }
    
        else if ( iDirectoryQueriedFromUser && iDirectoryQueriedFromUser->Des().Length() > 0 )
            {
            // target path = directory + the file name from source path
            TParse parser;
            parser.Set(fullSourcePath, NULL, NULL);

            fullTargetPath = iDirectoryQueriedFromUser->Des();
            fullTargetPath.Append( parser.NameAndExt() );

            LOGSTRING2("Creator: CCreatorFiles::CreateFileEntryL iDirectoryQueriedFromUser used, fullTargetPath: %S", &fullTargetPath);
            }

        else
            {   
            LOGSTRING("Creator: CCreatorFiles::CreateFileEntryL leaving with KErrPathNotFound");
            User::Leave(KErrPathNotFound);
            }
    
        TBool encrypt = parameters->iEncrypt; 
        if ( encrypt ) fullTargetPath.Append( KOma2DcfExtension );
        // check the target path has a unique filename ie we won't overwrite existing files
        // also generates any missing directories
        if ( BaflUtils::FileExists( iFs, fullTargetPath ) )
            {
            GenerateFileNameL( fullTargetPath );
            }
        User::LeaveIfError(CApaApplication::GenerateFileName( iFs, fullTargetPath ) );
        
        if ( encrypt )
            {
            EncryptFileL( fullSourcePath, fullTargetPath, parameters );
            }
        else
            {
            // copy the file (synchronous function)
            err = BaflUtils::CopyFile(iFs, fullSourcePath, fullTargetPath);
            LOGSTRING4("Creator: CCreatorFiles::CreateFileEntryL copy %S to %S, err=%d", &fullSourcePath, &fullTargetPath, err);            
            }
        
        if (err != KErrNone)
            User::Leave(err);  // leave because copying failed

        // Add fullTargetPath to store
        iFilePaths->AppendL( fullTargetPath );
        
		// make sure that the file won't have a read only attribute
		TEntry fileEntry;
		iFs.Entry(fullTargetPath, fileEntry);
		iFs.SetEntry(fullTargetPath, fileEntry.iModified, NULL, KEntryAttReadOnly);

        // clear variables
		parameters->iFullFilePath->Des().Copy ( KNullDesC );
        }

    return err;
    }

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

void CCreatorFiles::EncryptFileL( const TDesC& aInFileName, const TDesC& aOutFileName, CFilesParameters *aParameters )
    {
    LOGSTRING("Creator: CCreatorFiles::EncryptFileL");
    TBuf8<64> mime;
    SetMimeTypeL( aInFileName, mime, aParameters );
    CSupplier* supplier = CSupplier::NewLC();

    CMetaDataArray* metaData = CMetaDataArray::NewLC();
    
    // Tell the agent which MIME type to use for the encrypted data
    metaData->AddL( KOmaImportMimeTypeField, mime );

    if ( aParameters && aParameters->iPermission )
        {
        // Combined Delivery file will be created
        SetPermissionsL( metaData, aOutFileName, aParameters );
        }
    
    supplier->SetOutputDirectoryL( *iDirectoryQueriedFromUser );
    
    // The KOmaImportContentType is a OMA DRM agent specific MIME type which
    // indicates that plain content is to be encrypted
    CImportFile* importFile = supplier->ImportFileL( KOmaImportContentType,
                                                     *metaData,
                                                     aOutFileName );
    CleanupStack::PushL( importFile );
    
    // Peek the source file size:
    TInt fileLen( 0 );
    RFile file;
    User::LeaveIfError( file.Open( iFs, aInFileName, EFileRead ) );
    CleanupClosePushL( file );
    User::LeaveIfError( file.Size( fileLen ) );
    CleanupStack::PopAndDestroy( &file );
    
    // Read the source file to inmemory buffer
    RFileReadStream rs;    
    User::LeaveIfError( rs.Open( iFs,
                                 aInFileName,
                                 EFileStream | EFileRead ) ); 
    CleanupClosePushL( rs );
    HBufC8* fileBuf = HBufC8::NewLC( fileLen );
    TPtr8 p = fileBuf->Des();
    rs.ReadL( p, fileLen );
    
    // Start encryption
    TInt err = importFile->WriteData( p );
    if ( err == KErrCANewFileHandleRequired )
        {
        RFile file;
        User::LeaveIfError( file.Create( iFs, aOutFileName, EFileWrite ) );
        CleanupClosePushL( file );
        importFile->ContinueWithNewOutputFile( file, aOutFileName );
        CleanupStack::PopAndDestroy( &file );
        }
    else
        {
        User::LeaveIfError( err );
        }
    User::LeaveIfError( importFile->WriteDataComplete() );
    CleanupStack::PopAndDestroy( fileBuf );
    CleanupStack::PopAndDestroy( &rs );    
    CleanupStack::PopAndDestroy( importFile );
    CleanupStack::PopAndDestroy( metaData );
    CleanupStack::PopAndDestroy( supplier );
    }

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

void CCreatorFiles::SetPermissionsL( CMetaDataArray* aMetaData, const TDesC& aOutFileName, CFilesParameters *aParameters )
    {
    LOGSTRING("Creator: CCreatorFiles::SetPermissionsL");
    CDRMRights* rights = CDRMRights::NewL();
    CleanupStack::PushL( rights );
    
    HBufC8* cnturi = HBufC8::NewL( KMaxFileName );
    cnturi->Des().Copy( aOutFileName );
    
    CDRMAsset* asset = CDRMAsset::NewLC();
    asset->iUid = cnturi;
    // Set the asset to the rights class, it will duplicate the asset
    rights->SetAssetL( *asset );
    CleanupStack::PopAndDestroy( asset );
    
    rights->SetPermissionL( *aParameters->iPermission );
    
    // Construct externalized presentation of the rights object
    TInt rightsSize = 1024 *100;
    HBufC8* rightBuf = HBufC8::NewLC( rightsSize ); 
    TPtr8 bptr = rightBuf->Des();
    bptr.SetLength( rightsSize );
    RMemWriteStream iWriteStream;
    iWriteStream.Open( (TAny*)(rightBuf->Ptr() ), rightsSize );
    CleanupClosePushL( iWriteStream );
    iWriteStream << *rights;
    iWriteStream.CommitL();
    TPtr8 rp = rightBuf->Des();
    
    // Add rights to metadata
    aMetaData->AddL( KOmaImportRightsField, rp );
    CleanupStack::PopAndDestroy( &iWriteStream );
    CleanupStack::PopAndDestroy( rightBuf );
    CleanupStack::PopAndDestroy( rights );
    }

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

void CCreatorFiles::SetMimeTypeL( const TDesC& aFileName, TDes8& aMime, CFilesParameters *aParameters )
    {
    LOGSTRING("Creator: CCreatorFiles::SetMimeTypeL");
    TUid appUid;
    TDataType dataType;
    User::LeaveIfError( iApaLs.AppForDocument( aFileName, appUid, dataType ) );
    if ( dataType.Des().Length() )
        {
        aMime.Copy( dataType.Des() );    
        }
    else
        {
        // set default mime, because it was not recognized by iApaLs
        aMime.Copy( _L("text/plain") );
        }

    // set DRM permissions according the type of the file
    if ( aParameters->iPermission )
        {
        if ( dataType.Des().FindF( _L("image") ) > KErrNotFound )
            {
            aParameters->iPermission->iAvailableRights = ERightsDisplay | ERightsPrint;
            }
        else if ( dataType.Des().FindF( _L("audio") ) > KErrNotFound ||
                  dataType.Des().FindF( _L("video") ) > KErrNotFound ||
                  dataType.Des().FindF( _L("tone") ) > KErrNotFound || // e.g. application/vnd.nokia.ringing-tone
                  dataType.Des().FindF( _L("realmedia") ) > KErrNotFound )
            {
            // media files
            aParameters->iPermission->iAvailableRights = ERightsPlay;
            }
        else if ( dataType.Des().FindF( _L("archive") ) > KErrNotFound ||
                  dataType.Des().FindF( _L("x-sis") ) > KErrNotFound )
            {
            // application/java-archive
            // x-epoc/x-sisx-app
            aParameters->iPermission->iAvailableRights = ERightsExecute;
            }
        else if ( dataType.Des().FindF( _L("application") ) > KErrNotFound ||
                  dataType.Des().FindF( _L("text") ) > KErrNotFound )
            {
            // application/msexcel
            // application/msword
            // text/plain
            // etc.
            aParameters->iPermission->iAvailableRights = ERightsDisplay | ERightsPrint;
            }
        else
            {
            // other filetype
            aParameters->iPermission->iAvailableRights = ERightsDisplay;
            }
        }
    }

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

TBool CCreatorFiles::AskDRMDataFromUserL()
    {
    LOGSTRING("Creator: CCreatorFiles::AskDRMDataFromUserL");
    // Encryption -dialog
    TInt encIndex( 0 );
    CAknListQueryDialog* encDlg = new (ELeave) CAknListQueryDialog( &encIndex );
    encDlg->PrepareLC( R_ENCRYPTION_DIALOG );
    //Create flat array from which list is built.
    CDesCArrayFlat* items = new(ELeave) CDesCArrayFlat(5);
    CleanupStack::PushL(items);

    // Add entires to list
    items->AppendL( _L("None") );
    items->AppendL( _L("DRM Forward Lock") );
    items->AppendL( _L("DRM Combined Delivery") );

    // Add items into main list
    encDlg->SetOwnershipType( ELbmOwnsItemArray );
    encDlg->SetItemTextArray( items );
    CleanupStack::Pop( items );
    encDlg->ListBox()->SetCurrentItemIndexAndDraw( 0 );
   
    if ( encDlg->RunLD() )
        {
        if ( encIndex > 0 )
            {
            iUserParameters->iEncrypt = ETrue;
            }
        if ( encIndex == 2 )
            {
            iUserParameters->iPermission = CDRMPermission::NewL();
            CDRMPermission* perm = iUserParameters->iPermission; 
            perm->iTopLevel->iActiveConstraints = EConstraintNone;
            perm->iPlay->iActiveConstraints = EConstraintNone;
            perm->iDisplay->iActiveConstraints = EConstraintNone;
            perm->iPrint->iActiveConstraints = EConstraintNone;
            perm->iExecute->iActiveConstraints = EConstraintNone;
            perm->iUniqueID = 0;
            // DRM Combined Delivery
            return AskDRMCDDataFromUserL();
            }
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }

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

TBool CCreatorFiles::AskDRMCDDataFromUserL()
    {
    LOGSTRING("Creator: CCreatorFiles::AskDRMCDDataFromUserL");
    TInt count( 0 );
    if ( iEngine->EntriesQueryDialogL( count, _L("How many counts\r\n(0=unlimited)?"), ETrue ) )
        {
        if ( count > 0 )
            {
            CDRMPermission* perm = iUserParameters->iPermission;
            // apply constraints to all permission types
            // applied type will be selected by setting iAvailableRights
            // when determining the file type
            perm->iDisplay->iActiveConstraints |= EConstraintCounter;
            perm->iDisplay->iCounter = count;
            perm->iDisplay->iOriginalCounter = count;

            perm->iPlay->iActiveConstraints |= EConstraintCounter;
            perm->iPlay->iCounter = count;
            perm->iPlay->iOriginalCounter = count;

            perm->iPrint->iActiveConstraints |= EConstraintCounter;
            perm->iPrint->iCounter = count;
            perm->iPrint->iOriginalCounter = count;
            
            perm->iExecute->iActiveConstraints |= EConstraintCounter;
            perm->iExecute->iCounter = count;
            perm->iExecute->iOriginalCounter = count;
            }
        }
    else
        {
        return EFalse;
        }
    /*
    TInt seconds( 0 );
    if ( iEngine->EntriesQueryDialogL( seconds, _L("How many accumulated seconds until expire (0=unlimited)?"), ETrue ) )
        {
        if ( seconds > 0 )
            {
            CDRMPermission* perm = iUserParameters->iPermission;            
            // apply constraints to all permission types
            // applied type will be selected by setting iAvailableRights
            // when determining the file type            
            perm->iDisplay->iActiveConstraints |= EConstraintAccumulated;
            perm->iDisplay->iEndTime = Time::MaxTTime();
            perm->iDisplay->iStartTime = Time::MinTTime();;
            perm->iDisplay->iAccumulatedTime = seconds;
            
            perm->iPlay->iActiveConstraints |= EConstraintAccumulated;
            perm->iPlay->iEndTime = Time::MaxTTime();
            perm->iPlay->iStartTime = Time::MinTTime();;
            perm->iPlay->iAccumulatedTime = seconds;

            perm->iPrint->iActiveConstraints |= EConstraintAccumulated;
            perm->iPrint->iEndTime = Time::MaxTTime();
            perm->iPrint->iStartTime = Time::MinTTime();;
            perm->iPrint->iAccumulatedTime = seconds;

            perm->iExecute->iActiveConstraints |= EConstraintAccumulated;
            perm->iExecute->iEndTime = Time::MaxTTime();
            perm->iExecute->iStartTime = Time::MinTTime();;
            perm->iExecute->iAccumulatedTime = seconds;
            }
        }
    else
        {
        return EFalse;
        }
    */
    
    TInt minutes( 0 );
    if ( iEngine->EntriesQueryDialogL( minutes, _L("How many minutes until expire (0=unlimited)?"), ETrue ) )
        {
        if ( minutes > 0 )
            {
            CDRMPermission* perm = iUserParameters->iPermission;            
            // apply constraints to all permission types
            // applied type will be selected by setting iAvailableRights
            // when determining the file type            
            perm->iDisplay->iActiveConstraints |= EConstraintInterval;
            perm->iDisplay->iInterval = TTimeIntervalSeconds( 60 * minutes );
            perm->iDisplay->iIntervalStart = Time::NullTTime();
            
            perm->iPlay->iActiveConstraints |= EConstraintInterval;
            perm->iPlay->iInterval = TTimeIntervalSeconds( 60 * minutes );
            perm->iPlay->iIntervalStart = Time::NullTTime();

            perm->iPrint->iActiveConstraints |= EConstraintInterval;
            perm->iPrint->iInterval = TTimeIntervalSeconds( 60 * minutes );
            perm->iPrint->iIntervalStart = Time::NullTTime();

            perm->iExecute->iActiveConstraints |= EConstraintInterval;
            perm->iExecute->iInterval = TTimeIntervalSeconds( 60 * minutes );
            perm->iExecute->iIntervalStart = Time::NullTTime();
            }
        }
    else
        {
        return EFalse;
        }
    
    return ETrue;
    }

//----------------------------------------------------------------------------
void CCreatorFiles::DeleteAllL()
    {
    LOGSTRING("Creator: CCreatorFiles::DeleteAllL");
    User::Leave( KErrNotSupported ); // will not be supported
    }

//----------------------------------------------------------------------------
void CCreatorFiles::DeleteAllCreatedByCreatorL()
    {
    LOGSTRING("Creator: CCreatorFiles::DeleteAllCreatedByCreatorL");
    iFileId = 1;
    CDictionaryFileStore* store = iEngine->FileStoreLC();
    User::LeaveIfNull( store );
        
    if ( store->IsPresentL( KUidDictionaryUidFiles ) )
        {
        RDictionaryReadStream in;
        in.OpenLC( *store, KUidDictionaryUidFiles );
        CFileMan* fileMan = CFileMan::NewL( iFs );
        CleanupStack::PushL( fileMan );
        TFileName fullPath;
        // ignore return value, don't update iFileId here:
        TRAPD( err, in.ReadInt32L() );
        while ( !err )
            {
            TInt len( KErrNotFound );
            TRAP( err, len = in.ReadInt8L() );  // will leave with KErrEof
            if ( !err )
                {
                TRAP( err, in.ReadL( fullPath, len ) );                    
                }
            if ( !err )
                {
                TEntry fileEntry;
                iFs.Entry( fullPath, fileEntry );
                if ( fileEntry.IsDir() )
                    {
                    fileMan->RmDir( fullPath ); // ignore return value
                    }
                else
                    {
                    iFs.Delete( fullPath ); // ignore return value    
                    }                    
                }
            }
        CleanupStack::PopAndDestroy( fileMan );
        CleanupStack::PopAndDestroy( &in );
        
        // files deleted, remove the Creator internal file registry
        store->Remove( KUidDictionaryUidFiles );
        store->CommitL();
        }
    CleanupStack::PopAndDestroy( store );
    }

//----------------------------------------------------------------------------
void CCreatorFiles::StorePathsForDeleteL( CDesCArray& aPaths )
    {
    LOGSTRING("Creator: CCreatorFiles::StorePathsForDeleteL");
    CDictionaryFileStore* store = iEngine->FileStoreLC();
    User::LeaveIfNull( store );
    
    // backup previous filepaths from store
    // otherwise they would be overwritten when calling out.WriteL
    CDesCArray* previousPaths = new (ELeave) CDesCArrayFlat( 4 );
    CleanupStack::PushL( previousPaths );
    
    TFileName fullPath;
    
    if ( store->IsPresentL( KUidDictionaryUidFiles ) )
        {
        RDictionaryReadStream in;
        in.OpenLC( *store, KUidDictionaryUidFiles );
        // ignore return value, don't update iFileId here:
        TRAPD( err, in.ReadInt32L() );
        while ( !err ) 
            {
            TRAP( err,
                TInt len = in.ReadInt8L(); // will leave with KErrEof
                in.ReadL( fullPath, len );
                previousPaths->AppendL( fullPath );
                );
            }
        CleanupStack::PopAndDestroy(); // in
        }
    
    RDictionaryWriteStream out;       
    out.AssignLC( *store, KUidDictionaryUidFiles );
    
    // write latest file id to store
    out.WriteInt32L( iFileId );
    
    // restore previous paths to store
    for ( TInt i = 0; i < previousPaths->Count(); i++ )
        {
        out.WriteInt8L( (*previousPaths)[i].Length() );
        out.WriteL( (*previousPaths)[i] );            
        }

    // write new paths to store
    for ( TInt i = 0; i < aPaths.Count(); i++ )
        {
        out.WriteInt8L( aPaths[i].Length() );
        out.WriteL( aPaths[i] );            
        }
    
    out.CommitL();
    CleanupStack::PopAndDestroy(); // out
    
    store->CommitL();
    CleanupStack::PopAndDestroy( previousPaths );
    CleanupStack::PopAndDestroy( store );
    }

//----------------------------------------------------------------------------
void CCreatorFiles::GenerateFileNameL( TFileName& aRootName )
    {
    LOGSTRING("Creator: CCreatorFiles::GenerateFileNameL");
    if ( iFileId )
        {
        TBuf<16> extension;
        if ( iFileId < 10 )
            {
            extension.Format( _L("(0%d)"), iFileId );     
            }
        else
            {
            extension.Format( _L("(%d)"), iFileId );
            }
        aRootName.Insert( aRootName.Locate( '.' ), extension );
        }
    iFileId++;
    }

// End of file
