/*

* 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/Template Editor mode.

*

*/

// INCLUDE FILES

#include <aknappui.h>

#include <avkon.hrh>

#include <eikmenub.h>

#include <txtglobl.h>

#include <AknForm.h>

#include <aknnotedialog.h>

#include <aknkeys.h>

#include <eikapp.h>

#include <eikedwob.h>

#include <aknnotewrappers.h>

#include <AknUtils.h>

#include <barsread.h>

#include <sendui.h>

#include <Sendnorm.rsg>

#include <hlplch.h>

#include <featmgr.h>

#include <NpdLib.rsg>

#include "NpdLib.hrh"

#include <txtrich.h>

#include <StringLoader.h>

#include <AvkonInternalCRKeys.h>

#include <e32keys.h>

#include <finditemengine.h>

#include <finditemmenu.h>

#include <finditemdialog.h>

#include <FindItemmenu.rsg>

#include <csxhelp/nmake.hlp.hrh>

#include "NpdEdwin.h"

#include "NpdEditorDialog.h"

#include "NpdDialogBase.h"

#include "NpdListDialog.h"

#include "NpdModel_platsec.h"

#include "NpdApi.h"

#include "NpdLib.h"

#include "NpdEdwinLines.h"

#include "NpdLibPanic.h"

// CONSTANTS

const TInt KNotepadSequenceGranularity(10);

const TInt KNotepadInvalidSequenceIndex(-1);

//0x21b2 is the linefeed character

//const TChar linefeed(0x21B2);

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

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

// CNotepadEditorDialog::NewL

// Constructor.

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

//

EXPORT_C CNotepadEditorDialog* CNotepadEditorDialog::NewL(

    TInt aResId, 

    CNotepadModel* aModel,

    CNotepadListDialog* aListDialog,

    CSendUi* aSendUi

    )

    {

    __ASSERT_DEBUG(aModel, Panic(ENotepadLibraryPanicNoModel));

    CNotepadEditorDialog* self = 

        new(ELeave) CNotepadEditorDialog(*aModel, aListDialog);

    CleanupStack::PushL(self);

    TResourceReader rr;

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

    self->ConstructL( rr );

    CleanupStack::PopAndDestroy(); // rr

    CleanupStack::Pop(); // self

    self->iSendUi = aSendUi;

    return self;

    }

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

// CNotepadEditorDialog::ConstructL

// private second-phase constructor

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

//

void CNotepadEditorDialog::ConstructL( TResourceReader& aReader)

    {

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

    TPtrC ptr = aReader.ReadTPtrC();

    if ( ptr.Length() )

        {

        SetTitleL(&ptr);               // LTEXT title

        }

    iModel.SetNotepadModelObserver(this);

	iFindItemMenu = CFindItemMenu::NewL(ENotepadCmdFind);

	iRedrawBackground = EFalse;

	iTaskSwapperFlag=EFalse;

	User::LeaveIfError(iQwertyModeStatusProperty.Attach(KCRUidAvkon, KAknQwertyInputModeActive));

    if ( FeatureManager::FeatureSupported( KFeatureIdFfEnablePrintingFramework ) )

        {

        iServiceHandler = CAiwServiceHandler::NewL();

        iServiceHandler->AttachMenuL( R_NOTEPAD_EDITOR_MENU, R_PS_AIW_INTEREST );

        }

	}

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

// CNotepadEditorDialog::~CNotepadEditorDialog

// Destructor

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

//

EXPORT_C CNotepadEditorDialog::~CNotepadEditorDialog()

    {

    if ( iEditor )

        {

        iEditor->CancelFepTransaction();

        }

    if ( iListDialog )

        {

        iListDialog->EditorDeleted();

        }

    delete iSequence;

    delete iIdle;

	delete iFindItemMenu;

    delete iServiceHandler;

    }

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

// CNotepadEditorDialog::ExecuteLD

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

//

EXPORT_C TInt CNotepadEditorDialog::ExecuteLD()

    {

    CleanupStack::PushL(this);

    CreateSequenceL();

    CleanupStack::Pop(); // this

    return CNotepadDialogBase::ExecuteLD();

    }

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

// CNotepadEditorDialog::SwitchTextL

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

//

void CNotepadEditorDialog::SwitchTextL(TInt aKey) 

    {

    TInt err(KErrNone);

    __ASSERT_DEBUG( iEditor, Panic(ENotepadLibraryPanicNoEdwin) );

    if ( iModel.SeekKey(aKey) != 0 ) // not found

        {

        aKey = KNotepadPseudoKeyIdForNewNote;

        }

    TRAP(err,

        iEditor->ClearSelectionL();

        iEditor->Text()->Reset();

        iEditor->HandleTextChangedL();

        iEditor->SetCursorPosL(0, EFalse);

        if ( aKey != KNotepadPseudoKeyIdForNewNote )

            {

            HBufC* text = iModel.ContentByKeyL(aKey);

            CleanupStack::PushL(text);

            iEditor->SetTextL(text);

            CleanupStack::PopAndDestroy(); // text

            }

     	else

        	{

            iEditor->NotifyNewFormatL();

        	}

        iEditor->SetCursorPosL(0,EFalse);

        );

    if (err != KErrNone)

        {

        delete(this);

        User::Leave(err);

        }

    iKey = aKey; // set after switching is succeeded (important)

    if (iRedrawBackground)

    	{

    	iEditor->HandleResourceChange(KEikDynamicLayoutVariantSwitch);

    	iEditor->SetBackgroundColorL();

    	iRedrawBackground = EFalse;

    	}

    	iEditor->Text()->SetHasChanged(EFalse);

    	iEditor->DrawDeferred();

  }

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

// CNotepadEditorDialog::SaveOnExitL

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

//

TInt CNotepadEditorDialog::SaveOnExitL(

    TBool aNeedListRefresh )

    {

    TBool doSave( ( IsModeAdding() && !IsEmpty() ) ||

        ( IsModeEditing() && iEditor->Text()->HasChanged() ) );

    TInt statOfSave(CNotepadModel::ENotepadModelRowNop);

    TInt returnKey( iKey );

    iFlags &= ~ENotepadCatchSaveOnExitCallback;

    if ( doSave )

        {

        const TInt savedNextKey( NextKeyInSequence() );

        statOfSave = SaveL();

        returnKey = ( statOfSave == CNotepadModel::ENotepadModelRowDeleted ) ?

            savedNextKey : iKey;

        }

    if ( aNeedListRefresh )

        {

        iListDialog->HandleEditorExitL( statOfSave, returnKey,

            statOfSave == CNotepadModel::ENotepadModelRowNop || 

            iFlags & ENotepadCatchSaveOnExitCallback );

        }

    return statOfSave;

    }

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

// CNotepadEditorDialog::EditByKeyL

// This case is caused by Pinboard.

// If a pinned memo is selected by Pinboard while Notepad is 

// running in editor mode, we must change iEditorDialog's content

// instead of creating new EditorDialog.

//

// we don't need to save/switchtext if required memo is

// equivalent to the memo now being edited (ie. aKey == iKey)

//

// The editor did not work well after following operation:

//     1. Launch Notepad

//     2. Open a certain memo to switch into editor mode

//     3. Press application key to return shell

//     4. Launch Pinboard

//     5. Select "Write a note"

// then, no cursor will be displayed, numeric keys not work.

// We can fix this by adding:

//     iBaseAppUi->UpdateStackedControlFlags(iEditorDialog, 0, ~0);

// to this function.

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

//

void CNotepadEditorDialog::EditByKeyL(const TInt aKey, CAknAppUi& aAppUi)

    {

    if ( aKey == KNotepadPseudoKeyIdForNewNote // Pinboard "Write a Note"

        || aKey != iKey )

        {

        SaveL();

     	  SwitchTextL(aKey);	

        }

    aAppUi.UpdateStackedControlFlags(this, 0, ~0);

    DrawNow();

    }

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

// CNotepadEditorDialog::SetInitialKeyEventL

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

//

void CNotepadEditorDialog::SetInitialKeyEventL(const TKeyEvent& aKeyEvent)

    {

    iEvent = aKeyEvent;

    delete iIdle;

    iIdle = NULL;

    iIdle = CIdle::NewL(CActive::EPriorityUserInput);

    iIdle->Start(TCallBack(NumberKeyCallBack, this));

    }

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

// CNotepadEditorDialog::HandleNotepadModelEventL

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

//

void CNotepadEditorDialog::HandleNotepadModelEventL(

    TEvent aEvent, 

    TInt /*aParam*/ )

    {

    switch ( aEvent )

        {

        case EDatabaseChanged:

            iFlags |= ENotepadCatchSaveOnExitCallback;

            if ( (iModel.ItemArrayFlags()) & CNotepadModel::ENotepadItemArrayUpdateOnly )

            	{

            	iModel.SyncL(EFalse);

            	}

            if ( iStoreWait.IsStarted() )

                {

                iStoreWait.AsyncStop();

                }

            break;

        case ECompleteItemArrayChange:

            SyncSequenceL(ETrue);

            break;

        default:

            break;

        }

    }

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

// CNotepadEditorDialog::DynInitMenuPaneL

// from MEikMenuObserver

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

//

void CNotepadEditorDialog::DynInitMenuPaneL(

    TInt aResourceId,

    CEikMenuPane* aMenuPane)

    {

    __ASSERT_DEBUG(aResourceId > 0, Panic(ENotepadLibraryPanicNoMenuResource));

    __ASSERT_DEBUG(aMenuPane, Panic(ENotepadLibraryPanicNullMenuPane));

    __ASSERT_DEBUG(iEditor, Panic(ENotepadLibraryPanicNoEdwin));

    if ( iServiceHandler && iServiceHandler->HandleSubmenuL( *aMenuPane ) )

        {

        return;

        }

    iModel.SyncL(EFalse);

    CNotepadDialogBase::DynInitMenuPaneL( aResourceId, aMenuPane );

    SyncSequenceL(EFalse);

    TInt index;

    switch ( aResourceId )

        {

        case R_SENDUI_MENU:

            index = 2;   

			iSendUi->AddSendMenuItemL(*aMenuPane, index, ENotepadCmdSend /*TSendingCapabilities()*/ );

            break;

        case R_NOTEPAD_EDITOR_MENU: // when Notepad Editor

            {

            if ( FeatureManager::FeatureSupported( KFeatureIdFfEnablePrintingFramework ) )

                {

                // Initiliaze menu

                if ( !IsEmpty() )

                    {

                    if ( iServiceHandler )

                        {

                        CAiwGenericParamList& inParams = iServiceHandler->InParamListL();

                        iServiceHandler->InitializeMenuPaneL( *aMenuPane, 

                                                              aResourceId,  

                                                              ENotepadCmdPrint,

                                                              inParams

                                                             );

                        }

                    }

                else

                    {

                    aMenuPane->DeleteMenuItem( ENotepadCmdPrint );

                    }

                }

            else

                {

                aMenuPane->DeleteMenuItem( ENotepadCmdPrint );

                }

            const TBool empty(IsEmpty());

            if((empty && !iEditor->CcpuCanPaste()) || ( iFlags & ENotepadMenuByOkKey) || iEditor->IsReadOnly() )

                {

                aMenuPane->DeleteMenuItem( EAknCmdEditTextMenu ); 

                }

           #ifdef RD_INTELLIGENT_TEXT_INPUT    

            else

            {

            	aMenuPane->DeleteMenuItem( EAknCmdEditTextMenu ); 

            } 

            #endif

            if ( empty )

                {

                aMenuPane->DeleteMenuItem(ENotepadCmdAdd);

                }

            else

                {

				iSendUi->AddSendMenuItemL( *aMenuPane, 0, ENotepadCmdSend /*TSendingCapabilities()*/ ); // top item 

				if ( !( iFlags & ENotepadMenuByOkKey ) )

					{

					iFindItemMenu->DisplayFindItemMenuItemL(*aMenuPane, ENotepadCmdPreviousMemo);

					}

           		}

			if ( iFlags & ENotepadMenuByOkKey )

                {

                aMenuPane->DeleteMenuItem(ENotepadCmdNextMemo);

                aMenuPane->DeleteMenuItem(ENotepadCmdPreviousMemo);

                aMenuPane->DeleteMenuItem(EAknCmdExit);

				if(FeatureManager::FeatureSupported(KFeatureIdHelp))

					{

				aMenuPane->DeleteMenuItem(EAknCmdHelp);

					}

				}

            else

                {

                if ( IsSequenceAtLast() )

                    {

                    aMenuPane->DeleteMenuItem(ENotepadCmdNextMemo);

                    }

                if ( IsSequenceAtFirst() )

                    {

                    aMenuPane->DeleteMenuItem(ENotepadCmdPreviousMemo);

                    }

                }

			if(!FeatureManager::FeatureSupported(KFeatureIdHelp))

				{

				aMenuPane->DeleteMenuItem(EAknCmdHelp);

				}

			TLanguage language = User::Language();

			if(language == ELangJapanese || language == ELangEnglish_Japan)

			{

				aMenuPane->DeleteMenuItem(EAknCmdInputLanguage);	

		    }

		    else

		    {

			    if (iFlags & ENotepadMenuByOkKey)

			    {

			    	aMenuPane->DeleteMenuItem(EAknCmdInputLanguage);

			    }

			    #ifdef RD_INTELLIGENT_TEXT_INPUT   

			    else

			    {

			        aMenuPane->DeleteMenuItem(EAknCmdInputLanguage);

			    }

			   #endif

			}

		   	if(language == ELangPrcChinese || language ==ELangHongKongChinese || language ==ELangTaiwanChinese)

			{

				TInt checkQwertyStatus;	

				iQwertyModeStatusProperty.Get(checkQwertyStatus);

				if(!checkQwertyStatus )

				{

				aMenuPane->DeleteMenuItem(EAknCmdInputMethod);	

				}

			}

			else

			{

				aMenuPane->DeleteMenuItem(EAknCmdInputMethod);

			}

            }

            break;

           case R_NOTEPAD_TEMPLATE_EDITOR_MENU: // when Template Editor

            {

            const TBool empty(IsEmpty());

            if ( !empty )

                {

				iSendUi->AddSendMenuItemL( *aMenuPane, 0, ENotepadCmdSend /*TSendingCapabilities()*/ ); // top item

                }

            if ( iFlags & ENotepadMenuByOkKey )

                {

                aMenuPane->DeleteMenuItem(EAknCmdExit);

                if(FeatureManager::FeatureSupported(KFeatureIdHelp))

					{

                aMenuPane->DeleteMenuItem(EAknCmdHelp);

					}

                }

			if(!FeatureManager::FeatureSupported(KFeatureIdHelp))

				{

				aMenuPane->DeleteMenuItem(EAknCmdHelp);

				}

            }

            break;

		case R_FINDITEMMENU_MENU :

            {

            iFindItemMenu->DisplayFindItemCascadeMenuL(*aMenuPane);

            break;

            }

        default:

            break;

        }

    }

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

// CNotepadEditorDialog::DynInitMenuBarL

// from MEikMenuObserver

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

//    

void CNotepadEditorDialog::DynInitMenuBarL(

    TInt aResourceId,

    CEikMenuBar* aMenuBar )

{

	__ASSERT_DEBUG( aResourceId > 0, 

        Panic(ENotepadLibraryPanicNoMenuResource) );

    __ASSERT_DEBUG( aMenuBar, Panic(ENotepadLibraryPanicNoMenuResource) );

    if(!iTaskSwapperFlag )

    {

    aMenuBar->SetMenuType(CEikMenuBar::EMenuOptionsNoTaskSwapper);

    }

    else

    {

    	aMenuBar->SetMenuType(CEikMenuBar::EMenuOptions);

    	iTaskSwapperFlag=EFalse;	

    }

}

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

// CNotepadEditorDialog::ProcessCommandL

// from MEikCommandObserver

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

//

void CNotepadEditorDialog::ProcessCommandL(TInt aCommandId)

    {

    HideMenu();

	if ( iFindItemMenu && iFindItemMenu->CommandIsValidL( aCommandId ) )

        {

        	iFlags |= ENotepadFindItemRuning;

           TInt ret = DoSearchL( iFindItemMenu->SearchCase(aCommandId) );

		   if ( ret == EAknSoftkeyExit )

			{

				aCommandId = ret;

			}

			iFlags &= ~ENotepadFindItemRuning;

        }