/*

* 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 List of Memos/Templates mode.

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <eikmenup.h>

#include <eikclbd.h>

#include <eikapp.h>

#include <aknlists.h>

#include <bacntf.h>

#include <sendui.h>

#include <Sendnorm.rsg>

#include <txtglobl.h>

#include <AknIconArray.h>

#include <StringLoader.h>

#include <AknDlgShut.h>

#include <AknProgressDialog.h>

#include <eikprogi.h>

#include <eikimage.h>

#include <AvkonIcons.hrh>

#include <avkon.mbg>

#include <aknlayoutscalable_avkon.cdl.h>

#include <gulicon.h>

#include <aknconsts.h>

#include <hlplch.h>

#include <featmgr.h>

#include <StringLoader.h>

#include <NpdLib.rsg>

#include <AiwCommon.hrh>

#include <AiwGenericParam.h>

#include <CMessageData.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <vwsdefpartner.h>

#endif

#include "NpdLib.hrh"

#include "NpdListDialog.h"

#include "NpdEditorDialog.h"

#include "NpdModel_platsec.h"

#include "NpdLib.h"

#include "NpdListBox.h"

#include <csxhelp/nmake.hlp.hrh>

#include <csxhelp/mce.hlp.hrh>

// Next is for KNotepadPseudoKeyIdForNewNote

//

#include "NpdApi.h"

#include "NpdLibPanic.h"

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

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

// CNotepadListDialog::NewL

// Constructor.

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

//

EXPORT_C CNotepadListDialog* CNotepadListDialog::NewL(

    TInt aResId,             // Resource Id of type NOTEPAD_LIST_DIALOG

    CEikDialog** aSelfPtr )

    {

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

    self->iSelfPtr = aSelfPtr;

    CleanupStack::PushL(self);

    TResourceReader rr;

    self->iCoeEnv->CreateResourceReaderLC(rr, aResId); // Push rr

    self->ConstructL( rr );

    CleanupStack::PopAndDestroy(); // rr

    CleanupStack::Pop(); // self

    return self;

    }

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

// CNotepadListDialog::~CNotepadListDialog

// Destructor.

//

// In destructor of CNotepadEditorDialog, 

// CNotepadListDialog::iEditorDialog (pointer to the object) will be

// NULLed using CNotepadListDialog::EditorDeleted().

// So it is guaranteed that iEditorDialog is NULL iff the object is alive.

//

// *1* It seems that 'delete iProgressDialog must precceed delete iModel

// to avoid a crash when PowerOff while deleting or adding to pinboard.

// Because the focus is changed in deleting iProgressDialog 

// (caused by RemoveFromStack).

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

//

EXPORT_C CNotepadListDialog::~CNotepadListDialog()

    {

    delete iIdle;

    delete iProgressDialog; // *1*

    delete iEditorDialog;

    if ( iFlags & ENotepadObserveView )

        {

        iEikonEnv->EikAppUi()->RemoveViewObserver(this);

        }

    delete iModel;

    delete iSendUi;

    iSavedSelectedKeys.Close();

    iSavedKeysAboveCurrent.Close();

    delete iEnvironmentChangeNotifier;

    if ( iServiceHandler )

    	{

		delete iServiceHandler;

		iServiceHandler = NULL;

    	}

    }

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

// CNotepadListDialog::EditByKeyL

// Called from CNotepadAppUi.

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

//

EXPORT_C void CNotepadListDialog::EditByKeyL(const TInt aKey)

    {

    __ASSERT_DEBUG( IsNotepad(), 

        Panic(ENotepadLibraryPanicOnlySupportedInNotepad) );

    if ( iBaseAppUi == iEikonEnv->EikAppUi() // SendUi is not running

        /*&& !iBaseAppUi->IsDisplayingDialog()*/  // Dialog is not running

       	&& !iModel->IsDeleting() )

        {

        DoEditByKeyL(aKey);

        }

    }

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

// CNotepadListDialog::SaveL

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

//

EXPORT_C void CNotepadListDialog::SaveL()

    {

    if ( iEditorDialog )

        {

        iEditorDialog->SaveOnExitL(EFalse);

        }

    }

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

// CNotepadListDialog::HandleEditorExitL

// This function is called from CNotepadEditorDialog.

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

//

void CNotepadListDialog::HandleEditorExitL(

    TInt aStatOfSave, 

    const TInt aKey,

    const TBool aEagerSync )

    {

    	iEditorFlag= EFalse;

    if ( aKey != KNotepadPseudoKeyIdForNewNote )

        {

        iSavedKey = aKey;

        }

    if ( aStatOfSave == CNotepadModel::ENotepadModelRowAdded )

        {

        iFlags |= ENotepadItemAdded;

        }

    else 

        {

        iFlags &= ~ENotepadItemAdded;

        }

        {

        }

    if (aStatOfSave == CNotepadModel::ENotepadModelRowDeleted)

    	{

    	iListBox->HandleItemRemovalL();

    	DrawNow();

    	}

        // MSK 

        MiddleSoftKeyL();

    }

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

// CNotepadListDialog::EditorDeleted

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

//

void CNotepadListDialog::EditorDeleted()

    {

    iEditorDialog = NULL;

    iModel->SetNotepadModelObserver(this); 

    }

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

// CNotepadListDialog::ConstructL

// private second-phase constructor

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

//

void CNotepadListDialog::ConstructL( TResourceReader& aReader )

    {

    iNeedSave = EFalse;

    iSavedKey = KNotepadInvalidKeyId;

    iSendingEmail = EFalse;

    CNotepadDialogBase::ConstructL( aReader ); // menubar, dialog

    TInt modelResId(aReader.ReadInt32());        // LLINK model;

    iModel = CNotepadModel::NewL(

        iCoeEnv->FsSession(), modelResId );

    iEditorResId = aReader.ReadInt32();         // LLINK editor_dialog

    TPtrC ptr = aReader.ReadTPtrC();               // LTEXT title

    if ( ptr.Length() )

        {

        SetTitleL(&ptr);

        }

    iSendUi = CSendUi::NewL();

    if ( IsNotepad() )

        {

        TCallBack callback(HandleEnvironmentChangedL, this);

        iEnvironmentChangeNotifier = CEnvironmentChangeNotifier::NewL(

            EActivePriorityLogonA, callback);

        iEnvironmentChangeNotifier->Start();

        }

    iEikonEnv->EikAppUi()->AddViewObserverL(this);

    iFlags |= ENotepadObserveView;

    iClockValueChange = EFalse;

    iBaseAppUi = iAvkonAppUi;

    iModel->SetNotepadModelObserver(this);

    iBaseLevelOfActiveScheduler = LevelOfActiveScheduler() + 1;

    // Create instance of CAiwServiceHandler

	iServiceHandler = CAiwServiceHandler::NewL();

	// Attach menu services

	iServiceHandler->AttachMenuL( R_NOTEPAD_LIST_MENU_SECOND, R_NOTEPAD_APP_INTEREST );

    if ( FeatureManager::FeatureSupported( KFeatureIdFfEnablePrintingFramework ) )

        {

        iServiceHandler->AttachMenuL( R_NOTEPAD_LIST_MENU_FIRST, R_PS_AIW_INTEREST );

        }

    }

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

// CNotepadListDialog::StartEditorL

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

//

void CNotepadListDialog::StartEditorL()

    {

    iEditorFlag=ETrue;

    HideMenu();

    __ASSERT_DEBUG(iEditorResId, User::Invariant());

    iEditorDialog = CNotepadEditorDialog::NewL(iEditorResId, iModel, this,

            iSendUi);

    iEditorDialog->ExecuteLD();

    iListBox->ClearSelection();

    ClearSavedCurrentAndSelections();

    SaveCurrentAndSelectionsL();

    }

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

// CNotepadListDialog::OnCmdAddL

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

//

	void CNotepadListDialog::OnCmdAddL()

    {

    StartEditorL();

    iEditorDialog->SwitchTextL(KNotepadPseudoKeyIdForNewNote);

    }

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

// CNotepadListDialog::OnCmdOpenL

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

//

void CNotepadListDialog::OnCmdOpenL(TInt aIndex)

    {

    if ( iModel->MdcaCount() == 0 )

        {

    	  return;

        }

    StartEditorL();

    iEditorDialog->SwitchTextL(iModel->Key(aIndex));

    }

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

// CNotepadListDialog::ConfirmDeleteL

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

//

TBool CNotepadListDialog::ConfirmDeleteL(TInt aMemos)

    {

    TBool isConfirmed(ETrue);

    if ( aMemos >= 2 )

        {

        HBufC* prompt = StringLoader::LoadLC(

            QueryDeleteMultipleResId(), aMemos, iCoeEnv);

        isConfirmed = ExecuteConfirmationQueryL(prompt);

        CleanupStack::PopAndDestroy(); // prompt

        }

    else 

        {

        isConfirmed = ExecuteConfirmationQueryL(QueryDeleteSingleResId());

        }

    return isConfirmed;

    }

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

// CNotepadListDialog::CreateKeyArrayOfSelectionsL

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

//

void CNotepadListDialog::CreateKeyArrayOfSelectionsL()

    {

    const CListBoxView::CSelectionIndexArray* selections = 

        iListBox->SelectionIndexes();

    const TInt markCount( selections->Count() );

    iSavedSelectedKeys.Reset();

    for (TInt i(0); i < markCount; i++)

        {

        User::LeaveIfError(

            iSavedSelectedKeys.Append(iModel->Key((*selections)[i])) );

        }

    }

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

// CNotepadListDialog::OnCmdDeleteL

//

//                  IsNotepad    IsTemplates

// markCount >= 2     **A**(1)      **A**(2)

// markCount == 1     **C**         **A**(3)

// markCOunt == 0     **C**         **B**(3)

//

// According to UI specs (Notepad and Message Centre),

// in the case of the block **C**, no progress note is needed but 

// we must show a progress note if markCount>=2 or IsTempates

// (block **A** or **B**).

//

// And there are 3 different labels defined;

//   (1) "Deleting" 

//   (2) "Deleting template %0N of %1N"

//   (3) "Deleting template"

// Block **B** also create the progress note, but it is different from **A**

// in the point that it must create a KeyArray by itself.

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

//

void CNotepadListDialog::OnCmdDeleteL()

    {

    if ( iModel->MdcaCount() == 0 ) // this is posible when clear key

        {

        return;

        }

    ClearSavedCurrentAndSelections();

    SaveCurrentAndSelectionsL();

    TInt markCount( iListBox->SelectionIndexes()->Count() );

    TInt deleteCount( markCount > 0 ? markCount : 1 ); 

    if ( ConfirmDeleteL( deleteCount ) )

        {

        //be sure that the marks or the items might have gone while confirming

        //

        if ( markCount > 0 ? 

            ( deleteCount = iListBox->SelectionIndexes()->Count() ) > 0 :

            iModel->MdcaCount() > 0 )

            {

            // assert "deleteCount >= 1"

            if ( deleteCount >= 2 || ( IsTemplates() && markCount ) )

                { //**A**

                // Both Notepad and MCE specs require ProgressDialog

                // in deleting multiple items.

                // Only MCE shows ProgressDialog even in deleting one item.

                //

                CreateProgressDialogL(deleteCount,

                    deleteCount == 1 ? // when just one template is marked

                    R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATE :

                    ( IsTemplates() ? // when two or more templates are marked

                        R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATES :

                        0 )); // default label for Notepad

                iModel->DeleteByKeysL(iSavedSelectedKeys); // start CIdle

                }

            else if ( IsTemplates() ) // MCE, delete a focused item

                { //**B**

                // MCE spec requires ProgressDialog even in deleting one item

                //

                RArray<TInt> keys(1);

                CleanupClosePushL(keys);

                User::LeaveIfError(keys.Append(iSavedKey));

                CreateProgressDialogL( deleteCount, 

                    R_NOTEPAD_MCE_WAIT_NOTE_DELETE_TEMPLATE );

                iModel->DeleteByKeysL(keys); // start CIdle

                CleanupStack::PopAndDestroy();// keys

                }

            else 

                { //**C**

                // Notepad spec doesn't require ProgressDialog 

                // in deleting a single item

                //

                iModel->DeleteL( markCount == 0 ? iSavedKey : 

                    iSavedSelectedKeys[0] );

                }

            }

        }

        iModel->SyncL(EFalse); // sync might be delayed while confirming

    }

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

// CNotepadListDialog::OnCmdSendL

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

//

void CNotepadListDialog::OnCmdSendL(TInt aCommandId)

    {

    if ( iModel->MdcaCount() == 0 )

        {

    	  return;

        }    

    if ( iListBox->SelectionIndexes()->Count() > 0 )

        {

        ClearSavedCurrentAndSelections();

        SaveCurrentAndSelectionsL();

        TUid serviceUid = SendByKeysL(*iSendUi, aCommandId, *iModel, iSavedSelectedKeys);

        iModel->SyncL(EFalse); // sync might be delayed while SendAsL.

        TUid EmailUid = {0x10001028};

        if ( serviceUid == EmailUid )

        	{

        	iSendingEmail = ETrue;

        	}

        }

    else

        {

        HBufC* text = iModel->ContentL(iListBox->CurrentItemIndex());

        CleanupStack::PushL(text);

        iSavedKey = iModel->Key(iListBox->CurrentItemIndex());

        SendAsL( *iSendUi, aCommandId, EFalse, text );

        CleanupStack::PopAndDestroy(); // text

        iModel->SyncL(EFalse); // sync might be delayed while SendAsL.

        }

    }

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

// CNotepadListDialog::CreateProgressDialogL

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

//

void CNotepadListDialog::CreateProgressDialogL(

    const TInt aCount,

    const TInt aLabelResId )

    {

    __ASSERT_DEBUG( aCount >= 1, 

        Panic(ENotepadLibraryPanicInvalidFinalValueOfProgressNote) );

    delete iProgressDialog;

    iProgressDialog = NULL;

    iProgressDialog = new(ELeave) CNotepadProgressDialog(

        REINTERPRET_CAST( CEikDialog**, &iProgressDialog ), EFalse);

    iProgressDialog->SetMopParent(this);

    iProgressDialog->PrepareLC(R_NOTEPAD_DELETE_PROGRESS_NOTE);    

    iProgressDialog->PrepareL(aCount, aLabelResId);

    iProgressDialog->ProgressInfo()->SetFinalValue( 

        aLabelResId == 0 ? 

            aCount * 2 // In Notepad deleting a item is done by 2 steps

            : aCount );

     iProgressDialog->SetCallback(this);   

    iProgressDialog->RunLD();

    }

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

// CNotepadListDialog::DoEditByKeyL

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

//

void CNotepadListDialog::DoEditByKeyL(const TInt aKey)

    {

    iModel->SyncL(EFalse);

    if ( iEditorDialog )

        {

        iEditorDialog->EditByKeyL(aKey, *iBaseAppUi);

        }

	else if ( aKey != KNotepadPseudoKeyIdForNewNote 

				&& iModel->SeekKey(aKey) == 0 )

		{

		// Open the memo with the given key (aKey)

		OnCmdOpenL( iModel->IndexOf(aKey) );

		}

    else

        {

        // Launch empty editor (pinned number -1 means "Write a Note")

       	OnCmdAddL();

        }

    }

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

// CNotepadListDialog::HandleEnvironmentChangedL

// private static function.

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

//

TInt CNotepadListDialog::HandleEnvironmentChangedL( TAny* aThisPtr )

    {

    return STATIC_CAST(CNotepadListDialog*, 

        aThisPtr)->DoHandleEnvironmentChangedL();

    }

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

// CNotepadListDialog::DoHandleEnvironmentChangedL

//

// Just after first time iCrossoverNotifier->Start() is called,

// HandleDateChanged seems to be called.

// To avoid calling ForceListSync at the first callback,

// we use a flag ENotepadEverEnvironmentChanged.

// When this function is called at first, the flag is off and so

// ForceListSync is blocked by condition 

//   ( iFlags & ENotepadEverEnvironmentChanged )

// and then the flag is set to be on.

//

// Even if this function may LEAVE, the notification will not be 

// cancelled (ie. the callback is made on further EnvironmentChange. 

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

//

TInt CNotepadListDialog::DoHandleEnvironmentChangedL()

    {

    iClockValueChange = ((iEnvironmentChangeNotifier->Change() 

            & ( EChangesMidnightCrossover | EChangesLocale | EChangesSystemTime )) != 0);