/*

* Copyright (c) 2002-2007 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 FILES

#include    <aknnotewrappers.h>

#include    <documenthandlerui.rsg>    // Resource ids

#include    "DocSaver.h"

#include    "DocumentHandlerUI.hrh"

#include    "DocDefaultHandler.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CDocSaver::CDocSaver()

    {

    }

// EPOC default constructor can leave.

void CDocSaver::ConstructL()

    {

    }

// Two-phased constructor.

CDocSaver* CDocSaver::NewL()

    {

    CDocSaver* self = new (ELeave) CDocSaver;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CDocSaver::~CDocSaver()

    {    

    }

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

// CDocSaver::ConfNoteL

// "File saved to SomeApplication" confirmation note.

// 

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

//

void CDocSaver::ConfNoteL( const TDesC& aText, TBool aWait )

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler: CDocSaver::ConfNoteL: Called"));

    #endif 

    CAknConfirmationNote* myNote = new ( ELeave ) CAknConfirmationNote( aWait );

    myNote->ExecuteLD( aText );

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler: CDocSaver::ConfNoteL: Returns"));

    #endif 

    }

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

// CDocWaitDialog

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

CDocWaitDialog::CDocWaitDialog(

    CEikDialog** aSelfPtr,

    const TDesC& aText): 

    CAknWaitDialog(aSelfPtr, EFalse),

    iText(aText), 

    iFinished(EFalse)                               

    {

    }

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

// CDocWaitDialog::ExecuteDlgLD()

// 

// 

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

//

TInt CDocWaitDialog::ExecuteDlgLD()

    {

    PrepareLC(R_DOCHANDLER_WAIT_NOTE);

    SetTextL( iText );

    TInt ret = RunDlgLD(CAknNoteDialog::ENoTone);

    return ret;

    }

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

// CDocWaitDialog::Finish()

// 

// 

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

//

TBool CDocWaitDialog::Finish()

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler: CDocWaitDialog::Finish: Called"));

    #endif 

    TBool state = ETrue;

    if (iState == EProcessOnDisplayOff)

        {

        iProgressDialogTimer->Cancel();

        state = EFalse;

        iFinished = ETrue;

        }

    TRAP_IGNORE( ProcessFinishedL() );

    #ifdef _DEBUG 

    if (state)

        {

        RDebug::Print( _L("DocumentHandler: CDocWaitDialog::Finish: state=ETRUE"));

        }   

    else 

        {

        RDebug::Print( _L("DocumentHandler: CDocWaitDialog::Finish: state=EFALSE"));

        }

    #endif 

    return state;

    }

// CDocAsyncSaver

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CDocAsyncSaver::CDocAsyncSaver():

    CActive(EPriorityStandard), 

    iShowDialog(EFalse), 

    iSilent(EFalse)

    {

    }

// EPOC default constructor can leave.

void CDocAsyncSaver::ConstructL()

    {

    }

// Two-phased constructor.

CDocAsyncSaver* CDocAsyncSaver::NewL()

    {

    CDocAsyncSaver* self = NewLC();

    CleanupStack::Pop();

    return self;

    }

CDocAsyncSaver* CDocAsyncSaver::NewLC()

    {

    CDocAsyncSaver* self = new (ELeave) CDocAsyncSaver();

    CleanupStack::PushL( self );

    self->ConstructL();

    CActiveScheduler::Add(self);

    return self;

    }

// Destructor

CDocAsyncSaver::~CDocAsyncSaver()

    {

    if (iDocWaitDialog)

        {

        delete iDocWaitDialog;

        iDocWaitDialog = NULL;

        }

    Cancel();

    Deque();

    }

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

// CDocAsyncSaver::WriteToFileL()

// 

// 

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

//

void CDocAsyncSaver::WriteToFileL(

    const TDesC8& aContent, 

    RFile& aDestFile,

    const TDesC& aText )

    {

    iDocWaitDialog = 

        new (ELeave) CDocWaitDialog(

            ( REINTERPRET_CAST(

                CEikDialog**,

                &iDocWaitDialog ) ), 

            aText );

    iDocWaitDialog->ExecuteDlgLD();

    aDestFile.Write( aContent, iStatus );

    SetActive();

    iWait.Start();  

    }

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

// CDocAsyncSaver::CopyFileL()

// 

// 

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

//

void CDocAsyncSaver::CopyFileL(

    CFileMan* aFileManager, 

    const TFileName& aSourceFile,

    const TFileName& aDestFile,

    TUint aSwitch,

    const TDesC& aText )

    {

    iDocWaitDialog = 

        new (ELeave) CDocWaitDialog(

            ( REINTERPRET_CAST(

                CEikDialog**,

                &iDocWaitDialog ) ), 

            aText );

    iDocWaitDialog->ExecuteDlgLD();

    TInt error = 

        aFileManager->Copy( 

            aSourceFile, 

            aDestFile, 

            aSwitch, 

            iStatus );

    if ( error != KErrNone )

        {

        iStatus = error;

        iDocWaitDialog->Finish();

        }

    else

        {        

        SetActive();

        iWait.Start();

        }

    }

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

// CDocAsyncSaver::CopyFileL()

// 

// 

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

//

void CDocAsyncSaver::CopyFileL(

    CFileMan* aFileManager, 

    const RFile& aSourceFile,

    const TFileName& aDestFile,

    TUint aSwitch,

    const TDesC& aText )

    {

    iDocWaitDialog = 

        new (ELeave) CDocWaitDialog(

            ( REINTERPRET_CAST(

                CEikDialog**,

                &iDocWaitDialog ) ), 

            aText );

    iDocWaitDialog->ExecuteDlgLD();

    TInt error = 

        aFileManager->Copy(

            aSourceFile, 

            aDestFile, 

            aSwitch, 

            iStatus );

    if ( error != KErrNone )

        {

        iStatus = error;

        iDocWaitDialog->Finish();

        }

    else

        {        

        SetActive();

        iWait.Start();

        }

    }

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

// CDocAsyncSaver::MoveFileL()

// 

// 

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

//

void CDocAsyncSaver::MoveFileL(

    CFileMan* aFileManager, 

    const TFileName& aSourceFile,

    const TFileName& aDestFile,

    TUint aSwitch,

    const TDesC& aText,

    const TBool aSilent )

    {

    iSilent = aSilent;

    if (!iSilent)

        {

        iDocWaitDialog = 

            new (ELeave) CDocWaitDialog(

                ( REINTERPRET_CAST(

                    CEikDialog**,

                    &iDocWaitDialog ) ), 

                aText );

        iDocWaitDialog->ExecuteDlgLD();

        }

    TInt error = 

        aFileManager->Move(

            aSourceFile,

            aDestFile, 

            aSwitch, 

            iStatus );

    if ( error != KErrNone )

        {

        iStatus = error;

        if (!iSilent)

            {

            iDocWaitDialog->Finish();

            }

        }

    else

        {        

        SetActive();

        iWait.Start();

        }

    }

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

// CDocAsyncSaver::Status()

// 

// 

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

//

TRequestStatus CDocAsyncSaver::Status()

    {

    return iStatus;

    }

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

// CDocAsyncSaver::ShowDialog()

// 

// 

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

//

TBool CDocAsyncSaver::ShowDialog()

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler: CDocAsyncSaver::ShowDialog: Called"));

    #endif 

    iShowDialog = EFalse;

    if (iSilent)

        {

        iShowDialog = EFalse;

        }

    else if (!iDocWaitDialog->Finish())

        {

        iShowDialog = ETrue;

        #ifdef _DEBUG        

        RDebug::Print( _L("DocumentHandler: CDocAsyncSaver::ShowDialog: Returns ETRUE"));

        #endif 

        }

    return iShowDialog;

    }

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

// CDocAsyncSaver::RunL()

// 

// 

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

//

void CDocAsyncSaver::RunL()

    {   

    iWait.AsyncStop(); 

    }

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

// CDocAsyncSaver::DoCancel()

// 

// 

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

//

void CDocAsyncSaver::DoCancel()

    {

    }

//  End of File