/*

* Copyright (c) 2002 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:  Implementation of Notepad Library APIs.

*

*/

// INCLUDE FILES

#include <aknPopup.h>

#include <aknlists.h>

#include <NpdLib.rsg>

#include <bautils.h>

#include <txtetext.h>

#include <data_caging_path_literals.hrh>

#include <StringLoader.h>

#include "NpdApi.h"

#include "NpdModel_platsec.h"

#include "NpdListDialog.h"

#include "NpdEditorDialog.h"

#include "NpdExternalTextEditorDialog.h"

#include "NpdViewerDialog.h"

#include "NpdPopupList.h"

// CONSTANTS

_LIT(KNpdResourceDrive, "z:");

_LIT(KNpdLibResourceFilename, "npdlib.rsc");

//static const TInt KFetchMemoPromptMaxlength = 40;

//static const TInt KEmptyMessageMaxlength = 80; 

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

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

// CNotepadApi::NewL

// two-phased constructor

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

//

EXPORT_C CNotepadApi* CNotepadApi::NewL()

    {

    CNotepadApi* self = NewLC();

    CleanupStack::Pop(); // self

    return self;

    }

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

// CNotepadApi::NewLC

// two-phased constructor

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

//

EXPORT_C CNotepadApi* CNotepadApi::NewLC()

    {

    CNotepadApi* self = new(ELeave) CNotepadApi;

    CleanupStack::PushL(self);

    TFileName fileName(KNpdResourceDrive);

    fileName.Append(KDC_RESOURCE_FILES_DIR);

    fileName.Append(KNpdLibResourceFilename);

    self->iResourceLoader.OpenL(fileName);

    return self; // self is kept on CleanupStack

    }

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

// CNotepadApi::~CNotepadApi

// Destructor.

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

//

EXPORT_C CNotepadApi::~CNotepadApi()

    {

    delete iModel;

    iResourceLoader.Close();

    delete iDialog;

    }

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

// CNotepadApi::FetchMemoL

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

//

EXPORT_C HBufC* CNotepadApi::FetchMemoL(const TDesC* aTitle)

    {

    CNotepadApi* api = CNotepadApi::NewLC(); // with resource adding

    HBufC* fetchedMemo = api->DoPopupListL(

        aTitle, 

        R_NOTEPAD_FETCH_MEMO_MODEL,

        R_NOTEPAD_FETCH_MEMO_PRMPT);

    CleanupStack::PopAndDestroy(); // api (release the resource)

    return fetchedMemo;

    }

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

// CNotepadApi::FetchTemplateL

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

//

EXPORT_C HBufC* CNotepadApi::FetchTemplateL(const TDesC* aTitle)

    {

    CNotepadApi* api = CNotepadApi::NewLC(); // with resource adding

    HBufC* fetchedTemplate = api->DoPopupListL(

        aTitle, 

        R_NOTEPAD_FETCH_TEMPLATE_MODEL,

        R_NOTEPAD_FETCH_TEMPLATE_PRMPT,

        R_NOTEPAD_MCE_EMPTY_LIST );

    CleanupStack::PopAndDestroy(); // api (release the resource)

    return fetchedTemplate;

    }   

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

// CNotepadApi::ExecTemplatesL

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

//

EXPORT_C TInt CNotepadApi::ExecTemplatesL()

    {

    CNotepadApi* api = CNotepadApi::NewLC();

    api->CreateListDialogL(R_NOTEPAD_TEMPLATE_LIST_DIALOG);

    CNotepadListDialog* dialog = 

        STATIC_CAST(CNotepadListDialog*, api->iDialog);

    TInt returnValueOfDialogExecuteLD(dialog->ExecuteLD()); // wait dialog

    CleanupStack::PopAndDestroy(); // api

    return returnValueOfDialogExecuteLD;

    }

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

// CNotepadApi::ExecFileViewerL

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

//

EXPORT_C TInt CNotepadApi::ExecFileViewerL(

    const TDesC& aFileName, 

    const TDesC* aTitle,

    const TBool aDoWait,

    TBool aGuessEncoding,

    TUint aEncoding)

    {

    CNotepadApi* api = CNotepadApi::NewLC();

   	RFs fileSession;

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

   	CleanupClosePushL(fileSession);

    RFile file;

    User::LeaveIfError(file.Open(fileSession, aFileName, EFileRead));

    CleanupClosePushL(file);

    api->CreateViewerDialogL(

        file, aTitle, aDoWait, aGuessEncoding, aEncoding);

    TInt returnValueOfDialogExecuteLD(

        STATIC_CAST(CNotepadViewerDialog*, api->iDialog)->ExecuteLD() );

    CleanupStack::PopAndDestroy(3); // api, file, fileSession

    return returnValueOfDialogExecuteLD;

    }

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

// CNotepadApi::ExecFileViewerL file handle

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

//

EXPORT_C TInt CNotepadApi::ExecFileViewerL(

    RFile& aFile, 

    const TDesC* aTitle,

    const TBool aDoWait,

    TBool aGuessEncoding,

    TUint aEncoding)

    {

    CNotepadApi* api = CNotepadApi::NewLC();

    api->CreateViewerDialogL(

        aFile, aTitle, aDoWait, aGuessEncoding, aEncoding);

    TInt returnValueOfDialogExecuteLD(

        STATIC_CAST(CNotepadViewerDialog*, api->iDialog)->ExecuteLD() );

    CleanupStack::PopAndDestroy(); // api

    return returnValueOfDialogExecuteLD;

    }

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

// CNotepadApi::AddContentL

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

//

EXPORT_C void CNotepadApi::AddContentL(const TDesC& aText)

    {

    CNotepadApi::NewLC(); // loading our resource

    CNotepadCoreModel* model = new(ELeave) CNotepadCoreModel();

    CleanupStack::PushL(model);

    model->ConstructL( R_NOTEPAD_DATAFILE_NAME );

    TInt key(KNotepadPseudoKeyIdForNewNote);

    model->InsertL(aText, key);

    CleanupStack::PopAndDestroy(2); // model, api (release the resource)

    }

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

// CNotepadApi::ExistsMemoL

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

//

EXPORT_C TBool CNotepadApi::ExistsMemoL(const TInt aKey)

    {

    CNotepadApi* api = CNotepadApi::NewLC();

    TBool isFound( api->ProbeMemoL(aKey) );

    CleanupStack::PopAndDestroy(); // api

    return isFound;

    }

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

// CNotepadApi::NumberOfTemplates

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

//

EXPORT_C TInt CNotepadApi::NumberOfTemplates()

    {

    TInt numberOfTemplates(0);

    TRAPD(err, 

        CNotepadApi::NewLC(); // loading our resource

        CNotepadCoreModel* model = new(ELeave) CNotepadCoreModel();

        CleanupStack::PushL(model);

        model->ConstructL( R_NOTEPAD_TEMPLATE_DATAFILE_NAME );

        numberOfTemplates = model->CountL();

        CleanupStack::PopAndDestroy(2); // model, api (release the resource)

        );

    return (err < 0) ? err : numberOfTemplates;

    }

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

// CNotepadApi::SaveFileAsMemoL

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

//

EXPORT_C void CNotepadApi::SaveFileAsMemoL(const TDesC& aFileName)

    {

    CPlainText* text = CPlainText::NewL(CEditableText::EFlatStorage);

    CleanupStack::PushL(text);

    NotepadUtil::LoadFileL(*CCoeEnv::Static(), aFileName, 

        ETrue, // aGuessEncoding

        0, // aEncoding

        *text );

    AddContentL(text->Read(0, text->DocumentLength()));

    CleanupStack::PopAndDestroy(); // text

    }

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

// CNotepadApi::SaveFileAsMemoL file handle

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

//

EXPORT_C void CNotepadApi::SaveFileAsMemoL(RFile& aFile)

    {

    CPlainText* text = CPlainText::NewL(CEditableText::EFlatStorage);

    CleanupStack::PushL(text);

    NotepadUtil::LoadFileL(*CCoeEnv::Static(), aFile, 

        ETrue, // aGuessEncoding

        0, // aEncoding

        *text );

    AddContentL(text->Read(0, text->DocumentLength()));

    CleanupStack::PopAndDestroy(); // text

    }

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

// CNotepadApi::SaveFileAsMemoL

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

//

EXPORT_C void CNotepadApi::SaveFileAsMemoL(const TDesC& aFileName, const TUint aEncoding)

    {

    CPlainText* text = CPlainText::NewL(CEditableText::EFlatStorage);

    CleanupStack::PushL(text);

    NotepadUtil::LoadFileL(*CCoeEnv::Static(), aFileName, 

        EFalse, // aGuessEncoding

        aEncoding, // aEncoding

        *text );

    AddContentL(text->Read(0, text->DocumentLength()));

    CleanupStack::PopAndDestroy(); // text

    }

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

// CNotepadApi::SaveFileAsMemoL file handle

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

//

EXPORT_C void CNotepadApi::SaveFileAsMemoL(RFile& aFile, const TUint aEncoding)

    {

    CPlainText* text = CPlainText::NewL(CEditableText::EFlatStorage);

    CleanupStack::PushL(text);

    NotepadUtil::LoadFileL(*CCoeEnv::Static(), aFile, 

        EFalse, // aGuessEncoding

        aEncoding, // aEncoding

        *text );

    AddContentL(text->Read(0, text->DocumentLength()));

    CleanupStack::PopAndDestroy(); // text

    }

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

// CNotepadApi::Dialog

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

//

EXPORT_C CEikDialog* CNotepadApi::Dialog()

    {

    return iDialog;

    }

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

// CNotepadApi::Model

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

//

EXPORT_C CNotepadModel* CNotepadApi::Model()

    {

    return iModel;

    }

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

// CNotepadApi::CreateListDialogL

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

//

EXPORT_C void CNotepadApi::CreateListDialogL(TInt aResId)

    {

    delete iDialog;

    iDialog = NULL;

    iDialog = CNotepadListDialog::NewL(aResId,

        REINTERPRET_CAST( CEikDialog**, &iDialog ) );

    }

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

// CNotepadApi::CreateViewerDialogL

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

//

EXPORT_C void CNotepadApi::CreateViewerDialogL(

    const TDesC& aFileName, 

    const TDesC* aTitle,

    const TBool aDoWait,

    TBool aGuessEncoding,

    TUint aEncoding)

    {

    CreateViewerDialogL(aDoWait);

    STATIC_CAST(CNotepadViewerDialog*, iDialog)->SetFileL(

        aFileName, aTitle, aGuessEncoding, aEncoding );

    }

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

// CNotepadApi::CreateViewerDialogL file handle

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

//

EXPORT_C void CNotepadApi::CreateViewerDialogL(

    RFile& aFile, 

    const TDesC* aTitle,

    const TBool aDoWait,

    TBool aGuessEncoding,

    TUint aEncoding)

    {

    CreateViewerDialogL(aDoWait);

    STATIC_CAST(CNotepadViewerDialog*, iDialog)->SetFileL(

        aFile, aTitle, aGuessEncoding, aEncoding );

    }

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

// CNotepadApi::CreateViewerDialogL

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

//

EXPORT_C void CNotepadApi::CreateViewerDialogL(const TBool aDoWait)

    {

    delete iDialog;

    iDialog = NULL;

    iDialog = CNotepadViewerDialog::NewL(

        ( aDoWait ? R_NOTEPAD_VIEWER_WAITING : R_NOTEPAD_VIEWER ),

        REINTERPRET_CAST( CEikDialog**, &iDialog ) );

    }

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

// CNotepadApi::CreateViewerDialogL

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

//

EXPORT_C void CNotepadApi::CreateTextViewerDialogL(

    HBufC **aContentPointer,

    TInt& aReturnStatus,

    TBool aReadOnly,

    const TDesC& aText, 

    const TDesC& aTitle, 

    const TDesC& aDeleteConfirmationText

    )

    {

    delete iDialog;

    iDialog = NULL;

    iDialog = CNotepadViewerDialog::NewL(

        ( R_NOTEPAD_VIEWER_WAITING ),

        REINTERPRET_CAST( CEikDialog**, &iDialog ) );

    STATIC_CAST(CNotepadViewerDialog*, iDialog)->InitDescriptorViewerL(

        aContentPointer, aReturnStatus, aReadOnly, aText, aTitle, aDeleteConfirmationText );

    }

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

// CNotepadApi::CreateTextEditorDialogL

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

//

EXPORT_C void CNotepadApi::CreateTextEditorDialogL(

    HBufC **aContentPointer,

    TInt& aReturnStatus,

    const TDesC& aText, 

    const TDesC& aTitle, 

    const TDesC& aDeleteConfirmationText

    )

    {

    delete iDialog;

    iDialog = NULL;

    iDialog = CNotepadExternalTextDialog::NewL(

        aContentPointer, aReturnStatus, aText, aTitle, aDeleteConfirmationText, 

        REINTERPRET_CAST( CEikDialog**, &iDialog ) 

        );

    }

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

// CNotepadApi::CreateModelL

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

//

EXPORT_C void CNotepadApi::CreateModelL(TInt aResId)

    {

    delete iModel;

    iModel = NULL;

    iModel = CNotepadModel::NewL(iEnv->FsSession(), aResId);

    }

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

// CNotepadApi::ProbeMemoL

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

//

EXPORT_C TBool CNotepadApi::ProbeMemoL(const TInt aKey)

    {

    if ( aKey < 0 )

        {

        return EFalse;

        }

    if ( !iModel )

        {

        iModel = CNotepadModel::NewL(

            iEnv->FsSession(), R_NOTEPAD_SAVE_MEMO );

        }

    return 0 == iModel->SeekKey(aKey);

    }

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

// CNotepadApi::CNotepadApi

// private c++ Constructor

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

//

CNotepadApi::CNotepadApi()

    : iEnv(CCoeEnv::Static()), iResourceLoader(*CCoeEnv::Static())

    {

    }

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

// CNotepadApi::DoPopupListL

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

//

HBufC* CNotepadApi::DoPopupListL(

    const TDesC* aTitle, 

    TInt aModelResId,

    TInt aPromptResId, 

    TInt aEmptyTextResId )

    {

    CreateModelL(aModelResId);

    TBool finished(ETrue);

    TBool isNotCancelled;

    TInt itemIndex(0);

    do

        {

        CAknSinglePopupMenuStyleListBox* listbox 

            = new(ELeave) CAknSinglePopupMenuStyleListBox;

        CleanupStack::PushL(listbox);

        CNotepadPopupList* popupList = CNotepadPopupList::NewL(

            listbox, 

            R_AVKON_SOFTKEYS_SELECT_CANCEL, 

            AknPopupLayouts::EMenuWindow,

            *iModel);

        CleanupStack::PushL(popupList);

        iModel->SetNotepadModelObserver(popupList);

        listbox->ConstructL(popupList, 0);

        (listbox->Model())->SetItemTextArray(iModel);

        (listbox->Model())->SetOwnershipType(ELbmDoesNotOwnItemArray);

        listbox->CreateScrollBarFrameL(ETrue);

        listbox->ScrollBarFrame()->SetScrollBarVisibilityL(

            CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

        if ( aTitle )

            {

            popupList->SetTitleL(*aTitle);

            }

        else

            {

            HBufC* buf = StringLoader::LoadLC(aPromptResId);

            popupList->SetTitleL(*buf);

            CleanupStack::PopAndDestroy(buf);

            }

        if ( aEmptyTextResId > 0 )

            {

            HBufC* buf = StringLoader::LoadLC(aEmptyTextResId);

            listbox->View()->SetListEmptyTextL(*buf);

            CleanupStack::PopAndDestroy(buf);

            }

        isNotCancelled = popupList->EnhancedExecuteLD( finished );

        CleanupStack::Pop( popupList );

        itemIndex = listbox->CurrentItemIndex();

        CleanupStack::PopAndDestroy( listbox );

        }

    while(!finished);

    HBufC* fetchedContent = NULL;

    if ( isNotCancelled )

        {

        if (iModel->MdcaCount())

            {

            fetchedContent = 

                iModel->ContentL( itemIndex );

            }

        }

    return fetchedContent;

    }

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

// CNotepadApi::ExecReadonlyTextViewerL

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

//

EXPORT_C TInt CNotepadApi::ExecReadOnlyTextViewerL(

    const TDesC& aText, 

    const TDesC& aTitle, 

    const TDesC& aDeleteConfirmationText

    )

    {